index
int64 | repo_name
string | branch_name
string | path
string | content
string | import_graph
string |
|---|---|---|---|---|---|
31,470,600
|
WerWolfEee/simple-notes
|
refs/heads/master
|
/sql_app/main.py
|
from typing import List
from fastapi import Depends, FastAPI, HTTPException
from fastapi.security import OAuth2PasswordRequestForm
from sqlalchemy.orm import Session
import sql_app.crud as _crud
import sql_app.schemas as _schemas
import sql_app.services as _services
import sql_app.database as _database
def create_database():
return _database.Base.metadata.create_all(bind=_database.engine)
app = FastAPI()
@app.post("/users")
def create_user(user: _schemas.UserCreate, db: Session = Depends(_services.get_db)):
db_user = _crud.get_user_by_email(user.email, db)
if db_user:
raise HTTPException(status_code=400, detail="Email already registered")
new_user = _crud.create_user(user, db)
return _services.create_token(new_user)
@app.post("/token")
def generate_token(
form_data: OAuth2PasswordRequestForm = Depends(),
db: Session = Depends(_services.get_db),
):
user = _services.authenticate_user(form_data.username, form_data.password, db)
if not user:
raise HTTPException(status_code=401, detail="Invalid login or password")
return _services.create_token(user)
@app.get("/users/me", response_model=_schemas.User)
def read_user(user: _schemas.User = Depends(_crud.get_current_user)):
return user
@app.post("/notes", response_model=_schemas.Note)
def create_note_for_user(
note: _schemas.NoteCreate,
user: _schemas.User = Depends(_crud.get_current_user),
db: Session = Depends(_services.get_db)
):
return _crud.create_user_note(user=user, db=db, note=note)
@app.get("/notes", response_model=List[_schemas.Note])
def read_notes(
user: _schemas.User = Depends(_crud.get_current_user),
db: Session = Depends(_services.get_db)):
return _crud.get_notes(user=user, db=db)
@app.get("/notes/{note_id}", status_code=200)
def read_note(
note_id: int,
user: _schemas.User = Depends(_crud.get_current_user),
db: Session = Depends(_services.get_db)
):
return _crud.get_note(note_id, user, db)
@app.put("/notes/{note_id}", status_code=200)
def update_note_for_user(
note_id: int,
note: _schemas.NoteCreate,
user: _schemas.User = Depends(_crud.get_current_user),
db: Session = Depends(_services.get_db)
):
_crud.update_user_note(note_id, note, user, db)
return {"message": "Successfully updated"}
@app.delete("/notes/{note_id}")
def delete_note_for_user(
note_id: int,
user: _schemas.User = Depends(_crud.get_current_user),
db: Session = Depends(_services.get_db)
):
return _crud.delete_user_note(note_id, user, db)
|
{"/sql_app/main.py": ["/sql_app/database.py", "/sql_app/crud.py", "/sql_app/schemas.py", "/sql_app/services.py"], "/sql_app/services.py": ["/sql_app/database.py", "/sql_app/crud.py", "/sql_app/models.py", "/sql_app/schemas.py"], "/sql_app/models.py": ["/sql_app/database.py"], "/sql_app/crud.py": ["/sql_app/models.py", "/sql_app/schemas.py", "/sql_app/services.py"]}
|
31,470,601
|
WerWolfEee/simple-notes
|
refs/heads/master
|
/sql_app/schemas.py
|
from typing import List, Optional
from pydantic import BaseModel
class NoteBase(BaseModel):
title: str
description: Optional[str] = None
completion: Optional[bool] = False
class NoteCreate(NoteBase):
pass
class Note(NoteBase):
id: int
owner_id: int
class Config:
orm_mode = True
class UserBase(BaseModel):
email: str
class UserCreate(UserBase):
password: str
class Config:
orm_mode = True
class User(UserBase):
id: int
notes: List[Note] = []
class Config:
orm_mode = True
|
{"/sql_app/main.py": ["/sql_app/database.py", "/sql_app/crud.py", "/sql_app/schemas.py", "/sql_app/services.py"], "/sql_app/services.py": ["/sql_app/database.py", "/sql_app/crud.py", "/sql_app/models.py", "/sql_app/schemas.py"], "/sql_app/models.py": ["/sql_app/database.py"], "/sql_app/crud.py": ["/sql_app/models.py", "/sql_app/schemas.py", "/sql_app/services.py"]}
|
31,470,602
|
WerWolfEee/simple-notes
|
refs/heads/master
|
/sql_app/crud.py
|
from sqlalchemy.orm import Session
from fastapi import Depends, HTTPException
# from jose import jwt
from passlib import hash
import jwt
import sql_app.models as _models
import sql_app.schemas as _schemas
import sql_app.services as _services
def get_user_by_email(email: str, db: Session):
return db.query(_models.User).filter(_models.User.email == email).first()
def create_user(user: _schemas.UserCreate, db: Session):
user_obj = _models.User(
email=user.email, hashed_password=hash.bcrypt.hash(user.password)
)
db.add(user_obj)
db.commit()
db.refresh(user_obj)
return user_obj
def get_current_user(
db: Session = Depends(_services.get_db),
token: str = Depends(_services.oauth2schema)
):
try:
payload = jwt.decode(token, _services.JWT_SECRET, algorithms=["HS256"])
user = db.query(_models.User).get(payload["id"])
except:
raise HTTPException(status_code=401, detail="Invalid email or password")
return user
def get_notes(user: _schemas.User, db: Session):
notes = db.query(_models.Note).filter_by(owner_id=user.id)
return list(map(_schemas.Note.from_orm, notes))
def _note_selector(note_id: int, user: _schemas.User, db: Session):
note = (
db.query(_models.Note)
.filter_by(owner_id=user.id)
.filter(_models.Note.id == note_id)
.first()
)
if note is None:
raise HTTPException(status_code=404, detail="Note does not exist")
return note
def get_note(note_id: int, user: _schemas.User, db: Session):
note = _note_selector(note_id=note_id, user=user, db=db)
return _schemas.Note.from_orm(note)
def create_user_note(user: _schemas.User, db: Session, note: _schemas.NoteCreate):
db_note = _models.Note(**note.dict(), owner_id=user.id)
db.add(db_note)
db.commit()
db.refresh(db_note)
return _schemas.Note.from_orm(db_note)
def update_user_note(note_id: int, note: _schemas.NoteCreate, user: _schemas.User, db: Session):
current_note = _note_selector(note_id, user, db)
current_note.title = note.title
current_note.description = note.description
current_note.completion = note.completion
db.commit()
db.refresh(current_note)
return _schemas.Note.from_orm(current_note)
def delete_user_note(note_id: int, user: _schemas.User, db: Session):
current_note = _note_selector(note_id, user, db)
db.delete(current_note)
db.commit()
return {"message": "Note successfully deleted"}
|
{"/sql_app/main.py": ["/sql_app/database.py", "/sql_app/crud.py", "/sql_app/schemas.py", "/sql_app/services.py"], "/sql_app/services.py": ["/sql_app/database.py", "/sql_app/crud.py", "/sql_app/models.py", "/sql_app/schemas.py"], "/sql_app/models.py": ["/sql_app/database.py"], "/sql_app/crud.py": ["/sql_app/models.py", "/sql_app/schemas.py", "/sql_app/services.py"]}
|
31,548,401
|
vova123412/submarine
|
refs/heads/master
|
/ClientSide/SubmarinApp.py
|
from tkinter import *
from .GameFrame import *
class SubmarinApp(Tk):
def __init__(self):
Tk.__init__(self)
self.title("Welcome to LikeGeeks app")
self.geometry('1980x1300')
self.frame=GameFrame(self)
self.frame.grid(row=0,column=0)
self.showframe()
def showframe(self):
self.frame.tkraise()
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,402
|
vova123412/submarine
|
refs/heads/master
|
/server_sea_battle.py
|
from random import randint
import os
import socket
import json
from threading import Thread, Lock
import pickle
import time
from ServerSide.IActions import *
from ServerSide.playermannger import *
from ServerSide.prematch import *
class SocketMannager:
def __init__(self):
self.users=[]
self.threads=[]
HOST = '0.0.0.0'
PORT = 65432
self.sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((HOST, PORT))
self.sock.listen(5)
self.playermannger=PlayerMannger(self.users)
self.prematch=PreMatch(self.users,self.threads)
def acceptplayers(self):
player_idx=0
while player_idx<5:
conn, addr = self.sock.accept()
user={
'status':0,
'index':player_idx,
'addr':addr,
'sock':conn,
}
player_idx=player_idx+1
self.users.append(user)
self.threadplayermannger(conn,user)
self.semaphore =False
sys.exit()
def threadplayermannger(self,conn,user):
t = Thread(target=self.playermannger.play,args=(conn,user))
self.threads.append(t)
t.start()
def main():
socketmannager=SocketMannager()
socketmannager.prematch.threadfindmatch()
socketmannager.acceptplayers()
if __name__ == "__main__":
main()
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,403
|
vova123412/submarine
|
refs/heads/master
|
/ClientSide/SubmarinGame.py
|
import socket
import pickle
class SubmarinGame:
def __init__(self,sock,frame):
self.sock=sock
self.frame=frame
def Actions_loop(self):
while True:
action_strategy=pickle.loads(self.sock.recv(1024))
if action_strategy.do_action(self.sock,self.frame)==0:
break
print("SubmarinGame Over")
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,404
|
vova123412/submarine
|
refs/heads/master
|
/ClientSide/Ship.py
|
from tkinter import *
class Ship(Label):
def __init__(self,frame,width,height,image):
self.x=50
self.y=50
self.minwidth=5
self.minheitght=5
self.width=width
self.height=height
self.ship=Label(frame,text="ship",width=width,height=height,bg="green")
self.ship.grid(row=1,column=1)
self.make_draggable(self.ship)
def stopdrag(self):
self.ship.unbind("<Button-1>")
self.ship.unbind("<B1-Motion>")
def getcoordinate(self):
if self.width>=self.height:
return self.validatewidthcoordinate()
else:
return self.validateheightcoordinate()
def validatewidthcoordinate(self):
coordinate=[]
width=self.width
while width>0:
if(int((self.x/50+width/self.minwidth-1))*10+int(self.y/50)<100 and int(self.y/50)>0 and int(self.x/50)>0):
coordinate.append(int((self.x/50+width/self.minwidth-1))*10+int(self.y/50))
width=width-self.minwidth
return coordinate
def validateheightcoordinate(self):
coordinate=[]
height=self.height
while height>0:
if(int(self.x/5)+int(self.y/50+height/self.minheight)<100):
coordinate.append(int(self.x/5)+int(self.y/50+height/self.minheight-1) and int(self.y/50)>0 and int(self.x/50))
heiht=height-self.minheight
return coordinate
def make_draggable(self,widget):
widget.bind("<Button-1>", self.on_drag_start)
widget.bind("<B1-Motion>", self.on_drag_motion)
def on_drag_start(self,event):
widget = event.widget
widget._drag_start_x = event.x
widget._drag_start_y = event.y
def on_drag_motion(self,event):
widget = event.widget
self.x = widget.winfo_x() - widget._drag_start_x + event.x
self.y = widget.winfo_y() - widget._drag_start_y + event.y
if self.x<=(460-(self.width/self.minwidth-1)*50) and int(self.x/50)>0 and self.y<=(460-(self.height/self.minheitght-1)*50) and int(self.y/50)>0:
print(f'x {self.x/50:} y: {self.y/50:}')
shiplist=self.getcoordinate()
for i in shiplist:
print(i)
widget.place(x=int(self.x),y=int(self.y))
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,405
|
vova123412/submarine
|
refs/heads/master
|
/ClientSide/ConnectionMannger.py
|
from .SubmarinGame import *
import socket
import pickle
import time
import threading
class ConnectionMannger:
def __init__(self,frame):
self.value=""
self.sock= socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.mySubmarinGame=SubmarinGame(self.sock,frame)
self.threads=[]
self.HOST = '127.0.0.1'
self.PORT = 65432
self.t=None
def Init_Connection(self):
self.sock.connect((self.HOST, self.PORT))
def Play(self):
self.t = threading.Thread(target=self.mySubmarinGame.Actions_loop,args=())
self.threads.append(self.t)
self.t.start()
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,406
|
vova123412/submarine
|
refs/heads/master
|
/ServerSide/facadesubmaringame.py
|
from random import randint
import os
import socket
from .prematch import *
from .IActions import *
import json
from threading import Thread, Lock
import pickle
import time
class FacadeSubmarinGame:
def __init__(self,player_one_sock,player_two_sock,player_one_idx,player_two_idx,prematch):
self.prematch=prematch
self.player_idx=player_one_idx
self.player2_idx=player_two_idx
self.player_conn=player_one_sock
self.player_map=[]
self.player2_conn=player_two_sock
self.player2_map=[]
self.action={
"Send_Ship":Send_Ship(),
"Turn":Turn(),
"Miss":Miss(),
"Hit":Hit(),
"Win":Win(),
"Lose":Lose(),
"Error":Error(),
}
def startgame(self):
self.init_players_boards()
self.playonevsone(self.player_conn,self.player_map,self.player2_conn,self.player2_map)
def init_players_boards(self):
self.player_map= self.init_game_board(self.player_conn)
self.player2_map=self.init_game_board(self.player2_conn)
def init_game_board(self,conn):
self.sendaction(conn,self.action["Send_Ship"])
ship_array=pickle.loads(conn.recv(1024))
while self.validate_game_board(ship_array)==False:
self.sendaction(conn,self.action["Send_Ship"])
ship_array=pickle.loads(conn.recv(1024))
return ship_array
def validate_game_board(self,ship_array):
try:
for i in ship_array:
print(type(i))
if i<=9 or i>100 or (i>9 and i%10==0):
print("fail")
return False
return True
except:
conn.send(self.action["Error"])
return False
def playonevsone(self,sock,shiplist,sock2,shiplist2):
print("\n \n",shiplist,shiplist2)
while len(shiplist)!=0 and len(shiplist2)!=0:
if self.turnplayer(sock,shiplist,sock2,shiplist2)==False:
break
if self.turnplayer(sock2,shiplist2,sock,shiplist)==False:
break
self.changestatusendgame(self.player2_idx,self.player_idx)
def changestatusendgame(self,index,index2):
self.prematch.changestatusendgame(index,index2)
def turnplayer(self,sock,shiplist,sock2,shiplist2):
self.sendaction(sock,self.action["Turn"])
coordinate=int(self.recv_coordinate(sock))
return self.replyaction(sock,shiplist,sock2,shiplist2,coordinate)
def replyaction(self,sock,shiplist,sock2,shiplist2,coordinate):
if self.searchinshiplist(coordinate,shiplist2):
self.action["Hit"].set_coordinate(coordinate)
self.sendaction(sock,self.action["Hit"])
shiplist2.remove(coordinate)
if(len(shiplist2)==0):
self.sendaction(sock,self.action["Win"])
self.sendaction(sock2,self.action["Lose"])
return False
return True
self.action["Miss"].set_coordinate(coordinate)
self.sendaction(sock,self.action["Miss"])
return True
def searchinshiplist(self,coordinate,shiplist):
for i in shiplist:
if coordinate == i:
return True
return False
def sendaction(self,conn,action):
encodeaction=pickle.dumps(action)
conn.send(encodeaction)
def recv_coordinate(self,sock):
while True:
data=sock.recv(1024).decode("ascii")
if data:
print(" \n the data is :",data)
return data
break
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,407
|
vova123412/submarine
|
refs/heads/master
|
/ServerSide/playermannger.py
|
from .IActions import *
from random import randint
import os
import socket
import json
from threading import Thread, Lock
import pickle
import time
class PlayerMannger:
def __init__(self,users):
self.users=users
self.semaphore =True
def play(self,conn,user):
while self.semaphore :
if self.users[user['index']]['status']!=2 and self.users[user['index']]['status']!=1:
self.sendaction(conn,Options())
option= self.recv_option(conn)
if option=="search":
self.sendaction(conn,WaitForOpponent())
self.searchgamestatus(user)
print(self.users[user['index']]['status'])
time.sleep(3)
def sendaction(sel,conn,action):
encodeaction=pickle.dumps(action)
conn.send(encodeaction)
def recv_option(self,sock):
while True:
option=sock.recv(1024).decode("ascii")
if option:
print(" \n the option is :",option)
return option
break
def searchgamestatus(self,user):
self.users[user['index']]['status']=1
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,408
|
vova123412/submarine
|
refs/heads/master
|
/ClientSide/ShipBuilder.py
|
from tkinter import *
from .Ship import *
class ShipBuilder():
def __init__(self,frame):
self.frame=frame
self.image1 = PhotoImage(file="tenor.gif")
@staticmethod
def buildship(size,frame,image1):
if size=="small":
return Ship(frame,width=5,height=5,image=image1)
elif size=="middle":
return Ship(frame,width=10,height=5,image=image1)
elif size=="large":
return Ship(frame,width=15,height=5,image=image1)
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,409
|
vova123412/submarine
|
refs/heads/master
|
/ServerSide/prematch.py
|
from .facadesubmaringame import *
from random import randint
import os
import socket
import json
from threading import Thread, Lock
import pickle
import time
class PreMatch:
def __init__(self,users,threads):
self.users=users
self.threads=threads
self.semaphore =True
def threadfindmatch(self):
matches= Thread(target=self.findmatch)
self.threads.append(matches)
matches.start()
def findmatch(self):
while self.semaphore :
players_idx=self.searchforgames()
if players_idx !=None:
print(players_idx)
self.changestatusingame(players_idx[0],players_idx[1])
match=Thread(target=self.create_new_game,args=(players_idx[0],players_idx[1]))
self.threads.append(match)
match.start()
def changestatusingame(self,player_one_idx,player_two_idx):
self.users[player_one_idx]['status']=2
self.users[player_two_idx]['status']=2
def changestatusendgame(self,player_one_idx,player_two_idx):
self.users[player_one_idx]['status']=0
self.users[player_two_idx]['status']=0
def create_new_game(self,player_one_idx,player_two_idx):
one_vs_one=FacadeSubmarinGame(self.users[player_one_idx]['sock'],self.users[player_two_idx]['sock'],player_one_idx,player_two_idx,self)
one_vs_one.startgame()
def searchforgames(self):
while self.semaphore :
players_idx=[]
for i in self.users:
if i['status']==1:
players_idx.append(i['index'])
if len(players_idx)==2:
print("match found")
return players_idx
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,410
|
vova123412/submarine
|
refs/heads/master
|
/ClientSide/GameFrame.py
|
from tkinter import *
from .ConnectionMannger import *
from .ShipBuilder import *
class GameFrame(Frame):
def __init__(self,parent):
Frame.__init__(self,parent,width=1000, height=1000)
self.labelsboard=[]
self.image1 = PhotoImage(file="tenor.gif")
self.sendcoordinatebutton=None
self.startgame=None
self.shipslist=[]
self.initbuttons()
self.initboards()
self.initships()
self.player=ConnectionMannger(self)
def initconnection(self):
self.player.Init_Connection()
self.player.Play()
def initbuttons(self):
self.sendcoordinatebutton=Button(self,width=20,pady=10, text="send ships",bg="red",command=lambda: self.getcoordinatelist())
self.sendcoordinatebutton.grid(row=2,column=20)
self.startgame=Button(self,width=20,pady=10, text="connect",bg="red",command=lambda: self.initconnection())
self.startgame.grid(row=45,column=80)
def initboards(self):
for i in range(0,100):
self.labelsboard.append(Label(self,text=str(i),padx=17,pady=17 ))
self.labelsboard[i].grid(row=int(i/10),column=int(i%10))
Label(self,text="Enemy board =>",padx=17,pady=17).grid(row=5,column=20)
Label(self,text="<= your board dnd ship ",padx=17,pady=17).grid(row=4,column=20)
for i in range(0,100):
self.labelsboard.append(Label(self,text=str(i),padx=17,pady=17 ))
self.labelsboard[i+100].grid(row=int(i/10),column=int(i%10)+50)
def getcoordinatelist(self):
coordinate=[]
for ship in self.shipslist:
for i in ship.getcoordinate():
coordinate.append(i)
return coordinate
def unbindshipslist(self):
for ship in self.shipslist:
ship.stopdrag()
def initships(self):
self.shipslist.append(ShipBuilder.buildship("small",self,self.image1))
self.shipslist.append(ShipBuilder.buildship("middle",self,self.image1))
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,548,411
|
vova123412/submarine
|
refs/heads/master
|
/ServerSide/IActions.py
|
from abc import ABC, abstractmethod
import pickle
class IActions(ABC):
def __init__(self):
super().__init__()
@abstractmethod
def do_action(self):
pass
class Win(IActions):
def __init__(self,):
pass
def do_action(self,sock,frame):
print("Win")
sock.close()
return 0
class WaitForOpponent(IActions):
def __init__(self,):
pass
def do_action(self,sock,frame):
frame.startgame.configure(text="wait for opponent",command= lambda :self.donothing())
print("wait for opponent")
def donothing(self):
pass
class Turn(IActions):
def __init__(self,):
pass
def do_action(self,sock,frame):
print("Turn")
frame.sendcoordinatebutton.configure(command= lambda :self.donothing())
frame.startgame.config(text="attak")
for i in range(0,100):
if(int(i/10)!=0 and int(i%10)!=0):
frame.labelsboard[i+100].bind("<1>",lambda e,i=i:self.send_coordinate(frame,sock,i))
return 10
def send_coordinate(self,frame,sock,coordinate):
print("the coordinate is ",coordinate)
sock.send(str(coordinate).encode('ascii'))
for i in range(0,100):
if(int(i/10)!=0 and int(i%10)!=0):
frame.labelsboard[i+100].bind("<1>",lambda e,i=i:self.donothing())
def donothing(self):
pass
class Miss(IActions):
def __init__(self,):
self.coordinate=11
def do_action(self,sock,frame):
print("Miss")
frame.labelsboard[self.coordinate+100].configure(text="miss",bg="white")
frame.labelsboard[self.coordinate+100].tkraise()
def set_coordinate(self,coordinate):
self.coordinate=int(coordinate)
class Lose(IActions):
def __init__(self,):
pass
def do_action(self,sock,frame):
print("Lose")
sock.close()
return 0
class Hit(IActions):
def __init__(self,):
self.coordinate=11
def do_action(self,sock,frame):
print("hit")
frame.labelsboard[self.coordinate+100].configure(text="hit",bg="red")
frame.labelsboard[self.coordinate+100].tkraise()
def set_coordinate(self,coordinate):
self.coordinate=int(coordinate)
#what data
class Send_Ship(IActions):
def __init__(self):
pass
def do_action(self,sock,frame):
print("init your ships")
frame.startgame.config(text="init board ",command= lambda: self.donothing())
frame.sendcoordinatebutton.configure(command= lambda :self.send_List(sock,frame))
return 10
def donothing(self):
pass
def send_List(self,sock,frame):
shiplist=frame.getcoordinatelist()
frame.unbindshipslist()
pshiplist=pickle.dumps(shiplist)
sock.send(pshiplist)
class Options(IActions):
def __init__(self):
pass
def do_action(self,sock,frame):
sock.send("search".encode("ascii"))
class Error(IActions):
def __init__(self):
pass
def do_action(self,sock,frame):
print("error")
return 0
|
{"/Actions/Hit.py": ["/Actions/IActions.py"], "/Actions/Win.py": ["/Actions/IActions.py"], "/client_sea_battle.py": ["/Actions/IActions.py"], "/Actions/Lose.py": ["/Actions/IActions.py"], "/Actions/Miss.py": ["/Actions/IActions.py"], "/Actions/Turn.py": ["/Actions/IActions.py"], "/server_sea_battle.py": ["/Actions/IActions.py", "/ServerSide/IActions.py", "/ServerSide/playermannger.py", "/ServerSide/prematch.py"], "/ClientSide/SubmarinApp.py": ["/ClientSide/GameFrame.py"], "/ClientSide/ConnectionMannger.py": ["/ClientSide/SubmarinGame.py"], "/ServerSide/facadesubmaringame.py": ["/ServerSide/prematch.py", "/ServerSide/IActions.py"], "/ServerSide/playermannger.py": ["/ServerSide/IActions.py"], "/ClientSide/ShipBuilder.py": ["/ClientSide/Ship.py"], "/ServerSide/prematch.py": ["/ServerSide/facadesubmaringame.py"], "/ClientSide/GameFrame.py": ["/ClientSide/ConnectionMannger.py", "/ClientSide/ShipBuilder.py"]}
|
31,574,352
|
andreeamonu/FSND
|
refs/heads/master
|
/test_app.py
|
import os
import unittest
import json
from flask_sqlalchemy import SQLAlchemy
from app import create_app
from sqlalchemy import String, Integer
from models import setup_db, Movie, Actor
#----------------------------------------------------------------------------#
# Movies tests
#----------------------------------------------------------------------------#
class MovieTestCase(unittest.TestCase):
#This class represents the movie test cases
def setUp(self):
#Define test variables and initialize app.
self.app = create_app()
self.client = self.app.test_client
self.database_name = "casting_test"
self.database_path = "postgresql://{}/{}".format('localhost:5432',self.database_name)
setup_db(self.app, self.database_path)
# bind app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create tables
self.db.create_all()
#----------------------------------------------------------------------------#
# Define tokens
#----------------------------------------------------------------------------#
self.casting_assistant_token = "Bearer {}".format(os.environ.get('CASTING_ASSISTANT_TOKEN'))
self.casting_director_token = "Bearer {}".format(os.environ.get('CASTING_DIRECTOR_TOKEN'))
self.executive_producer_token = "Bearer {}".format(os.environ.get('EXECUTIVE_PRODUCER_TOKEN'))
def tearDown(self):
#Executed after each test
pass
# Test successful request to get movies
def test_get_all_movies(self):
res = self.client().get('/movies',headers={'Authorization':self.casting_assistant_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['movies']))
# Test successful request to create a movie
def test_create_movie(self):
new_movie = {
'title': 'Inception',
'release_date': '20 July 2010'
}
res = self.client().post('/movies', json=new_movie, headers={'Authorization':self.executive_producer_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['movies'])
self.assertTrue(len(data['movies']))
# Test unsuccessful request to create a movie when movie id is mentioned
def test_405_if_movie_creation_is_not_allowed(self):
new_movie = {
'title': 'Inception',
'release_date': '20 July 2010'
}
res = self.client().post('/movies/1', json=new_movie,headers={'Authorization':self.executive_producer_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 405)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'method not allowed')
# Test successful request to update a movie
def test_update_movie(self):
updated_movie = {
'title': 'Inception',
'release_date': '16 July 2010'
}
res = self.client().patch('/movies/3', json=updated_movie, headers={'Authorization':self.casting_director_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['movies']))
# Test unsuccessful request to update a movie when no data is mentioned
def test_405_if_data_is_missing_from_movies_update_request(self):
res = self.client().patch('/movies', headers={'Authorization': self.executive_producer_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 405)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'method not allowed')
# Test successful request to delete a movie
def test_delete_movie(self):
res = self.client().delete('/movies/2', headers={'Authorization': self.executive_producer_token})
data = json.loads(res.data)
movie = Movie.query.filter(Movie.id == 2).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['movie'])
# Test unsuccessful request to delete a movie that does not exist
def test_404_when_deleting_a_movie_that_does_not_exist(self):
res = self.client().delete('/movies/200', headers={'Authorization': self.executive_producer_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
def test_401_when_no_token_is_passed(self):
res = self.client().get('/movies')
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
#----------------------------------------------------------------------------#
# Actors tests
#----------------------------------------------------------------------------#
class ActorTestCase(unittest.TestCase):
#This class represents the actor test cases
def setUp(self):
#Define test variables and initialize app
self.app = create_app()
self.client = self.app.test_client
self.database_name = "casting_test"
self.database_path = "postgresql://{}/{}".format('localhost:5432',self.database_name)
setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all()
#----------------------------------------------------------------------------#
# Define tokens
#----------------------------------------------------------------------------#
self.casting_assistant_token = "Bearer {}".format(os.environ.get('CASTING_ASSISTANT_TOKEN'))
self.casting_director_token = "Bearer {}".format(os.environ.get('CASTING_DIRECTOR_TOKEN'))
self.executive_producer_token = "Bearer {}".format(os.environ.get('EXECUTIVE_PRODUCER_TOKEN'))
def tearDown(self):
"""Executed after reach test"""
pass
# Test successful request to get actors
def test_get_actors(self):
res = self.client().get('/actors', headers={'Authorization': self.casting_assistant_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['actors']))
# Test successful request to create an actor
def test_create_actor(self):
new_actor = {
'name': 'Marion Cotillard',
'age': 45,
'gender': 'Female'
}
res = self.client().post('/actors', json=new_actor, headers={'Authorization': self.executive_producer_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actors'])
self.assertTrue(len(data['actors']))
# Test unsuccessful request to create an actor when actor id is mentioned
def test_405_if_actor_creation_is_not_allowed(self):
new_actor = {
'name': 'Marion Cotillard',
'age': 45,
'gender': 'Female'
}
res = self.client().post('/actors/1', json=new_actor, headers={'Authorization': self.executive_producer_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 405)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'method not allowed')
# Test successful request to update an actor
def test_update_actor(self):
updated_actor = {
'name': 'Anne Hathaway',
'age': 38,
'gender': 'Female'
}
res = self.client().patch('/actors/3', json=updated_actor, headers={'Authorization': self.casting_director_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['actors']))
# Test unsuccessful request to update an actor when no data is mentioned
def test_405_if_data_is_missing_from_actors_update_request(self):
res = self.client().patch('/actors', headers={'Authorization': self.executive_producer_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 405)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'method not allowed')
# Test successful request to delete an actor
def test_delete_actor(self):
res = self.client().delete('/actors/2', headers={'Authorization': self.executive_producer_token})
data = json.loads(res.data)
actor = Actor.query.filter(Actor.id == 2).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actor'])
# Test unsuccessful request to delete an actor that does not exist
def test_404_when_deleting_an_actor_that_does_not_exist(self):
res = self.client().delete('/actors/200', headers={'Authorization':self.casting_director_token})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
def test_401_when_no_token_is_passed(self):
res = self.client().get('/actors')
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
# Make the tests executable
if __name__ == "__main__":
unittest.main()
|
{"/projects/01_fyyur/starter_code/app.py": ["/models.py"], "/projects/02_trivia_api/starter/backend/flaskr/__init__.py": ["/models.py"], "/test_app.py": ["/app.py", "/models.py"], "/app.py": ["/models.py"]}
|
31,574,353
|
andreeamonu/FSND
|
refs/heads/master
|
/env/bin/django-admin.py
|
#!/Users/andreeamonu/dev/code/udacity-nanodegree/FSND/projects/04_casting/env/bin/python3
from django.core import management
if __name__ == "__main__":
management.execute_from_command_line()
|
{"/projects/01_fyyur/starter_code/app.py": ["/models.py"], "/projects/02_trivia_api/starter/backend/flaskr/__init__.py": ["/models.py"], "/test_app.py": ["/app.py", "/models.py"], "/app.py": ["/models.py"]}
|
31,574,354
|
andreeamonu/FSND
|
refs/heads/master
|
/app.py
|
import os
import json
from flask import Flask, request, jsonify, abort
from flask_sqlalchemy import SQLAlchemy
from flask_cors import CORS
from models import setup_db, Movie, Actor
from auth import requires_auth, AuthError
def create_app(test_config=None):
app = Flask(__name__)
setup_db(app)
CORS(app)
# CORS(app) for all origins
cors = CORS(app, resources={r"/*": {"origins": "*"}})
# db_drop_and_create_all()
# CORS Headers
@app.after_request
def after_request(response):
# Allow requests headers ( Content-Type, Authorization)
response.headers.add('Access-Control-Allow-Headers',
'Content-Type,Authorization,true')
# Allow specific requests methods (GET, POST, PATCH, DELETE, OPTIONS)
response.headers.add('Access-Control-Allow-Methods',
'GET,PATCH,POST,DELETE,OPTIONS')
return response
# Endpoints
# Health endpoint
@app.route('/')
def health():
return jsonify("Healthy")
#----------------------------------------------------------------------------#
# Movies
#----------------------------------------------------------------------------#
# Retrieve movies
@app.route('/movies')
@requires_auth('get:movies')
def get_movies(payload):
movies = Movie.query.order_by(Movie.id).all()
movies = [movie.format() for movie in movies]
# return 404 if no movie is found
if len(movies) == 0:
abort(404)
# return data for movies
return jsonify({
'success': True,
'movies': movies,
'number_of_movies': len(Movie.query.all())
}), 200
# Create movies
@app.route('/movies', methods=['POST'])
@requires_auth("post:movies")
def post_movies(payload):
# get movies information
body = request.get_json()
if not ('title' in body or 'release_date' in body):
abort(422)
new_title = body.get('title')
new_release_date = body.get('release_date')
# update database with new movie details
movie = Movie(title=new_title,
release_date=new_release_date)
try:
movie.insert()
# return data for new movie
return jsonify({
'success': True,
'movies': movie.format(),
'number_of_movies': len(Movie.query.all())
}), 200
# return 422 if any problem happens
except Exception as e:
print(e)
# Update movie details
@app.route('/movies/<int:movie_id>', methods=['PATCH'])
@requires_auth("patch:movies")
def update_movie(payload, movie_id):
# get movie information
body = request.get_json()
updated_title = body.get("title", None)
updated_release_date = body.get("release_date", None)
try:
movie = Movie.query.filter(Movie.id == movie_id).one_or_none()
# return 404 if no movie matches the ID
if movie is None:
abort(404)
# update the movie
if updated_title is not None:
movie.title = json.dumps(updated_title)
if updated_release_date is not None:
movie.release_date = json.dumps(updated_release_date)
movie.update()
# return data for updated movie
return jsonify({
'success': True,
'movies': [movie.format()]
}), 200
# return 422 if any problem happens
except Exception as e:
print(e)
# Delete movie
@app.route('/movies/<int:movie_id>', methods=['DELETE'])
@requires_auth("delete:movies")
def delete_movie(payload, movie_id):
movie = Movie.query.filter(Movie.id == movie_id).one_or_none()
# return 404 if no movie matches the ID
if movie is None:
abort(404)
# delete the movie
try:
movie.delete()
# return data for deleted movie
return jsonify({
'success': True,
'movie': [movie.format()]
}), 200
# return 422 if any problem happens
except Exception as e:
print(e)
#----------------------------------------------------------------------------#
# Actors
#----------------------------------------------------------------------------#
# Retrieve actors
@app.route('/actors')
@requires_auth('get:actors')
def get_actors(payload):
actors = Actor.query.order_by(Actor.id).all()
actors = [actor.format() for actor in actors]
# return 404 if no actor is found
if len(actors) == 0:
abort(404)
# return data for actors
return jsonify({
'success': True,
'actors': actors,
'number_of_actors': len(Actor.query.all())
}), 200
# Create actors
@app.route('/actors', methods=['POST'])
@requires_auth("post:actors")
def post_actors(payload):
# get actor information
body = request.get_json()
if not ('name' in body or 'age' in body or 'gender' in body):
abort(422)
new_name = body.get('name')
new_age = body.get('age')
new_gender = body.get('gender')
# update database with new actor details
actor = Actor(name=new_name,
age=new_age,
gender=new_gender)
try:
actor.insert()
# return data for new actor
return jsonify({
'success': True,
'actors': actor.format(),
'number_of_actors': len(Actor.query.all())
}), 200
# return 422 if any problem happens
except Exception as e:
print(e)
# Update actor details
@app.route('/actors/<int:actor_id>', methods=['PATCH'])
@requires_auth("patch:actors")
def update_actor(payload, actor_id):
# get actor information
body = request.get_json()
updated_name = body.get('name', None)
updated_age = body.get('age', None)
updated_gender = body.get('gender', None)
try:
actor = Actor.query.filter(Actor.id == actor_id).one_or_none()
# return 404 if no actor matches the ID
if actor is None:
abort(404)
# update the actor
if updated_name is not None:
actor.name = json.dumps(updated_name)
if updated_age is not None:
actor.age = json.dumps(updated_age)
if updated_gender is not None:
actor.gender = json.dumps(updated_gender)
actor.update()
# return data for updated actor
return jsonify({
'success': True,
'actors': [actor.format()]
}), 200
# return 422 if any problem happens
except Exception as e:
print(e)
# Delete actor
@app.route('/actors/<int:actor_id>', methods=['DELETE'])
@requires_auth("delete:actors")
def delete_actor(payload, actor_id):
actor = Actor.query.filter(Actor.id == actor_id).one_or_none()
# return 404 if no actor matches the ID
if actor is None:
abort(404)
# delete the actor
try:
actor.delete()
# return data for deleted actor
return jsonify({
'success': True,
'actor': [actor.format()]
}), 200
# return 422 if any problem happens
except Exception as e:
print(e)
#----------------------------------------------------------------------------#
# Errors Handling
#----------------------------------------------------------------------------#
# User Error
@app.errorhandler(400)
def bad_request(error):
return jsonify({
"success":False,
"error":400,
"message": "bad request"
}), 400
# Unauthorised Error
@app.errorhandler(401)
def unauthorised(error):
return jsonify({
"success":False,
"error":401,
"message": "unauthorised"
}), 401
# Forbidden Error
@app.errorhandler(403)
def forbidden(error):
return jsonify({
"success":False,
"error":403,
"message": "forbidden"
}), 403
# Not found Error
@app.errorhandler(404)
def not_found(error):
return jsonify({
"success":False,
"error":404,
"message": "resource not found"
}), 404
# Method requested Error
@app.errorhandler(405)
def not_allowed(error):
return jsonify({
"success":False,
"error":405,
"message": "method not allowed"
}), 405
# Unprocessable Request
@app.errorhandler(422)
def unprocessable(error):
return jsonify({
"success":False,
"error":422,
"message": "unprocessable"
}), 422
# Server Error
@app.errorhandler(500)
def internal_server_error(error):
return jsonify({
"success":False,
"error":500,
"message": "internal server error"
}), 500
# Authorisation Error
@app.errorhandler(AuthError)
def handle_auth_error(ex):
"""
Receive the raised authorization error and propagates it as response
"""
response = jsonify(ex.error)
response.status_code = ex.status_code
return response
return app
#----------------------------------------------------------------------------#
# Launch
#----------------------------------------------------------------------------#
app = create_app()
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8080, debug=True)
|
{"/projects/01_fyyur/starter_code/app.py": ["/models.py"], "/projects/02_trivia_api/starter/backend/flaskr/__init__.py": ["/models.py"], "/test_app.py": ["/app.py", "/models.py"], "/app.py": ["/models.py"]}
|
31,574,355
|
andreeamonu/FSND
|
refs/heads/master
|
/models.py
|
import os
from sqlalchemy import Column, String, Integer, Date, create_engine
from flask_sqlalchemy import SQLAlchemy
import json
database_name = "casting"
database_path = "postgresql://local-admin@localhost:5432/casting"
db = SQLAlchemy()
'''
setup_db(app)
binds a flask application and a SQLAlchemy service
'''
def setup_db(app, database_path=database_path):
app.config["SQLALCHEMY_DATABASE_URI"] = database_path
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db.app = app
db.init_app(app)
'''
db_drop_and_create_all()
drops the database tables and starts fresh
can be used to initialize a clean database
'''
def db_drop_and_create_all():
db.drop_all()
db.create_all()
'''
Movies
Have title and release date
'''
class Movie(db.Model):
__tablename__ = 'movies'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), nullable=False)
release_date = db.Column(db.String(200), nullable=False)
def __init__(self, title, release_date):
self.title = title
self.release_date = release_date
def format(self):
return {
'id': self.id,
'title': self.title,
'release_date': self.release_date
}
def __repr__(self):
return f"( Movie {self.id} {self.title} {self.release_date} )"
'''
insert()
inserts a new model into the database
'''
def insert(self):
db.session.add(self)
db.session.commit()
'''
delete()
deletes a model from the database
the model must exist in the database
'''
def delete(self):
db.session.delete(self)
db.session.commit()
'''
update()
updates a model from the database
the model must exist in the database
'''
def update(self):
db.session.commit()
'''
Actors
Have name, age and gender
'''
class Actor(db.Model):
__tablename__ = 'actors'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
age = db.Column(db.Integer, nullable=False)
gender = db.Column(db.String(100), nullable=False)
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def format(self):
return {
'id': self.id,
'name': self.name,
'age': self.age,
'gender': self.gender
}
def __repr__(self):
return f"( Actor {self.id} {self.name} {self.age} {self.gender} )"
'''
insert()
inserts a new model into the database
'''
def insert(self):
db.session.add(self)
db.session.commit()
'''
delete()
deletes a model from the database
the model must exist in the database
'''
def delete(self):
db.session.delete(self)
db.session.commit()
'''
update()
updates a model from the database
the model must exist in the database
'''
def update(self):
db.session.commit()
|
{"/projects/01_fyyur/starter_code/app.py": ["/models.py"], "/projects/02_trivia_api/starter/backend/flaskr/__init__.py": ["/models.py"], "/test_app.py": ["/app.py", "/models.py"], "/app.py": ["/models.py"]}
|
31,606,904
|
hav4ik/rock-paper-scissors
|
refs/heads/master
|
/kumoko/strategies/rfind.py
|
import random
from kumoko.kumoko_base import *
class RFindStrategy(BaseAtomicStrategy):
def __init__(self, limit=None, src='his'):
self.limit = limit
self.src = src
def __call__(self, history):
if len(history) == 0:
return NUM_TO_MOVE[random.randint(0, 2)]
# Type of lookback sequence
if self.src == 'his':
sequence = history.his_moves
elif self.src == 'our':
sequence = history.our_moves
elif self.src == 'dna':
sequence = history.dna_moves
else:
raise ValueError(f'Invalid `src` value (got {self.src}')
# Define lookback window
length = len(history)
if self.limit == None:
lb = length
else:
lb = min(length, self.limit)
# RFind choose action
while lb >= 1 and \
not sequence[length - lb:length] in sequence[0:length - 1]:
lb -= 1
if lb >= 1:
if random.random() < 0.6:
idx = sequence.rfind(
sequence[length - lb:length], 0, length - 1)
elif random.random() < 0.5:
idx = sequence.rfind(
sequence[length - lb:length], 0, length - 1)
idx2 = sequence.rfind(
sequence[length - lb:length], 0, idx)
if idx2 != -1:
idx = idx2
else:
idx = sequence.find(
sequence[length - lb:length], 0, length - 1)
return BEAT[history.his_moves[idx + lb]]
else:
return random.choice('RPS')
|
{"/dojo.py": ["/kumoko/agent.py", "/kumoko/ensembles.py", "/kumoko/scoring.py"], "/kumoko/ensembles.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/strategies/rfind.py", "/kumoko/strategies/decision_tree.py", "/kumoko/strategies/decision_tree_v10.py", "/kumoko/strategies/testing_pls_ignore.py", "/kumoko/strategies/memory_patterns_v7.py", "/kumoko/strategies/centrifugal_bumblepuppy.py", "/kumoko/strategies/statistical_prediction.py", "/kumoko/strategies/are_you_a_lucker.py"], "/kumoko/action_choice.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"], "/kumoko/strategies/decision_tree.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/are_you_a_lucker.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/rfind.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py", "/kumoko/scoring.py", "/kumoko/action_choice.py"], "/kumoko/strategies/statistical_prediction.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py"], "/kumoko/strategies/centrifugal_bumblepuppy.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko_meta.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/decision_tree_v10.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/testing_pls_ignore.py": ["/kumoko/kumoko_base.py"], "/kumoko/scoring.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/memory_patterns_v7.py": ["/kumoko/kumoko_base.py"], "/kumoko/agent.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/kumoko.py", "/kumoko/ensembles.py", "/kumoko/scoring.py", "/kumoko/action_choice.py", "/kumoko/kumoko_v1.py"], "/kumoko/kumoko_v1.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"]}
|
31,606,905
|
hav4ik/rock-paper-scissors
|
refs/heads/master
|
/kumoko/ensembles.py
|
from kumoko.kumoko_base import *
from kumoko.kumoko_meta import *
from kumoko.strategies.rfind import RFindStrategy
from kumoko.strategies.decision_tree import DecisionTreeStrategy
from kumoko.strategies.hps_dojo_agent import HPSDojoStrategy
from kumoko.strategies.testing_pls_ignore import TestingPlsIgnoreStrategy
class RFindOnlyV1:
"""Only Rfind, nothing else!
"""
@staticmethod
def strategies():
"""List of strategies (including mirror strategies)
"""
strategies = []
# Add RFind strategies (2 meta-strategies P0 and P'0 for each)
limits=[50, 35, 20, 10]
sources = ['his', 'our', 'dna']
for limit in limits:
for source in sources:
strategies.extend(
generate_meta_strategy_pair(RFindStrategy,
*(limit, source)))
return strategies
@staticmethod
def scoring_funcs():
"""List of scoring functions
"""
# Add DLLU's scoring methods from his blog
# https://daniel.lawrence.lu/programming/rps/
dllu_scoring_configs = [
# decay, win_val, draw_val, lose_val, drop_prob, drop_draw, clip_zero
[ 0.80, 3.00, 0.00, -3.00, 0.00, False, False ],
[ 0.87, 3.30, -0.90, -3.00, 0.00, False, False ],
[ 1.00, 3.00, 0.00, -3.00, 1.00, False, False ],
[ 1.00, 3.00, 0.00, -3.00, 1.00, True, False ],
]
scoring_funcs = [
get_dllu_scoring(*cfg)
for cfg in dllu_scoring_configs]
return scoring_funcs
class FourStratsV1:
"""
Contains 4 type of strategies:
- RFind (with 4 windows and 3 sources)
- DecisionTree
- HPSDojo (from high performance notebook)
- TestingPleaseIgnore
"""
@staticmethod
def strategies():
"""List of strategies (including mirror strategies)
"""
strategies = []
# Add RFind strategies (2 meta-strategies P0 and P'0 for each)
limits=[50, 35, 20, 10]
sources = ['his', 'our', 'dna']
for limit in limits:
for source in sources:
strategies.extend(
generate_meta_strategy_pair(RFindStrategy,
*(limit, source)))
# Add decision tree strategies
strategies.extend(
generate_meta_strategy_pair(DecisionTreeStrategy))
# # Add HPS Dojo strategies
# strategies.extend(
# generate_meta_strategy_pair(HPSDojoStrategy))
# # Add testing please ignore strategies
# strategies.extend(
# generate_meta_strategy_pair(TestingPlsIgnoreStrategy))
return strategies
@staticmethod
def scoring_funcs():
"""List of scoring functions
"""
# Add DLLU's scoring methods from his blog
# https://daniel.lawrence.lu/programming/rps/
dllu_scoring_configs = [
# decay, win_val, draw_val, lose_val, drop_prob, drop_draw, clip_zero
[ 0.80, 3.00, 0.00, -3.00, 0.00, False, False ],
[ 0.87, 3.30, -0.90, -3.00, 0.00, False, False ],
[ 1.00, 3.00, 0.00, -3.00, 1.00, False, False ],
[ 1.00, 3.00, 0.00, -3.00, 1.00, True, False ],
]
scoring_funcs = [
get_dllu_scoring(*cfg)
for cfg in dllu_scoring_configs]
return scoring_funcs
ENSEMBLES = {
'rfind_v1': RFindOnlyV1,
'4_strats_v1': FourStratsV1,
}
|
{"/dojo.py": ["/kumoko/agent.py", "/kumoko/ensembles.py", "/kumoko/scoring.py"], "/kumoko/ensembles.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/strategies/rfind.py", "/kumoko/strategies/decision_tree.py", "/kumoko/strategies/decision_tree_v10.py", "/kumoko/strategies/testing_pls_ignore.py", "/kumoko/strategies/memory_patterns_v7.py", "/kumoko/strategies/centrifugal_bumblepuppy.py", "/kumoko/strategies/statistical_prediction.py", "/kumoko/strategies/are_you_a_lucker.py"], "/kumoko/action_choice.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"], "/kumoko/strategies/decision_tree.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/are_you_a_lucker.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/rfind.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py", "/kumoko/scoring.py", "/kumoko/action_choice.py"], "/kumoko/strategies/statistical_prediction.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py"], "/kumoko/strategies/centrifugal_bumblepuppy.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko_meta.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/decision_tree_v10.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/testing_pls_ignore.py": ["/kumoko/kumoko_base.py"], "/kumoko/scoring.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/memory_patterns_v7.py": ["/kumoko/kumoko_base.py"], "/kumoko/agent.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/kumoko.py", "/kumoko/ensembles.py", "/kumoko/scoring.py", "/kumoko/action_choice.py", "/kumoko/kumoko_v1.py"], "/kumoko/kumoko_v1.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"]}
|
31,606,906
|
hav4ik/rock-paper-scissors
|
refs/heads/master
|
/kumoko/kumoko_v1.py
|
import random
from kumoko.kumoko_base import *
from kumoko.kumoko_meta import *
class KumokoV1:
def __init__(self, strategies, scoring_funcs):
"""Define scoring functions and strategies"""
self.proposed_actions = []
self.proposed_meta_actions = []
self.our_last_move = None
self.holistic_history = HolisticHistoryHolder()
self.strategies = strategies
self.scoring_funcs = scoring_funcs
# Add initial scores for each strategy in the list
self.scores = 3. * np.ones(
shape=(len(self.scoring_funcs),
3 * len(self.strategies)))
self.proposed_actions = [
random.choice('RPS')] * self.scores.shape[1]
# Add meta-scores for each of the scoring function
self.meta_scoring_func = get_dllu_scoring(
decay=1.0,
win_value=3.0,
draw_value=0.0,
lose_value=-3.0,
drop_prob=0.0,
drop_draw=False,
clip_zero=True)
self.meta_scores = 3. * np.ones(
shape=(len(self.scoring_funcs)))
self.proposed_meta_actions = [
random.choice('RPS')] * self.meta_scores.shape[0]
def next_action(self, our_last_move, his_last_move):
"""Generate next move based on opponent's last move"""
# Force last move, so that we can use Kumoko as part of
# a larger meta-agent
self.our_last_move = our_last_move
# Update game history with the moves from previous
# game step
if his_last_move is not None:
if DEBUG_MODE:
assert self.our_last_move is not None
self.holistic_history.add_moves(
self.our_last_move, his_last_move)
# Update score for the previous game step
if his_last_move is not None and \
len(self.proposed_actions) > 0:
if DEBUG_MODE:
assert len(self.proposed_actions) == \
3 * len(self.strategies)
assert len(self.proposed_meta_actions) == \
len(self.meta_scores)
assert self.scores.shape[0] == \
len(self.scoring_funcs)
# Meta-strategy selection score
for sf in range(len(self.scoring_funcs)):
for pa in range(len(self.proposed_actions)):
self.scores[sf, pa] = self.scoring_funcs[sf](
self.scores[sf, pa],
self.proposed_actions[pa],
his_last_move)
# Selector selection score
for sf in range(len(self.scoring_funcs)):
self.meta_scores[sf] = self.meta_scoring_func(
self.meta_scores[sf],
self.proposed_meta_actions[sf],
his_last_move)
# Generate next move for each strategy
if len(self.proposed_actions) == 0:
self.proposed_actions = \
[random.choice('RPS')] * (len(self.strategies) * 3)
else:
for st in range(len(self.strategies)):
proposed_action = \
self.strategies[st](self.holistic_history)
if proposed_action is not None:
self.proposed_actions[st] = proposed_action
self.proposed_actions[st + len(self.strategies)] = \
BEAT[self.proposed_actions[st]]
self.proposed_actions[st + 2 * len(self.strategies)] = \
CEDE[self.proposed_actions[st]]
# For each scoring function (selector), choose the
# action with highest score
best_actions_idx = np.argmax(self.scores, axis=1)
if DEBUG_MODE:
assert best_actions_idx.shape == \
(len(self.scoring_funcs), )
self.proposed_meta_actions = [
self.proposed_actions[idx]
for idx in best_actions_idx]
# Meta-Selector: selecting the scoring function
if DEBUG_MODE:
assert len(self.meta_scores) == \
len(self.proposed_meta_actions)
best_meta_action_idx = np.argmax(self.meta_scores)
self.our_last_move = \
self.proposed_meta_actions[best_meta_action_idx]
return self.our_last_move
|
{"/dojo.py": ["/kumoko/agent.py", "/kumoko/ensembles.py", "/kumoko/scoring.py"], "/kumoko/ensembles.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/strategies/rfind.py", "/kumoko/strategies/decision_tree.py", "/kumoko/strategies/decision_tree_v10.py", "/kumoko/strategies/testing_pls_ignore.py", "/kumoko/strategies/memory_patterns_v7.py", "/kumoko/strategies/centrifugal_bumblepuppy.py", "/kumoko/strategies/statistical_prediction.py", "/kumoko/strategies/are_you_a_lucker.py"], "/kumoko/action_choice.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"], "/kumoko/strategies/decision_tree.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/are_you_a_lucker.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/rfind.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py", "/kumoko/scoring.py", "/kumoko/action_choice.py"], "/kumoko/strategies/statistical_prediction.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py"], "/kumoko/strategies/centrifugal_bumblepuppy.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko_meta.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/decision_tree_v10.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/testing_pls_ignore.py": ["/kumoko/kumoko_base.py"], "/kumoko/scoring.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/memory_patterns_v7.py": ["/kumoko/kumoko_base.py"], "/kumoko/agent.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/kumoko.py", "/kumoko/ensembles.py", "/kumoko/scoring.py", "/kumoko/action_choice.py", "/kumoko/kumoko_v1.py"], "/kumoko/kumoko_v1.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"]}
|
31,606,907
|
hav4ik/rock-paper-scissors
|
refs/heads/master
|
/dojo.py
|
import os
from argparse import ArgumentParser
import pandas as pd
import kaggle_environments
from datetime import datetime
import multiprocessing as pymp
from tqdm import tqdm
# Parse cmd line input
parser = ArgumentParser()
parser.add_argument('-m', '--multiprocessing', action='store_true')
args = parser.parse_args()
# Form list of enemies
agents = [
os.path.join('opponents', agent_file)
for agent_file in os.listdir('opponents')
if os.path.splitext(agent_file)[-1] == '.py']
# Agent to eval
agent_to_eval = os.path.join('kumoko', 'agent.py')
# function to return score
def get_result(match_settings):
start = datetime.now()
outcomes = kaggle_environments.evaluate(
'rps',
[match_settings[0], match_settings[1]],
num_episodes=match_settings[2],
configuration={
'debug': True
})
won, lost, tie, avg_score = 0, 0, 0, 0.
for outcome in outcomes:
score = outcome[0]
if score > 0: won += 1
elif score < 0: lost += 1
else: tie += 1
avg_score += score
elapsed = datetime.now() - start
opponent_name = os.path.basename(match_settings[1])
opponent_name = os.path.splitext(opponent_name)[0]
print(f'... vs {opponent_name:<30} --- {won:2d}/{tie:2d}/{lost:2d} --- {avg_score}')
return match_settings[1], won, lost, tie, elapsed, float(avg_score) / float(match_settings[2])
def eval_agent_against_baselines(agent, baselines, num_episodes=10):
print('')
print(f'Evaluating {agent}:')
df = pd.DataFrame(
columns=['wins', 'loses', 'ties', 'total time', 'avg. score'],
index=baselines)
matches = [[agent, baseline, num_episodes] for baseline in baselines]
results = []
if args.multiprocessing:
pool = pymp.Pool()
for content in pool.imap_unordered(get_result, matches):
results.append(content)
else:
for match_cfg in matches:
results.append(get_result(match_cfg))
for baseline_agent, won, lost, tie, elapsed, avg_score in results:
df.loc[baseline_agent, 'wins'] = won
df.loc[baseline_agent, 'loses'] = lost
df.loc[baseline_agent, 'ties'] = tie
df.loc[baseline_agent, 'total time'] = elapsed
df.loc[baseline_agent, 'avg. score'] = avg_score
return df
df = eval_agent_against_baselines(agent_to_eval, agents)
|
{"/dojo.py": ["/kumoko/agent.py", "/kumoko/ensembles.py", "/kumoko/scoring.py"], "/kumoko/ensembles.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/strategies/rfind.py", "/kumoko/strategies/decision_tree.py", "/kumoko/strategies/decision_tree_v10.py", "/kumoko/strategies/testing_pls_ignore.py", "/kumoko/strategies/memory_patterns_v7.py", "/kumoko/strategies/centrifugal_bumblepuppy.py", "/kumoko/strategies/statistical_prediction.py", "/kumoko/strategies/are_you_a_lucker.py"], "/kumoko/action_choice.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"], "/kumoko/strategies/decision_tree.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/are_you_a_lucker.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/rfind.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py", "/kumoko/scoring.py", "/kumoko/action_choice.py"], "/kumoko/strategies/statistical_prediction.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py"], "/kumoko/strategies/centrifugal_bumblepuppy.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko_meta.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/decision_tree_v10.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/testing_pls_ignore.py": ["/kumoko/kumoko_base.py"], "/kumoko/scoring.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/memory_patterns_v7.py": ["/kumoko/kumoko_base.py"], "/kumoko/agent.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/kumoko.py", "/kumoko/ensembles.py", "/kumoko/scoring.py", "/kumoko/action_choice.py", "/kumoko/kumoko_v1.py"], "/kumoko/kumoko_v1.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"]}
|
31,606,908
|
hav4ik/rock-paper-scissors
|
refs/heads/master
|
/kumoko/agent.py
|
import os
import random
import kaggle_environments
from kumoko.kumoko_base import *
from kumoko.kumoko_meta import *
from kumoko.kumoko_meta import MetaKumoko
from kumoko.kumoko_v1 import KumokoV1
from kumoko.ensembles import ENSEMBLES
# Default values
ENSEMBLE = ENSEMBLES['4_strats_v1']
USE_META = True
# Read from OS environ
if 'KENSEMBLE' in os.environ:
ENSEMBLE = ENSEMBLES[os.environ['KENSEMBLE']]
if 'KMETA' in os.environ:
USE_META = bool(os.environ['KMETA'])
global kumoko_agent
global latest_action
latest_action = None
if USE_META:
kumoko_agent = MetaKumoko(
KumokoV1,
kumoko_args=[
ENSEMBLE.strategies(),
ENSEMBLE.scoring_funcs()
])
else:
kumoko_agent = KumokoV1(
ENSEMBLE.strategies(),
ENSEMBLE.scoring_funcs())
def agent(obs, conf):
global kumoko_agent
global latest_action
# return random.randint(0,2)
if obs.step == 0:
s_move = kumoko_agent.next_action(None, None)
else:
s_his_last_move = NUM_TO_MOVE[obs.lastOpponentAction]
s_our_last_move = NUM_TO_MOVE[latest_action]
s_move = kumoko_agent.next_action(
s_our_last_move, s_his_last_move)
latest_action = MOVE_TO_NUM[s_move]
# Surprise motherfucker
if random.random() < 0.1 or random.randint(3, 40) > obs.step:
latest_action = random.randint(0, 2)
return latest_action
if __name__ == '__main__':
env = kaggle_environments.make(
"rps", configuration={"episodeSteps": 100}, debug=True)
outcomes = env.run([agent, agent])
|
{"/dojo.py": ["/kumoko/agent.py", "/kumoko/ensembles.py", "/kumoko/scoring.py"], "/kumoko/ensembles.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/strategies/rfind.py", "/kumoko/strategies/decision_tree.py", "/kumoko/strategies/decision_tree_v10.py", "/kumoko/strategies/testing_pls_ignore.py", "/kumoko/strategies/memory_patterns_v7.py", "/kumoko/strategies/centrifugal_bumblepuppy.py", "/kumoko/strategies/statistical_prediction.py", "/kumoko/strategies/are_you_a_lucker.py"], "/kumoko/action_choice.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"], "/kumoko/strategies/decision_tree.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/are_you_a_lucker.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/rfind.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py", "/kumoko/scoring.py", "/kumoko/action_choice.py"], "/kumoko/strategies/statistical_prediction.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko.py"], "/kumoko/strategies/centrifugal_bumblepuppy.py": ["/kumoko/kumoko_base.py"], "/kumoko/kumoko_meta.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/decision_tree_v10.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/testing_pls_ignore.py": ["/kumoko/kumoko_base.py"], "/kumoko/scoring.py": ["/kumoko/kumoko_base.py"], "/kumoko/strategies/memory_patterns_v7.py": ["/kumoko/kumoko_base.py"], "/kumoko/agent.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py", "/kumoko/kumoko.py", "/kumoko/ensembles.py", "/kumoko/scoring.py", "/kumoko/action_choice.py", "/kumoko/kumoko_v1.py"], "/kumoko/kumoko_v1.py": ["/kumoko/kumoko_base.py", "/kumoko/kumoko_meta.py"]}
|
31,608,550
|
c2tarun/aws-sam-cli
|
refs/heads/master
|
/samcli/lib/utils/feature_flag.py
|
"""
Provides utility functions to centralize logic for AWS SAM CLI feature flags in a single file.
"""
from os import getenv
EXTENSIONS_PREVIEW_ENV = "ENABLE_LAMBDA_EXTENSIONS_PREVIEW"
def extensions_preview_enabled():
"""
Checks the ENABLE_LAMBDA_EXTENSIONS_PREVIEW env variable to determine if functionality for the
extensions preview should be enabled or not.
"""
env_value = getenv(EXTENSIONS_PREVIEW_ENV)
if env_value == "1":
return True
return False
|
{"/samcli/lib/providers/sam_layer_provider.py": ["/samcli/lib/providers/sam_base_provider.py"]}
|
31,608,551
|
c2tarun/aws-sam-cli
|
refs/heads/master
|
/samcli/lib/providers/sam_layer_provider.py
|
"""
Class that provides layers from a given SAM template
"""
import logging
from .provider import LayerVersion
from .sam_base_provider import SamBaseProvider
LOG = logging.getLogger(__name__)
class SamLayerProvider(SamBaseProvider):
"""
Fetches and returns Layers from a SAM Template. The SAM template passed to this provider is assumed to be valid,
normalized and a dictionary.
It may or may not contain a layer.
"""
def __init__(self, template_dict, parameter_overrides=None):
"""
Initialize the class with SAM template data. The SAM template passed to this provider is assumed
to be valid, normalized and a dictionary. It should be normalized by running all pre-processing
before passing to this class. The process of normalization will remove structures like ``Globals``, resolve
intrinsic functions etc.
This class does not perform any syntactic validation of the template.
After the class is initialized, any changes to the ``template_dict`` will not be reflected in here.
You need to explicitly update the class with new template, if necessary.
Parameters
----------
template_dict: SAM Template as a dictionary
parameter_overrides: Optional dictionary of values for SAM template parameters that might want to get
substituted within the template
"""
self._template_dict = SamLayerProvider.get_template(template_dict, parameter_overrides)
self._resources = self._template_dict.get("Resources", {})
self._layers = self._extract_layers()
def get(self, name):
"""
Returns the layer with given name or logical id.
Parameters
----------
name: name or logical id of the layer.
Returns
-------
LayerVersion object of one layer.
"""
if not name:
raise ValueError("Layer name is required")
for layer in self._layers:
if layer.name == name:
return layer
return None
def get_all(self):
"""
Returns all Layers in template
Returns
-------
[LayerVersion] list of layer version objects.
"""
return self._layers
def _extract_layers(self):
"""
Extracts all resources with Type AWS::Lambda::LayerVersion and AWS::Serverless::LayerVersion and return a list
of those resources.
"""
layers = []
for name, resource in self._resources.items():
if resource.get("Type") in [self.LAMBDA_LAYER, self.SERVERLESS_LAYER]:
layers.append(self._convert_lambda_layer_resource(name, resource))
return layers
def _convert_lambda_layer_resource(self, layer_logical_id, layer_resource):
"""
Convert layer resource into {LayerVersion} object.
Parameters
----------
layer_logical_id: LogicalID of resource.
layer_resource: resource in template.
"""
# In the list of layers that is defined within a template, you can reference a LayerVersion resource.
# When running locally, we need to follow that Ref so we can extract the local path to the layer code.
layer_properties = layer_resource.get("Properties", {})
resource_type = layer_resource.get("Type")
compatible_runtimes = layer_properties.get("CompatibleRuntimes")
codeuri = None
if resource_type == self.SERVERLESS_LAYER:
codeuri = SamLayerProvider._extract_sam_function_codeuri(layer_logical_id, layer_properties, "ContentUri")
if resource_type == self.LAMBDA_LAYER:
codeuri = SamLayerProvider._extract_lambda_function_code(layer_properties, "Content")
return LayerVersion(layer_logical_id, codeuri, compatible_runtimes, layer_resource.get("Metadata", None))
|
{"/samcli/lib/providers/sam_layer_provider.py": ["/samcli/lib/providers/sam_base_provider.py"]}
|
31,608,552
|
c2tarun/aws-sam-cli
|
refs/heads/master
|
/samcli/lib/providers/sam_base_provider.py
|
"""
Base class for SAM Template providers
"""
import logging
from samcli.lib.intrinsic_resolver.intrinsic_property_resolver import IntrinsicResolver
from samcli.lib.intrinsic_resolver.intrinsics_symbol_table import IntrinsicsSymbolTable
from samcli.lib.samlib.resource_metadata_normalizer import ResourceMetadataNormalizer
from samcli.lib.samlib.wrapper import SamTranslatorWrapper
LOG = logging.getLogger(__name__)
class SamBaseProvider:
"""
Base class for SAM Template providers
"""
SERVERLESS_FUNCTION = "AWS::Serverless::Function"
LAMBDA_FUNCTION = "AWS::Lambda::Function"
SERVERLESS_LAYER = "AWS::Serverless::LayerVersion"
LAMBDA_LAYER = "AWS::Lambda::LayerVersion"
DEFAULT_CODEURI = "."
def get(self, name):
"""
Given name of the function, this method must return the Function object
:param string name: Name of the function
:return Function: namedtuple containing the Function information
"""
raise NotImplementedError("not implemented")
def get_all(self):
"""
Yields all the Lambda functions available in the provider.
:yields Function: namedtuple containing the function information
"""
raise NotImplementedError("not implemented")
@staticmethod
def _extract_lambda_function_code(resource_properties, code_property_key):
"""
Extracts the Lambda Function Code from the Resource Properties
Parameters
----------
resource_properties dict
Dictionary representing the Properties of the Resource
code_property_key str
Property Key of the code on the Resource
Returns
-------
str
Representing the local code path
"""
codeuri = resource_properties.get(code_property_key, SamBaseProvider.DEFAULT_CODEURI)
if isinstance(codeuri, dict):
codeuri = SamBaseProvider.DEFAULT_CODEURI
return codeuri
@staticmethod
def _extract_sam_function_codeuri(
name, resource_properties, code_property_key, ignore_code_extraction_warnings=False
):
"""
Extracts the SAM Function CodeUri from the Resource Properties
Parameters
----------
name str
LogicalId of the resource
resource_properties dict
Dictionary representing the Properties of the Resource
code_property_key str
Property Key of the code on the Resource
ignore_code_extraction_warnings
Boolean to ignore log statements on code extraction from Resources.
Returns
-------
str
Representing the local code path
"""
codeuri = resource_properties.get(code_property_key, SamBaseProvider.DEFAULT_CODEURI)
# CodeUri can be a dictionary of S3 Bucket/Key or a S3 URI, neither of which are supported
if isinstance(codeuri, dict) or (isinstance(codeuri, str) and codeuri.startswith("s3://")):
codeuri = SamBaseProvider.DEFAULT_CODEURI
if not ignore_code_extraction_warnings:
LOG.warning(
"Lambda function '%s' has specified S3 location for CodeUri which is unsupported. "
"Using default value of '%s' instead",
name,
codeuri,
)
return codeuri
@staticmethod
def get_template(template_dict, parameter_overrides=None):
"""
Given a SAM template dictionary, return a cleaned copy of the template where SAM plugins have been run
and parameter values have been substituted.
Parameters
----------
template_dict : dict
unprocessed SAM template dictionary
parameter_overrides: dict
Optional dictionary of values for template parameters
Returns
-------
dict
Processed SAM template
"""
template_dict = template_dict or {}
parameters_values = SamBaseProvider._get_parameter_values(template_dict, parameter_overrides)
if template_dict:
template_dict = SamTranslatorWrapper(template_dict, parameter_values=parameters_values).run_plugins()
ResourceMetadataNormalizer.normalize(template_dict)
resolver = IntrinsicResolver(
template=template_dict,
symbol_resolver=IntrinsicsSymbolTable(logical_id_translator=parameters_values, template=template_dict),
)
template_dict = resolver.resolve_template(ignore_errors=True)
return template_dict
@staticmethod
def _get_parameter_values(template_dict, parameter_overrides):
"""
Construct a final list of values for CloudFormation template parameters based on user-supplied values,
default values provided in template, and sane defaults for pseudo-parameters.
Parameters
----------
template_dict : dict
SAM template dictionary
parameter_overrides : dict
User-supplied values for CloudFormation template parameters
Returns
-------
dict
Values for template parameters to substitute in template with
"""
default_values = SamBaseProvider._get_default_parameter_values(template_dict)
# NOTE: Ordering of following statements is important. It makes sure that any user-supplied values
# override the defaults
parameter_values = {}
parameter_values.update(IntrinsicsSymbolTable.DEFAULT_PSEUDO_PARAM_VALUES)
parameter_values.update(default_values)
parameter_values.update(parameter_overrides or {})
return parameter_values
@staticmethod
def _get_default_parameter_values(sam_template):
"""
Method to read default values for template parameters and return it
Example:
If the template contains the following parameters defined
Parameters:
Param1:
Type: String
Default: default_value1
Param2:
Type: String
Default: default_value2
then, this method will grab default value for Param1 and return the following result:
{
Param1: "default_value1",
Param2: "default_value2"
}
:param dict sam_template: SAM template
:return dict: Default values for parameters
"""
default_values = {}
parameter_definition = sam_template.get("Parameters", None)
if not parameter_definition or not isinstance(parameter_definition, dict):
LOG.debug("No Parameters detected in the template")
return default_values
for param_name, value in parameter_definition.items():
if isinstance(value, dict) and "Default" in value:
default_values[param_name] = value["Default"]
LOG.debug("Collected default values for parameters: %s", default_values)
return default_values
|
{"/samcli/lib/providers/sam_layer_provider.py": ["/samcli/lib/providers/sam_base_provider.py"]}
|
31,608,553
|
c2tarun/aws-sam-cli
|
refs/heads/master
|
/samcli/lib/telemetry/metrics.py
|
"""
Provides methods to generate and send metrics
"""
from timeit import default_timer
import platform
import logging
import click
from samcli.lib.warnings.sam_cli_warning import TemplateWarningsChecker
from samcli.cli.context import Context
from samcli.commands.exceptions import UserException
from samcli.cli.global_config import GlobalConfig
from .telemetry import Telemetry
LOG = logging.getLogger(__name__)
WARNING_ANNOUNCEMENT = "WARNING: {}"
def send_installed_metric():
LOG.debug("Sending Installed Metric")
telemetry = Telemetry()
telemetry.emit("installed", {"osPlatform": platform.system(), "telemetryEnabled": _telemetry_enabled()})
def track_template_warnings(warning_names):
"""
Decorator to track when a warning is emitted. This method accepts name of warning and executes the function,
gathers all relevant metrics, reports the metrics and returns.
On your warning check method use as follows
@track_warning(['Warning1', 'Warning2'])
def check():
return True, 'Warning applicable'
"""
def decorator(func):
"""
Actual decorator method with warning names
"""
def wrapped(*args, **kwargs):
telemetry = Telemetry()
template_warning_checker = TemplateWarningsChecker()
ctx = Context.get_current_context()
try:
ctx.template_dict
except AttributeError:
LOG.debug("Ignoring warning check as template is not provided in context.")
return func(*args, **kwargs)
for warning_name in warning_names:
warning_message = template_warning_checker.check_template_for_warning(warning_name, ctx.template_dict)
if _telemetry_enabled():
telemetry.emit("templateWarning", _build_warning_metric(ctx, warning_name, warning_message))
if warning_message:
click.secho(WARNING_ANNOUNCEMENT.format(warning_message), fg="yellow")
return func(*args, **kwargs)
return wrapped
return decorator
def _build_warning_metric(ctx, warning_name, warning_message):
return {
"awsProfileProvided": bool(ctx.profile),
"debugFlagProvided": bool(ctx.debug),
"region": ctx.region or "",
"warningName": warning_name, # Full command path. ex: sam local start-api
"warningCount": 1 if warning_message else 0, # 1-True or 0-False
}
def track_command(func):
"""
Decorator to track execution of a command. This method executes the function, gathers all relevant metrics,
reports the metrics and returns.
If you have a Click command, you can track as follows:
.. code:: python
@click.command(...)
@click.options(...)
@track_command
def hello_command():
print('hello')
"""
def wrapped(*args, **kwargs):
if not _telemetry_enabled():
# When Telemetry is disabled, call the function immediately and return.
return func(*args, **kwargs)
telemetry = Telemetry()
exception = None
return_value = None
exit_reason = "success"
exit_code = 0
duration_fn = _timer()
try:
# Execute the function and capture return value. This is returned back by the wrapper
# First argument of all commands should be the Context
return_value = func(*args, **kwargs)
except UserException as ex:
# Capture exception information and re-raise it later so we can first send metrics.
exception = ex
exit_code = ex.exit_code
if ex.wrapped_from is None:
exit_reason = type(ex).__name__
else:
exit_reason = ex.wrapped_from
except Exception as ex:
exception = ex
# Standard Unix practice to return exit code 255 on fatal/unhandled exit.
exit_code = 255
exit_reason = type(ex).__name__
ctx = Context.get_current_context()
telemetry.emit(
"commandRun",
{
# Metric about command's general environment
"awsProfileProvided": bool(ctx.profile),
"debugFlagProvided": bool(ctx.debug),
"region": ctx.region or "",
"commandName": ctx.command_path, # Full command path. ex: sam local start-api
# Metric about command's execution characteristics
"duration": duration_fn(),
"exitReason": exit_reason,
"exitCode": exit_code,
},
)
if exception:
raise exception # pylint: disable=raising-bad-type
return return_value
return wrapped
def _timer():
"""
Timer to measure the elapsed time between two calls in milliseconds. When you first call this method,
we will automatically start the timer. The return value is another method that, when called, will end the timer
and return the duration between the two calls.
..code:
>>> import time
>>> duration_fn = _timer()
>>> time.sleep(5) # Say, you sleep for 5 seconds in between calls
>>> duration_ms = duration_fn()
>>> print(duration_ms)
5010
Returns
-------
function
Call this method to end the timer and return duration in milliseconds
"""
start = default_timer()
def end():
# time might go backwards in rare scenarios, hence the 'max'
return int(max(default_timer() - start, 0) * 1000) # milliseconds
return end
def _telemetry_enabled():
gc = GlobalConfig()
return bool(gc.telemetry_enabled)
|
{"/samcli/lib/providers/sam_layer_provider.py": ["/samcli/lib/providers/sam_base_provider.py"]}
|
31,670,742
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/client_network.py
|
from socket import *
import threading
import pickle
import sys
class User:
def __init__(self,uID,password):
#login------------------------------------------------------
self.recieved_messages = []
self.quickplay_section_messages = []
self.pwf_section_messages = []
self.profile_section_messages = []
self.main_page_messages = []
self.chat_messages = []
self.board_messages = []
self.color = None
self.room_id = None
self.enemy_name = None
self.ip = '65.0.204.13'
self.port = 13000
self.uID = uID
self.password = password
try:
self.sock = socket(AF_INET, SOCK_STREAM)
print("Socket successfully created")
except error as err:
print("socket creation failed with error %s" % (err))
try:
self.sock.connect((self.ip, self.port))
message = {'ID':5,'UserID':self.uID,'Password':self.password,'Loggedin':1}
self.sock.send(pickle.dumps(message))
reply = self.sock.recv(1024)
print("Reply:",pickle.loads(reply))
#------------------------------------------------------------
self.Flist = pickle.loads(self.sock.recv(2048))
print(self.Flist)
self.recieve_thread = threading.Thread(target=self.recieve_messages)
self.recieve_thread.start()
except:
print("Server is not running")
sys.exit()
def send(self,data):
try:
self.sock.send(pickle.dumps(data))
except:
print("Error while sending message")
def recieve_messages(self):
while True:
try:
message = self.sock.recv(4096)
if message:
data = pickle.loads(message)
print(data)
self.recieved_messages.append(data)
if data['ID']==24:
self.pwf_section_messages.append(data)
elif data['ID']==25:
self.pwf_section_messages.append(data)
elif data['ID']==7:
print("Error occured! - {}".format(data))
elif data['ID']==50:
self.main_page_messages.append(data)
elif data['ID']==55:
self.pwf_section_messages.append(data)
elif data['ID']==2200:
self.main_page_messages.append(data)
self.pwf_section_messages.append(data)
self.quickplay_section_messages.append(data)
elif data['ID'] == 11:
self.pwf_section_messages.append(data)
elif data['ID'] == 30:
self.chat_messages.append(data)
elif data['ID'] == 12:
self.pwf_section_messages.append(data)
elif data['ID'] == 27:
self.profile_section_messages.append(data)
elif data['ID'] == 60:
self.board_messages.append(data)
elif data['ID'] == 40:
self.profile_section_messages.append(data)
elif data['ID'] == 56:
self.quickplay_section_messages.append(data)
elif data['ID'] == 57:
pass
elif data['ID'] == 28:
self.profile_section_messages.append(data)
elif data['ID'] == 13:
self.pwf_section_messages.append(data)
except:
break
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,743
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/Client.py
|
import socket
import threading
import pickle
class User(object):
def __init__(self):
self.sending_messages = []
self.recieving_messages = []
self.userid = None
self.password = None
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect(("", 12000))
self.recieve_thread =
self.send_thread =
self.logout = False
def recieve_messages(self):
while not self.logout:
message = self.sock.recv(4096)
data = pickle.loads(message)
self.recieving_messages.append(data)
return
def send_messages(self):
while not self.logout:
if len(self.sending_messages) > 0:
message = self.sending_messages.pop(0)
data = pickle.dumps()
self.sock.send(data)
else:
continue
return
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,744
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/pwfriend.py
|
import pygame
from pygame.locals import *
import random
from socket import *
import pickle
import time
import threading
RED = (255,0,0)
GREEN = (0,255,0)
BLUE = (0,0,255)
pygame.init()
WHITE = (255,255,255)
FONT = pygame.font.SysFont('freesansbold.ttf', 40)
FONT1 = pygame.font.SysFont('consolas',20,bold=True)
FONT2 = pygame.font.SysFont('freesansbold.ttf', 35)
FONT3 = pygame.font.SysFont('freesansbold.ttf', 30)
class PlayWithFriend:
def __init__(self,screen,clock,client):
self.screen = screen
self.clock = clock
self.client = client
self.get_search_bar()
self.get_friends(client)
self.Friends_texts = [FONT1.render(i,True,random.choice([RED,GREEN,BLUE])) for i in self.Friends_list]
self.Friends_texts_rects = [i.get_rect() for i in self.Friends_texts]
self.first_friend_index = 0
self.last_friend_index = len(self.Friends_list)
self.buttons_pos = [146+i*50 for i in range(0,len(self.Friends_list))]
self.button_texts_pos = [150+i*50 for i in range(0,len(self.Friends_list))]
self.invite_text = FONT1.render("Invite",True,(0,255,0))
self.titles = [FONT.render("Invite Friend",True,(255,255,255)),FONT.render("Search",True,(255,255,255))]
self.search_desc = FONT3.render("Enter username to search",True,(255,255,255))
self.offline_text = FONT1.render("Offline",True,(255,255,255))
self.invited_text = FONT1.render("Invite sent",True,(255,255,255))
self.busy_text = FONT1.render("Busy",True,(248,252,3))
self.add = FONT1.render("ADD",True,(0,255,0))
self.search_result = ""
self.search = ""
self.count_down = 1
self.get_centers()
self.goback = FONT.render("Go Back",True,(0,255,0))
def get_pwf_section_messages(self):
try:
msg = self.client.pwf_section_messages.pop()
#print(msg['ID'])
if msg['ID']==24:
#print(msg)
self.search_result = FONT2.render(msg['Data'][0],True,(66,245,114))
elif msg['ID']==2200:
self.client.room_id = msg['RoomID']
self.client.color = msg['Turn']
elif msg['ID']==11:
friend_came_online = msg['FriendID']
self.status_list[self.Friends_list.index(friend_came_online)] = True
elif msg['ID']==12:
friend_went_offline = msg['FriendID']
self.status_list[self.Friends_list.index(friend_went_offline)] = False
elif msg['ID']==13:
friend_became_busy = msg['FriendID']
self.status_list[self.Friends_list.index(friend_became_busy)] = "busy"
elif msg['ID']==55:
print("True")
self.client.enemy_name = msg['Receiver']
except:
#print("exception")
pass
def get_friends(self,Flist):
Flist = self.client.Flist
self.status_list = []
self.Friends_list = Flist['Friends']
online_friends = Flist['Online_Friends']
for i in self.Friends_list:
if i in online_friends:
self.status_list.append(True)
else:
self.status_list.append(False)
def get_centers(self):
x,y = 100,160
for i in self.Friends_texts_rects[self.first_friend_index:self.last_friend_index]:
i.center = (x+i.width/2,y)
y += 50
def get_search_bar(self):
self.delay = 500
self.current_time = pygame.time.get_ticks()
self.change_time = self.current_time + self.delay
self.cursor_visible = True
self.input = ""
self.cursor_position = 0
self.max_input_length = 25
self.cursor_coords = [[770.5,156],[770.5,186]]
def cursor_blink(self):
self.current_time = pygame.time.get_ticks()
if self.current_time >= self.change_time:
self.change_time = self.current_time + self.delay
self.cursor_visible = not self.cursor_visible
return self.cursor_visible
def get_input_pwf(self,event):
if bool(event.unicode) and len(self.input) < self.max_input_length and event.key != pygame.K_RETURN:
self.input = self.input[:self.cursor_position] + event.unicode + self.input[self.cursor_position:]
self.cursor_position += 1
self.input_text = FONT.render(self.input, True, WHITE)
self.input_rect = self.input_text.get_rect()
self.input_rect.center = (770.5 + (self.input_rect.width // 2),
160 + self.input_rect.height//2)
text = FONT.render(self.input[self.cursor_position:], True, WHITE)
rect = text.get_rect()
self.cursor_coords[0][0] = 770.5 + self.input_rect.width - rect.width
self.cursor_coords[1][0] = self.cursor_coords[0][0]
elif (event.key == pygame.K_RETURN or event.key == pygame.K_KP_ENTER) and len(self.input) > 0:
#print(self.input)
message = {'ID':24,'UserID':self.client.uID,'FriendID':self.input}
self.client.sock.send(pickle.dumps(message))
time.sleep(1)
#print(self.client.pwf_section_messages)
#self.get_pwf_section_messages()
elif event.key == pygame.K_LEFT and self.cursor_position > 0:
self.cursor_position -= 1
text = FONT.render(self.input[:self.cursor_position],True,WHITE)
rect = text.get_rect()
self.cursor_coords[0][0] = 770.5+rect.width
self.cursor_coords[1][0] = 770.5+rect.width
elif event.key == pygame.K_RIGHT and self.cursor_position < len(self.input):
self.cursor_position += 1
text = FONT.render(self.input[:self.cursor_position],True,WHITE)
rect = text.get_rect()
self.cursor_coords[0][0] = 770.5+rect.width
self.cursor_coords[1][0] = 770.5+rect.width
elif event.key == pygame.K_BACKSPACE and self.cursor_position > 0:
self.cursor_position -= 1
text = FONT.render(self.input[self.cursor_position],True,WHITE)
rect = text.get_rect()
self.cursor_coords[0][0] = self.cursor_coords[0][0]-rect.width
self.cursor_coords[1][0] = self.cursor_coords[0][0]
temp = ""
for i in range(len(self.input)):
if i != self.cursor_position:
temp += self.input[i]
self.input = temp
self.input_text = FONT.render(self.input, True, WHITE)
self.input_rect = self.input_text.get_rect()
self.input_rect.center = (770.5 + (self.input_rect.width // 2),160 + self.input_rect.height//2)
def print_input(self):
if len(self.input) > 0 :
self.screen.blit(self.input_text,self.input_rect)
def set_timer(self,index):
self.status_list[index]=True
def update(self):
while True:
#events = pygame.event.get()
self.get_pwf_section_messages()
pos = pygame.mouse.get_pos()
self.screen.fill("#1f1f23")
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.KEYDOWN:
self.get_input_pwf(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 4:
if pos[0]<= 720.5 and pos[0]>=80 and pos[1]<=741 and pos[1] >=60:
if self.first_friend_index > 0:
self.first_friend_index -= 1
self.last_friend_index -= 1
self.get_centers()
elif event.button == 5:
if pos[0]<= 720.5 and pos[0]>=80 and pos[1]<=741 and pos[1] >=60:
if self.last_friend_index < len(self.Friends_list):
self.first_friend_index += 1
self.last_friend_index += 1
self.get_centers()
elif event.button == 1:
#invite events
if len(self.Friends_list)>0:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 171 and pos[1] >= 146:
if self.status_list[self.first_friend_index] not in ["invited","busy"]:
self.status_list[self.first_friend_index]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index]))
if len(self.Friends_list)>1:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 221 and pos[1] >= 196:
print(self.status_list[self.first_friend_index+1])
if self.status_list[self.first_friend_index+1] not in ["invited","busy"]:
self.status_list[self.first_friend_index+1]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+1,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+1]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+1]))
if len(self.Friends_list)>2:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 271 and pos[1] >= 246:
if self.status_list[self.first_friend_index+2] not in ["invited","busy"]:
self.status_list[self.first_friend_index+2]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+2,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+2]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+2]))
if len(self.Friends_list)>3:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 321 and pos[1] >= 296:
if self.status_list[self.first_friend_index+3] not in ["invited","busy"]:
self.status_list[self.first_friend_index+3]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+3,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+3]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+3]))
if len(self.Friends_list)>4:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 371 and pos[1] >= 346:
if self.status_list[self.first_friend_index+4] not in ["invited","busy"]:
self.status_list[self.first_friend_index+4]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index,+4))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+4]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+4]))
if len(self.Friends_list)>5:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 421 and pos[1] >= 396:
if self.status_list[self.first_friend_index+5] not in ["invited","busy"]:
self.status_list[self.first_friend_index+5]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+5,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+5]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+5]))
if len(self.Friends_list)>6:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 471 and pos[1] >= 446:
if self.status_list[self.first_friend_index+6] not in ["invited","busy"]:
self.status_list[self.first_friend_index+6]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+6,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+6]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+6]))
if len(self.Friends_list)>7:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 521 and pos[1] >= 496:
if self.status_list[self.first_friend_index+7] not in ["invited","busy"]:
self.status_list[self.first_friend_index+7]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+7,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+7]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+7]))
if len(self.Friends_list)>8:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 571 and pos[1] >= 546:
if self.status_list[self.first_friend_index+8] not in ["invited","busy"]:
self.status_list[self.first_friend_index+8]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+8,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+8]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+8]))
if len(self.Friends_list)>9:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 621 and pos[1] >= 596:
if self.status_list[self.first_friend_index+9] not in ["invited","busy"]:
self.status_list[self.first_friend_index+9]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+9,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+9]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+9]))
if len(self.Friends_list)>10:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 671 and pos[1] >= 646:
if self.status_list[self.first_friend_index+10] not in ["invited","busy"]:
self.status_list[self.first_friend_index+10]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+10,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+10]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+10]))
if len(self.Friends_list)>11:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 721 and pos[1] >= 696:
if self.status_list[self.first_friend_index+11] not in ["invited","busy"]:
self.status_list[self.first_friend_index+11]="invited"
timer = threading.Timer(10.0, self.set_timer,args=(self.first_friend_index+11,))
timer.start()
invite_msg = {'ID':20,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+11]}
self.client.sock.send(pickle.dumps(invite_msg))
print("Invited {}".format(self.Friends_list[self.first_friend_index+11]))
if self.search_result:
if pos[0]<=1350 and pos[0]>=1270 and pos[1]<=235 and pos[1]>=210:
#print("Friend request sent to {}".format(self.search))
message = {'ID':25,'UserID':self.client.uID,'FriendID':self.search}
self.client.sock.send(pickle.dumps(message))
time.sleep(1)
print(self.client.pwf_section_messages)
if pos[0]<=1530 and pos[0]>=1410 and pos[1]<=56 and pos[1]>=6:
return
#Two main borders
pygame.draw.rect(self.screen,(255,255,255),[80,60,640.5,681],2)
pygame.draw.rect(self.screen,(255,255,255),[740.5,60,640.5,681],2)
pygame.draw.rect(self.screen,(255,255,255),[1410,6,120,50],2)
if pos[0]<=1530 and pos[0]>=1410 and pos[1]<=56 and pos[1]>=6:
pygame.draw.rect(self.screen,(51, 148, 163),[1412,8,118,48])
self.screen.blit(self.goback,(1415,15))
#input bar
pygame.draw.rect(self.screen,(0,255,0),[760.5,146,600.5,50],2)
#Blinking cursor
if self.cursor_visible:
pygame.draw.line(self.screen,(255,255,255),(self.cursor_coords[0][0],self.cursor_coords[0][1]),
(self.cursor_coords[1][0],self.cursor_coords[1][1]),2)
# invite buttons rects
for i in self.buttons_pos:
if self.status_list[self.first_friend_index+self.buttons_pos.index(i)]==True:
pygame.draw.rect(self.screen,(255,255,255),[620,i,80,25],2)
#invite buttons hover function
if len(self.Friends_list)>0:
if self.status_list[self.first_friend_index] and self.status_list[self.first_friend_index] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 171 and pos[1] >= 146:
pygame.draw.rect(self.screen,(255,255,255),[622,148,80,25])
if len(self.Friends_list)>1:
if self.status_list[self.first_friend_index+1] and self.status_list[self.first_friend_index+1] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 221 and pos[1] >= 196:
pygame.draw.rect(self.screen,(255,255,255),[622,198,80,25])
if len(self.Friends_list)>2:
if self.status_list[self.first_friend_index+2] and self.status_list[self.first_friend_index+2] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 271 and pos[1] >= 246:
pygame.draw.rect(self.screen,(255,255,255),[622,248,80,25])
if len(self.Friends_list)>3:
if self.status_list[self.first_friend_index+3] and self.status_list[self.first_friend_index+3] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 321 and pos[1] >= 296:
pygame.draw.rect(self.screen,(255,255,255),[622,298,80,25])
if len(self.Friends_list)>4:
if self.status_list[self.first_friend_index+4] and self.status_list[self.first_friend_index+4] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 371 and pos[1] >= 346:
pygame.draw.rect(self.screen,(255,255,255),[622,348,80,25])
if len(self.Friends_list)>5:
if self.status_list[self.first_friend_index+5] and self.status_list[self.first_friend_index+5] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 421 and pos[1] >= 396:
pygame.draw.rect(self.screen,(255,255,255),[622,398,80,25])
if len(self.Friends_list)>6:
if self.status_list[self.first_friend_index+6] and self.status_list[self.first_friend_index+6] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 471 and pos[1] >= 446:
pygame.draw.rect(self.screen,(255,255,255),[622,448,80,25])
if len(self.Friends_list)>7:
if self.status_list[self.first_friend_index+7] and self.status_list[self.first_friend_index+7] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 521 and pos[1] >= 496:
pygame.draw.rect(self.screen,(255,255,255),[622,498,80,25])
if len(self.Friends_list)>8:
if self.status_list[self.first_friend_index+8] and self.status_list[self.first_friend_index+8] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 571 and pos[1] >= 546:
pygame.draw.rect(self.screen,(255,255,255),[622,548,80,25])
if len(self.Friends_list)>9:
if self.status_list[self.first_friend_index+9] and self.status_list[self.first_friend_index+9] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 621 and pos[1] >= 596:
pygame.draw.rect(self.screen,(255,255,255),[622,598,80,25])
if len(self.Friends_list)>10:
if self.status_list[self.first_friend_index+10] and self.status_list[self.first_friend_index+10] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 671 and pos[1] >= 646:
pygame.draw.rect(self.screen,(255,255,255),[622,648,80,25])
if len(self.Friends_list)>11:
if self.status_list[self.first_friend_index+11] and self.status_list[self.first_friend_index+11] not in ["invited","busy"]:
if pos[0] <= 700 and pos[0] >= 620 and pos[1] <= 721 and pos[1] >= 696:
pygame.draw.rect(self.screen,(255,255,255),[622,698,80,25])
#add button hover
if self.search_result:
if pos[0]<=1350 and pos[0]>=1270 and pos[1]<=325 and pos[1]>=300:
pygame.draw.rect(self.screen,(255,255,255),[1272,300,80,25])
for i in self.button_texts_pos:
#online
if self.status_list[self.first_friend_index+self.button_texts_pos.index(i)] not in ["invited",False]:
self.screen.blit(self.invite_text,(627,i))
#already invited
elif self.status_list[self.first_friend_index+self.button_texts_pos.index(i)]=="invited":
self.screen.blit(self.invited_text,(580,i))
#busy
elif self.status_list[self.first_friend_index+self.button_texts_pos.index(i)]=="busy":
self.screen.blit(self.busy_text,(570,i))
#offline
else:
self.screen.blit(self.offline_text,(620,i))
for friend in self.Friends_texts[self.first_friend_index:self.last_friend_index]:
self.screen.blit(friend,self.Friends_texts_rects[self.Friends_texts.index(friend)])
self.screen.blit(self.titles[0],(320,80))
self.screen.blit(self.titles[1],(1010,80))
self.screen.blit(self.search_desc,(850,698))
if self.search_result:
self.screen.blit(self.search_result,(768,300))
#searched results add button
pygame.draw.rect(self.screen,(255,255,255),[1270,300,80,25],2)
self.screen.blit(self.add,(1295,300))
if self.client.room_id:
return
self.cursor_blink()
self.print_input()
pygame.display.flip()
self.clock.tick(60)
#width,height = 1536,801
#clock = pygame.time.Clock()
#screen = pygame.display.set_mode((width,height))
#pygame.display.set_caption("Play With Friend")
#play_with_friend = PlayWithFriend(screen,clock)
#play_with_friend.update()
#pygame.quit()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,745
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/testdb.py
|
import mysql.connector
from mysql.connector import errorcode
try:
mydb = mysql.connector.connect(
host = "localhost",
user = "superuser",
password = "Akash@2918",
database = 'testdb',
)
except mysql.connector.Error as err:
if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
print("Something is wrong with username or password")
elif err.errno == errorcode.ER_BAD_DB_ERROR:
print("Database does not exist")
else:
print(err)
cursor = mydb.cursor()
query2 = ('insert into Clients (UserID, Email, PASSWD, STATUS) values (%s, %s, %s, %s)')
def insert_data(userid, email, passwd, status='Not Verified'):
cursor.execute(query2, (userid, email, passwd, status,))
#query = ("select * from Clients")
query = ('select * from Clients')
custquery = ("CREATE TABLE customers (name VARCHAR(255), address(255))")
print(mydb)
cursor.execute(query)
print("The type of cursor is {}".format(type(cursor)))
for data in cursor:
print(data)
# print("Creating new table")
cursor.close()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,746
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/Testemail.py
|
import smtplib
from email.message import EmailMessage
class Email(object):
def __init__(self, to=None, message=None):
self.to = to
self.message = message
self.msg = EmailMessage()
def verification_email(self, to, uid, code):
self.to = to
self.msg['Subject'] = 'Testing Mail Indendations' #"Varification Code From Chess Project SE 2021"
self.msg['To'] = self.to
self.msg['From'] = "Chess Project SE 2021"
self.msg.set_content("Hello,\n\n \tYour varification code for account is 123456")
try:
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login('chessprojectse2021@gmail.com', 'Chess@2021')
server.send_message(msg)
return True
except:
print("Error while sending the mail to the user {}".format(uid))
return False
def Send_VerificationCode(to, uid, code):
msg = EmailMessage()
msg['Subject'] = 'Verification Code From Chess Project'
msg['From'] = 'Chess Project SE 2021'
msg['To'] = to
msg.set_content('Hello sending test mail for testing function to user {} and code is {}'.format(uid, code))
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login('chessprojectse2021@gmail.com', 'Chess@2021')
server.send_message(msg)
print("Mail sent")
return True
Send_VerificationCode(to='malavekarakash2229@yahoo.com', uid="Akash2918", code="123456")
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,747
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/testmail.py
|
# import smtplib
# from email.message import EmailMessage
# msg = EmailMessage()
# msg['Subject'] = 'Testing Mail Indendations'
# msg['From'] = 'Chess Project SE 2021'
# msg['To'] = 'malavekarakash2229@yahoo.com'
# msg.set_content("Test Email from Chess Project SE 2021\n\n \t Testing Indendations")
# server = smtplib.SMTP_SSL('smtp.gmail.com', 465)
# server.login('chessprojectse2021@gmail.com', 'Chess@2021')
# server.send_message(msg)
# server.quit()
# print("Mail sent")
from email import Email
Uemal = Email(to='malavekarakash2229@yahoo.com', message="Hello User")
Uemal.verification_email(to='malavekarakash2229@yahoo.com', uid="Akash2918", code="123456")
print("Done")
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,748
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/Room.py
|
import random
import pickle
import threading
class Room(object):
def __init__(self, roomid=None, user1=None, user2=None, spectators= [], db=None, rooms=None):
self.RoomID = roomid
self.User1 = user1['UserID'] ##User is a dictonary containing userid, conn
self.User2 = user2['UserID']
self.Rooms = rooms
self.spectators = spectators ## Spectators is list of user dict containing uuid and conn
self.board_messages = []
self.db = db
self.chat_messages = []
self.game_end = False
self.conn1 = user1['Conn']
self.conn2 = user2['Conn']
self.win = None
self.lost = None
self.move_log = None
self.set_turns()
self.chat_thread = threading.Thread(target=self.broadcast_chat_message)
self.board_thread = threading.Thread(target=self.broadcast_board_message)
self.chat_thread.start()
self.board_thread.start()
def update_database(self):
self.db.insert_new_game_info(self.RoomID, self.User1, self.User2)
self.db.insert_History_details(self.RoomID, self.move_log)
self.db.update_lost_status(self.lost)
self.db.update_win_status(self.win)
print("Data added to the database successfully")
return
def set_turns(self):
num = random.randint(1, 100)
if num%2 == 0:
data1 = {
'ID': 2200,
'Turn': 'White',
'Message': 'Start game with white pieces',
'RoomID': self.RoomID
}
data2 = {
'ID': 2200,
'Turn': 'Black',
'Message': 'Start game with black pieces',
'RoomID': self.RoomID
}
# res1 = pickle.dumps(data1)
# res2 = pickle.dumps(data2)
# self.conn1.send(res1)
# self.conn2.send(res2)
else:
data2 = {
'ID': 2200,
'Turn': 'White',
'Message': 'Start game with white pieces',
'RoomID': self.RoomID
}
data1 = {
'ID': 2200,
'Turn': 'Black',
'Message': 'Start game with black pieces',
'RoomID': self.RoomID
}
res1 = pickle.dumps(data1)
res2 = pickle.dumps(data2)
self.conn1.send(res1)
self.conn2.send(res2)
return
# def broadcast_message(self, message):
# print("Inside the broadcast message")
# sender = message['UserID']
# message = pickle.dumps(message)
# if sender == self.User1:
# self.conn2.send(message)
# for spect in self.spectators:
# conn = spect['conn']
# conn.send(message)
# elif sender == self.User2:
# self.conn1.send(message)
# for spect in self.spectators:
# conn = spect['conn']
# conn.send(message)
# else:
# self.conn1.send(message)
# self.conn2.send(message)
# for spect in self.spectators:
# if sender == spect['UserID']:
# continue
# else:
# conn = spect['conn']
# conn.send(message)
# print("Exited from broadcast messages")
# return
def broadcast_message_to_client(self, message):
data = pickle.dumps(message)
self.conn1.send(data)
print("Message sent to {}".format(self.User1))
self.conn2.send(data)
print("Message sent to {}".format(self.User2))
print("Message broadcaste")
return
def broadcast_chat_message(self):
while not self.game_end:
if len(self.chat_messages) > 0:
print("The chat messages are {}".format(self.chat_messages))
message = self.chat_messages.pop()
data = pickle.dumps(message)
uid = message['UserID']
if uid == self.User1:
self.conn2.send(data)
else:
self.conn1.send(data)
else:
continue
print("Returning from chat messages")
return
def broadcast_board_message(self):
while not self.game_end:
if len(self.board_messages) > 0:
print("The pending board messages {}".format(self.board_messages))
msg = self.board_messages.pop()
data = pickle.dumps(msg)
self.conn1.send(data)
self.conn2.send(data)
else:
continue
print("Returning from board messages")
return
def start(self):
print("User 1 {}".format(self.User1))
print("User2 {}".format(self.User2))
print("Conn1 {}".format(self.conn1))
print("conn2 {}".format(self.conn2))
# while True:
# if len(self.board_messages) > 0:
# print("{}".format(self.board_messages))
# message = self.board_messages.pop(0)
# print("{}".format(message))
# elif len(self.chat_messages) > 0:
# print("{}".format(self.chat_messages))
# message = self.chat_messages.pop(0)
# print("The chat messages is {}".format(message))
# while not self.game_end :
# if len(self.board_messages) > 0:
# print("board messages : {}".format(self.board_messages))
# message = self.board_messages.pop(0)
# #checkmate = message['Checkmate']
# checkmate = False
# if checkmate:
# self.game_end = True
# self.win = message['Win']
# self.lost = message['Lost']
# self.move_log = message['Move_log']
# self.spectators.clear()
# i = 0
# for i in range(len(self.Rooms)):
# if self.Rooms[i]['RoomID'] == self.RoomID:
# self.Rooms.pop(i)
# else:
# continue
# # self.broadcast_message(message)
# elif len(self.chat_messages) > 0:
# print("Chat messages {}".format(self.chat_messages))
# message = self.chat_messages.pop(0)
# else:
# continue
# self.broadcast_message(message)
# self.update_database()
# return
# def broadcast_chat_message(self, message):
# pass
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,749
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/functions.py
|
import pygame
from pygame.locals import *
from time import *
import sys
from threading import Thread
from socket import *
import time
import random
#from chat_panel import *
from move_functions import Moves_manager, CastleRights
import pickle
captured_piece = None
moved_piece = None
pygame.init()
BLACK = (0, 0, 0)
GRAY = (130, 130, 130)
WHITE = (255, 255, 255)
GREEN = (0, 102, 0)
LIGHTBLUE = (51, 153, 255)
COLOR1 = (48, 128, 42)
COLOR2 = (118, 196, 112)
COLOR3 = (153, 77, 0)
COLOR4 = (255, 155, 51)
COLOR5 = (71, 144, 192)
COLOR6 = (185, 214, 232)
COLOR7 = (105, 105, 105)
COLOR8 = (166, 166, 166)
LIGHTGREEN = (153, 255, 153)
LIGHTNAVY = (153, 153, 255)
RED = (255, 0, 0)
FONT = pygame.font.SysFont('freesansbold.ttf', 25)
FONT1 = pygame.font.SysFont('freesansbold.ttf', 35)
AXIS_COORD_FONT = pygame.font.SysFont('consolas', 25, True)
class box:
def __init__(self, x, y, xstart, ystart, width, height):
self.x = x
self.y = y
self.xstart = xstart
self.ystart = ystart
self.is_empty = True
self.width = width
self.height = height
self.piece = None
class interface:
def __init__(self, width, height, client, ctype):
self.width = width
self.height = height
self.ctype = ctype
if self.ctype == 1:
self.board_colors = (COLOR1, COLOR2)
elif self.ctype == 2:
self.board_colors = (COLOR3, COLOR4)
elif self.ctype == 3:
self.board_colors = (COLOR5, COLOR6)
elif self.ctype == 4:
self.board_colors = (COLOR7, COLOR8)
self.screen = None
self.grid = []
self.delay = 500
self.current_time = pygame.time.get_ticks()
self.change_time = self.current_time + self.delay
self.cursor_visible = True
self.message = ""
self.chat_buffer_text = []
self.chat_buffer_graphic = []
self.last_message_done = True
self.cursor_position = 0
self.max_message_length = 25
self.old_messages = []
self.first_msg = 0
self.last_msg = 0
# self.server = '65.0.204.13'
self.port = 12000
self.client = client
self.username = self.client.uID
# self.connect_to_server()
self.receive_thread = Thread(target=self.decode_messages)
self.receive_thread.start()
def generate_board_coordinates(self):
self.xstart = self.width * (20 / 100)
self.ystart = self.height * (0.998 / 100)
self.boardheight = 780
self.boardwidth = self.boardheight
self.xend = self.xstart + self.boardwidth
self.boxwidth = self.boardwidth // 8
self.boxheight = self.boardheight // 8
for row in range(8):
self.grid.append([])
for column in range(8):
self.grid[row].append(box(row, column, int(self.xstart + 2 + (column * self.boxwidth)),
self.ystart + 2 + (row * self.boxheight), self.boxwidth, self.boxheight))
def generate_settings_panel(self):
self.panel_xstart = self.xend + self.width * (0.97 / 100)
self.panel_ystart = self.ystart
self.panelwidth = (self.width - self.width * (0.97 / 100)) - self.panel_xstart
self.panelheight = self.height * (9.9 / 100)
def generate_killed_pieces_box(self):
self.killed_xstart = self.xend + self.width * (0.97 / 100)
self.killed_ystart = self.panel_ystart + self.panelheight + self.width * (0.97 / 100)
self.killed_box_width = self.panelwidth
self.killed_box_height = self.height * (31 / 100) - 50
def generate_chatbox(self):
self.chatbox_xstart = self.xend + self.width * (0.97 / 100)
self.chatbox_ystart = self.killed_ystart + self.killed_box_height + self.width * (0.97 / 100)
self.chatbox_width = self.panelwidth
self.chatbox_height = self.boardheight + self.ystart - self.chatbox_ystart
def draw_chess_board(self):
for i in range(8):
for j in range(8):
if (i + j) % 2 == 1:
pygame.draw.rect(self.screen, self.board_colors[0],
[self.grid[i][j].xstart, self.grid[i][j].ystart, self.boxwidth, self.boxheight])
else:
pygame.draw.rect(self.screen, self.board_colors[1],
[self.grid[i][j].xstart, self.grid[i][j].ystart, self.boxwidth, self.boxheight])
def generate_message_input_box(self):
self.messsage_input_xstart = self.chatbox_xstart + self.width * (0.97 / 100)
self.messsage_input_ystart = self.chatbox_ystart + self.chatbox_height - (self.height * (6 / 100))
self.messsage_input_width = self.chatbox_width - self.width * (1.9 / 100)
self.messsage_input_height = self.width * (2.6 / 100)
self.message_text_xstart = self.messsage_input_xstart + self.width * (0.3 / 100)
self.message_text_ystart = self.messsage_input_ystart + self.height * (0.6 / 100)
self.cursor_coord = [[self.messsage_input_xstart + self.width * (0.3 / 100),
self.messsage_input_ystart + self.height * (0.6 / 100)],
[self.messsage_input_xstart + self.width * (0.3 / 100),
self.messsage_input_ystart + self.height * (4.4 / 100)]]
def cursor_blink(self):
self.current_time = pygame.time.get_ticks()
if self.current_time >= self.change_time:
self.change_time = self.current_time + self.delay
self.cursor_visible = not self.cursor_visible
return self.cursor_visible
def get_chat_input(self, events):
for event in events:
if event.type == pygame.KEYDOWN:
if bool(event.unicode) and len(self.message) < self.max_message_length and event.key != pygame.K_RETURN:
self.message = self.message[:self.cursor_position] + event.unicode + self.message[
self.cursor_position:]
self.cursor_position += 1
self.message_text = FONT.render(self.message, True, WHITE)
self.message_rect = self.message_text.get_rect()
self.message_rect.center = (
self.messsage_input_xstart + self.width * (0.3 / 100) + (self.message_rect.width // 2),
self.messsage_input_ystart + self.height * (2 / 100))
text = FONT.render(self.message[self.cursor_position:], True, BLACK)
rect = text.get_rect()
self.cursor_coord[0][0] = self.messsage_input_xstart + self.width * (
0.3 / 100) + self.message_rect.width - rect.width
self.cursor_coord[1][0] = self.cursor_coord[0][0]
if self.cursor_coord[0][
0] >= self.messsage_input_xstart + self.messsage_input_width - self.width * (0.3 / 100):
self.cursor_coord[0][
0] = self.messsage_input_xstart + self.messsage_input_width - self.width * (0.3 / 100)
self.cursor_coord[1][0] = self.cursor_coord[0][0]
elif (event.key == pygame.K_RETURN or event.key == pygame.K_KP_ENTER) and len(self.message) > 0:
self.last_message_done = False
self.chat_buffer_text.append("Me:" + self.message)
msg = self.message
msg = {'ID': 30, 'UserID': self.username, 'Data': msg, 'RoomID': self.client.room_id}
# send the text message on socket
self.client.sock.send(pickle.dumps(msg))
text = FONT.render(self.message, True, WHITE)
rect = text.get_rect()
username = FONT.render(self.username + ":", True, (0, 255, 0))
uname_rect = username.get_rect()
self.chat_buffer_graphic.append(([username, uname_rect], [text, rect]))
self.message = ""
self.cursor_position = 0
self.cursor_coord = [[self.messsage_input_xstart + self.width * (0.3 / 100),
self.messsage_input_ystart + self.height * (0.6 / 100)],
[self.messsage_input_xstart + self.width * (0.3 / 100),
self.messsage_input_ystart + self.height * (4.4 / 100)]]
self.last_msg += 1
if self.last_msg >= 13:
self.first_msg += 1
elif event.key == pygame.K_LEFT and self.cursor_position > 0:
self.cursor_position -= 1
string_right_to_cursor = self.message[self.cursor_position:]
text = FONT.render(string_right_to_cursor, True, BLACK)
rect = text.get_rect()
# change cursor coordinates
self.cursor_coord[0][0] = self.messsage_input_xstart + self.width * (
0.3 / 100) + self.message_rect.width - rect.width
self.cursor_coord[1][0] = self.cursor_coord[0][0]
elif event.key == pygame.K_RIGHT and self.cursor_position < len(self.message):
self.cursor_position += 1
string_left_to_cursor = self.message[:self.cursor_position]
text = FONT.render(string_left_to_cursor, True, BLACK)
rect = text.get_rect()
self.cursor_coord[0][0] = self.messsage_input_xstart + self.width * (0.3 / 100) + rect.width
self.cursor_coord[1][0] = self.cursor_coord[0][0]
elif event.key == pygame.K_BACKSPACE and self.cursor_position > 0:
self.cursor_position -= 1
deleted_letter = self.message[self.cursor_position]
temp = ""
for i in range(len(self.message)):
if i != self.cursor_position:
temp += self.message[i]
self.message = temp
self.message_text = FONT.render(self.message, True, WHITE)
self.message_rect = self.message_text.get_rect()
self.message_rect.center = (
self.messsage_input_xstart + self.width * (0.3 / 100) + (self.message_rect.width // 2),
self.messsage_input_ystart + self.height * (2 / 100))
deleted_letter = FONT.render(deleted_letter, True, BLACK)
rect = deleted_letter.get_rect()
self.cursor_coord[0][0] -= rect.width
self.cursor_coord[1][0] = self.cursor_coord[0][0]
if len(self.message) > 0:
self.screen.blit(self.message_text, self.message_rect)
if len(self.message) == 0:
self.cursor_coord = [[self.messsage_input_xstart + self.width * (0.3 / 100),
self.messsage_input_ystart + self.height * (0.6 / 100)],
[self.messsage_input_xstart + self.width * (0.3 / 100),
self.messsage_input_ystart + self.height * (4.4 / 100)]]
def print_messages(self):
free_space_start = [self.messsage_input_xstart, self.messsage_input_ystart - self.height * (3.7 / 100)]
for i in reversed(self.chat_buffer_graphic[self.first_msg:self.last_msg]):
i[0][1].center = (free_space_start[0] + i[0][1].width // 2, free_space_start[1])
i[1][1].center = (free_space_start[0] + i[0][1].width + (i[1][1].width // 2) + 3, free_space_start[1])
self.screen.blit(i[0][0], i[0][1])
self.screen.blit(i[1][0], i[1][1])
free_space_start[1] -= self.height * (3.7 / 100)
def generate_other_functionalities(self):
self.game_info_box1_coords = (self.width * (0.65 / 100), self.ystart)
self.game_info_box1_width = (self.height * (33.7 / 100)) + 10
self.game_info_box1_height = (self.boardheight // 2) - (self.height * (1.2 / 100))
self.game_info_box2_coords = (
self.width * (0.65 / 100), self.ystart + self.game_info_box1_height + (self.height * (1.2 / 100)))
self.game_info_box2_width = self.game_info_box1_width
self.game_info_box2_height = (self.boardheight // 2)
def decode_messages(self):
while True:
try:
# message = self.sock.recv(1024).decode()
message = self.client.chat_messages.pop()
if message['ID'] == 30:
username, message = message['UserID'], message['Data']
if message and username:
self.chat_buffer_text.append(message)
username = FONT.render(username + ":", True, RED)
uname_rect = username.get_rect()
message = FONT.render(message, True, WHITE)
message_rect = message.get_rect()
self.chat_buffer_graphic.append(([username, uname_rect], [message, message_rect]))
self.last_msg += 1
if self.last_msg >= 10:
self.first_msg += 1
else:
self.chat_buffer_text.append(message)
text1 = message.split(" ")[0]
text2 = message[len(text1):]
text1 = FONT.render(text1, True, BLACK)
text2 = FONT.render(text2, True, BLACK)
text1_rect = text1.get_rect()
text2_rect = text2.get_rect()
self.chat_buffer_graphic.append(([text1, text1_rect], [text2, text2_rect]))
self.last_msg += 1
if self.last_msg >= 10:
self.first_msg += 1
except:
pass
def __del__(self):
print("Interface object deleted")
class Piece(object):
def __init__(self, name, position, color):
self.name = name
self.position = position
self.image = None
self.color = color
self.pos_adjustment = None
self.is_alive = True
self.is_at_start = True
self.locked = True
def __str__(self):
return "Name:{}\nPosition:{}\nColor:{}\nAlive:{}".format(self.name, self.position, self.color, self.is_alive)
class game(object):
def __init__(self, Interface=None, screen=None, sfac=None, piece_type=None, my_piece_color=None):
self.main_menu = None
self.my_piece_color = my_piece_color
self.my_turn = True if self.my_piece_color == 'White' else False
self.opponent_turn = not self.my_turn
if self.my_piece_color == "White":
self.enemy_piece_color = "Black"
else:
self.enemy_piece_color = "White"
self.white_pieces_images = {}
self.black_pieces_images = {}
self.captured_pieces = {'wpawn': 0, 'wrook': 0, 'wknight': 0, 'wbishop': 0, 'wqueen': 0,
'bpawn': 0, 'brook': 0, 'bknight': 0, 'bbishop': 0, 'bqueen': 0}
self.captured_pieces_count = {}
self.piece_type = piece_type
self.grid = Interface.grid
self.Interface = Interface
self.moves_manager = None
#self.moved_piece = None
self.myprofimg = None
self.enemyprofimg = None
self.myname = None
self.enemyname = None
self.selected_square = list()
self.playerclick = list()
self.opponentclick = list()
self.whiteToMove = True #if self.my_piece_color == "White" else False # modify after pawn work properly
self.opponent_coords = []
self.opponent_click = []
self.currentCastleRights = CastleRights(True, True, True, True)
self.enemy_pieces = {}
self.selected_box = None
self.screen = screen
self.pieces_scaling_factor = sfac
self.selected_piece = None
self.get_captured_pieces_numbers()
self.get_buttons()
self.position_adjustment = {
'type1': {'WPawn': (0, 0), 'WRook': (0, 0),
'WKnight': (0, 0), 'WBishop': (0, 0),
'WQueen': (0, 0), 'WKing': (0, 0),
'BPawn': (0, 0), 'BRook': (0, 0),
'BKnight': (0, 0), 'BBishop': (0, 0),
'BQueen': (0, 0), 'BKing': (0, 0)},
'type2': {'WPawn': (Interface.width * (0.19 / 100), 0),
'WRook': (Interface.width * (0.4 / 100), Interface.height * (0.62 / 100)),
'WKnight': (Interface.width * (0.97 / 100), Interface.height * (0.4 / 100)),
'WBishop': (Interface.width * (0.5 / 100), Interface.height * (0.5 / 100)),
'WQueen': (Interface.width * (1.1 / 100), -Interface.height * (0.4 / 100)),
'WKing': (Interface.width * (0.97 / 100), Interface.height * (0.4 / 100)),
'BPawn': (0, 0), 'BRook': (Interface.width * (0.4 / 100), Interface.height * (0.4 / 100)),
'BKnight': (Interface.width * (1 / 100), Interface.height * (0.12 / 100)),
'BBishop': (Interface.width * (0.65 / 100), Interface.height * (1.1 / 100)),
'BQueen': (Interface.width * (1.1 / 100), 0),
'BKing': (Interface.width * (0.97 / 100), Interface.height * (0.4 / 100))},
'type3': {'WPawn': (Interface.width * (1 / 100), Interface.height * (0.62 / 100)),
'WRook': (Interface.width * (0.97 / 100), Interface.height * (0.9 / 100)),
'WKnight': (Interface.width * (0.97 / 100), Interface.height * (0.5 / 100)),
'WBishop': (Interface.width * (0.97 / 100), Interface.height * (0.7 / 100)),
'WQueen': (Interface.width * (0.32 / 100), Interface.height * (0.7 / 100)),
'WKing': (Interface.width * (0.8 / 100), Interface.height * (0.9 / 100)),
'BPawn': (Interface.width * (0.97 / 100), Interface.height * (0.6 / 100)),
'BRook': (Interface.width * (0.97 / 100), Interface.height * (0.6 / 100)),
'BKnight': (Interface.width * (1 / 100), Interface.height * (0.24 / 100)),
'BBishop': (Interface.width * (1 / 100), Interface.height * (0.12 / 100)),
'BQueen': (Interface.width * (0.32 / 100), 0),
'BKing': (Interface.width * (0.84 / 100), Interface.height * (0.5 / 100))},
}
self.opponent_checkmate = False
self.opponent_forfeited = False
self.opponent_left = False
self.receive_messages = Thread(target=self.decode_messages)
self.receive_messages.start()
def get_buttons(self):
self.music_on_button = FONT1.render("Music:ON", True, (0, 180, 0))
self.music_off_button = FONT1.render("Music:OFF", True, (0, 180, 0))
self.forfeit_button = FONT1.render("Forfeit", True, (0, 0, 0))
self.leave_button = FONT1.render("Leave", True, (0, 0, 0))
def load_pieces(self):
piece = ['Rook', 'Bishop', 'Knight', 'Queen', 'King', 'Pawn']
for i in piece:
self.white_pieces_images[i] = pygame.image.load(f'Media/pieces type {self.piece_type}/W{i}.png')
if self.pieces_scaling_factor:
for piece in self.white_pieces_images:
self.white_pieces_images[piece] = pygame.transform.scale(self.white_pieces_images[piece],
(self.pieces_scaling_factor,
self.pieces_scaling_factor))
for i in piece:
self.black_pieces_images[i] = pygame.image.load(f'Media/pieces type {self.piece_type}/B{i}.png')
if self.pieces_scaling_factor:
for piece in self.black_pieces_images:
self.black_pieces_images[piece] = pygame.transform.scale(self.black_pieces_images[piece],
(self.pieces_scaling_factor,
self.pieces_scaling_factor))
def init_my_pieces(self):
pawns = [Piece('pawn', [6, 0], self.my_piece_color.lower()), Piece('pawn', [6, 1], self.my_piece_color.lower()),
Piece('pawn', [6, 2], self.my_piece_color.lower()),
Piece('pawn', [6, 3], self.my_piece_color.lower()), Piece('pawn', [6, 4], self.my_piece_color.lower()),
Piece('pawn', [6, 5], self.my_piece_color.lower()),
Piece('pawn', [6, 6], self.my_piece_color.lower()), Piece('pawn', [6, 7], self.my_piece_color.lower())]
for pawn in pawns:
if self.my_piece_color == "White":
pawn.image = self.white_pieces_images['Pawn']
else:
pawn.image = self.black_pieces_images['Pawn']
pawn.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Pawn'.format(self.my_piece_color[0].upper())]
self.moves_manager.pieces['pawn'] = pawns
for i in range(8):
self.grid[6][i].piece = pawns[i]
rooks = [Piece('rook', [7, 0], "{}".format(self.my_piece_color.lower())),
Piece('rook', [7, 7], self.my_piece_color.lower())]
for rook in rooks:
if self.my_piece_color == "White":
rook.image = self.white_pieces_images['Rook']
else:
rook.image = self.black_pieces_images['Rook']
rook.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Rook'.format(self.my_piece_color[0].upper())]
self.moves_manager.pieces['rook'] = rooks
self.grid[7][0].piece = rooks[0]
self.grid[7][7].piece = rooks[1]
bishops = [Piece('bishop', [7, 2], self.my_piece_color.lower()),
Piece('bishop', [7, 5], self.my_piece_color.lower())]
for bishop in bishops:
if self.my_piece_color == "White":
bishop.image = self.white_pieces_images['Bishop']
else:
bishop.image = self.black_pieces_images['Bishop']
bishop.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Bishop'.format(self.my_piece_color[0].upper())]
self.moves_manager.pieces['bishop'] = bishops
self.grid[7][2].piece = bishops[0]
self.grid[7][5].piece = bishops[1]
knights = [Piece('knight', [7, 1], self.my_piece_color.lower()),
Piece('knight', [7, 6], self.my_piece_color.lower())]
for knight in knights:
if self.my_piece_color == "White":
knight.image = self.white_pieces_images['Knight']
else:
knight.image = self.black_pieces_images['Knight']
knight.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Knight'.format(self.my_piece_color[0].upper())]
self.moves_manager.pieces['knight'] = knights
self.grid[7][1].piece = knights[0]
self.grid[7][6].piece = knights[1]
if self.my_piece_color == "White":
king = Piece('king', [7, 4], self.my_piece_color.lower())
king.image = self.white_pieces_images['King']
self.grid[7][4].piece = king
else:
king = Piece('king', [7, 3], self.my_piece_color.lower())
king.image = self.black_pieces_images['King']
self.grid[7][3].piece = king
king.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}King'.format(self.my_piece_color[0].upper())]
self.moves_manager.pieces['king'] = [king]
if self.my_piece_color == "White":
queen = Piece('queen', [7, 3], self.my_piece_color.lower())
queen.image = self.white_pieces_images['Queen']
self.grid[7][3].piece = queen
else:
queen = Piece('queen', [7, 4], self.my_piece_color.lower())
queen.image = self.black_pieces_images['Queen']
self.grid[7][4].piece = queen
queen.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Queen'.format(self.my_piece_color[0].upper())]
self.moves_manager.pieces['queen'] = [queen]
for i in range(6, 8):
for j in range(0, 8):
self.grid[i][j].is_empty = False
for i in range(2, 6):
for j in range(0, 8):
self.grid[i][j].is_empty = True
def init_opponent_pieces(self):
pawns = [Piece('pawn', [1, 0], self.enemy_piece_color.lower()),
Piece('pawn', [1, 1], self.enemy_piece_color.lower()),
Piece('pawn', [1, 2], self.enemy_piece_color.lower()),
Piece('pawn', [1, 3], self.enemy_piece_color.lower()),
Piece('pawn', [1, 4], self.enemy_piece_color.lower()),
Piece('pawn', [1, 5], self.enemy_piece_color.lower()),
Piece('pawn', [1, 6], self.enemy_piece_color.lower()),
Piece('pawn', [1, 7], self.enemy_piece_color.lower())]
for pawn in pawns:
if self.enemy_piece_color == "Black":
pawn.image = self.black_pieces_images['Pawn']
else:
pawn.image = self.white_pieces_images['Pawn']
pawn.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Pawn'.format(self.enemy_piece_color[0].upper())]
self.moves_manager.enemy_pieces['pawn'] = pawns
for i in range(8):
self.grid[1][i].piece = pawns[i]
rooks = [Piece('rook', [0, 0], self.enemy_piece_color.lower()),
Piece('rook', [0, 7], self.enemy_piece_color.lower())]
for rook in rooks:
if self.enemy_piece_color == "Black":
rook.image = self.black_pieces_images['Rook']
else:
rook.image = self.white_pieces_images['Rook']
rook.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Rook'.format(self.enemy_piece_color[0].upper())]
self.moves_manager.enemy_pieces['rook'] = rooks
self.grid[0][0].piece = rooks[0]
self.grid[0][7].piece = rooks[1]
bishops = [Piece('bishop', [0, 2], self.enemy_piece_color.lower()),
Piece('bishop', [0, 5], self.enemy_piece_color.lower())]
for bishop in bishops:
if self.enemy_piece_color == "Black":
bishop.image = self.black_pieces_images['Bishop']
else:
bishop.image = self.white_pieces_images['Bishop']
bishop.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Bishop'.format(self.enemy_piece_color[0].upper())]
self.moves_manager.enemy_pieces['bishop'] = bishops
self.grid[0][2].piece = bishops[0]
self.grid[0][5].piece = bishops[1]
knights = [Piece('knight', [0, 1], self.enemy_piece_color.lower()),
Piece('knight', [0, 6], self.enemy_piece_color.lower())]
for knight in knights:
if self.enemy_piece_color == "Black":
knight.image = self.black_pieces_images['Knight']
else:
knight.image = self.white_pieces_images['Knight']
knight.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Knight'.format(self.enemy_piece_color[0].upper())]
self.moves_manager.enemy_pieces['knight'] = knights
self.grid[0][1].piece = knights[0]
self.grid[0][6].piece = knights[1]
if self.enemy_piece_color == "Black":
king = Piece('king', [0, 4], self.enemy_piece_color.lower())
king.image = self.black_pieces_images['King']
self.grid[0][4].piece = king
else:
king = Piece('king', [0, 3], self.enemy_piece_color.lower())
king.image = self.white_pieces_images['King']
self.grid[0][3].piece = king
king.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}King'.format(self.enemy_piece_color[0].upper())]
self.moves_manager.enemy_pieces['king'] = [king]
if self.enemy_piece_color == "White":
queen = Piece('queen', [0, 4], self.enemy_piece_color.lower())
queen.image = self.white_pieces_images['Queen']
self.grid[0][4].piece = queen
else:
queen = Piece('queen', [0, 3], self.enemy_piece_color.lower())
queen.image = self.black_pieces_images['Queen']
self.grid[0][3].piece = queen
queen.pos_adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
'{}Queen'.format(self.enemy_piece_color[0].upper())]
self.moves_manager.enemy_pieces['queen'] = [queen]
for i in range(0, 2):
for j in range(0, 8):
self.grid[i][j].is_empty = False
def update_pieces(self):
for pieces in self.moves_manager.pieces:
for piece in self.moves_manager.pieces[pieces]:
if piece.locked and piece.is_alive:
self.screen.blit(piece.image, (
self.grid[piece.position[0]][piece.position[1]].xstart + piece.pos_adjustment[0],
self.grid[piece.position[0]][piece.position[1]].ystart + piece.pos_adjustment[1]))
for pieces in self.moves_manager.enemy_pieces:
for piece in self.moves_manager.enemy_pieces[pieces]:
if piece.locked and piece.is_alive:
self.screen.blit(piece.image, (
self.grid[piece.position[0]][piece.position[1]].xstart + piece.pos_adjustment[0],
self.grid[piece.position[0]][piece.position[1]].ystart + piece.pos_adjustment[1]))
# as of now, both white and black pieces can move as per some basic rules.
def handle_click_event(self,coords):
# print(self.whiteToMove, self.my_turn)
# print(self.moves_manager.currentCastleRights.bks, self.moves_manager.currentCastleRights.bqs)
self.selected_box = self.grid[coords[0]][coords[1]]
my_color = self.my_piece_color.lower()
'''
if self.whiteToMove and self.my_piece_color == 'White':
my_color = "white"
enemy_color = "black"
elif not self.whiteToMove and self.my_piece_color == 'Black':
my_color = "black"
enemy_color = "white"
'''
# print(self.my_turn, end = " - self.my_turn\n")
# print(self.whiteToMove)
# print(self.selected_box.piece)
# if self.my_turn and .....
if self.my_turn and len(self.playerclick) == 0: # player clicks on first square
if self.grid[coords[0]][coords[1]].is_empty == False: # if the square selected is not empty
if self.grid[coords[0]][coords[1]].piece.color == my_color: # player selects his piece
self.selected_square = coords
self.playerclick.append(self.selected_square)
# print(self.playerclick)
# print('1')
self.moves_manager.get_legal_moves(self.grid[coords[0]][coords[1]].piece, self.grid)
elif (self.grid[coords[0]][
coords[1]].piece.color != my_color): # player selects empty square or opposite piece
self.selected_box = None
self.playerclick = list()
self.selected_square = list()
# print('2')
else: # if square selected is empty
self.selected_box = None
self.playerclick = list()
self.selected_square = list()
# print('3')
# if self.my_turn and .....
elif self.my_turn and len(self.playerclick) == 1: # player clicks on second square
if self.grid[coords[0]][coords[1]].is_empty == False: # if selected square is not empty
if self.grid[coords[0]][
coords[1]].piece.color == my_color: # if selected square contains player's piece
# print("Hellllo")
if self.selected_square == coords: # if player clicks same square twice ie he's trying to deselect
self.selected_square = list()
self.playerclick = list()
self.selected_box = None
# print('4')
else:
self.selected_square = coords
self.playerclick = [self.selected_square]
self.moves_manager.get_legal_moves(self.grid[coords[0]][coords[1]].piece, self.grid)
# for i in self.moves_manager.legal_moves:
# print(i.x, i.y, end="i.x, i.y")
elif self.grid[coords[0]][coords[1]].piece.color != my_color:
if coords in [[i.x, i.y] for i in self.moves_manager.legal_moves]:
# print(self.moves_manager.selected_piece)
print("1")
message = {'ID': 60, 'UserID': self.Interface.username, 'RoomID': self.Interface.client.room_id,
'Start': self.playerclick[0],#Rutvik
'Stop': coords, 'MoveNo': self.moves_manager.moves_count,
'Turn': "white" if self.my_piece_color == "Black" else "black",'Checkmate':False,'Forfeit':False,'Stalemate':False,'Left':False}
# send the move message to all other users
self.Interface.client.sock.send(pickle.dumps(message))
self.opponent_turn = True
self.my_turn = False
self.move(self.grid[self.playerclick[0][0]][self.playerclick[0][1]].piece, coords, self.grid,
self.position_adjustment['type{}'.format(self.piece_type)][
self.moves_manager.adjustment_dictionary_name])
#print("My pawns")
#for move in self.moves_manager.pieces['pawn']:
# print(move.position,end = " ")
#print("Enemy pawns")
#for move in self.moves_manager.enemy_pieces['pawn']:
# print(move.position,end = " ")
# print('6')
self.selected_square = list()
self.playerclick = list()
#############################print(self.moves_manager.checks, end = " ")
self.whiteToMove = not self.whiteToMove
if self.whiteToMove:
self.moves_manager.moves_count += 1
else:
self.selected_square = list()
self.playerclick = list()
self.selected_box = None
else:
if coords in [[i.x, i.y] for i in self.moves_manager.legal_moves]:
# print(self.moves_manager.selected_piece)
print("2")
message = {'ID': 60, 'UserID': self.Interface.username, 'RoomID': self.Interface.client.room_id,
'Start': self.playerclick[0],#Rutvik
'Stop': coords, 'MoveNo': self.moves_manager.moves_count,
'Turn': "white" if self.my_piece_color == "Black" else "black",'Checkmate':False,'Forfeit':False,'Stalemate':False,'Left':False}
# send the move message to all other users
self.Interface.client.sock.send(pickle.dumps(message))
self.opponent_turn = True
self.my_turn = False
self.move(self.grid[self.playerclick[0][0]][self.playerclick[0][1]].piece, coords, self.grid,
self.position_adjustment['type{}'.format(self.piece_type)][
self.moves_manager.adjustment_dictionary_name])
#print("My pawns")
# for move in self.moves_manager.pieces['pawn']:
# print(move.position,end = " ")
#print("Enemy pawns")
#for move in self.moves_manager.enemy_pieces['pawn']:
# print(move.position,end = " ")
# print('7')
self.selected_square = list()
self.playerclick = list()
self.whiteToMove = not self.whiteToMove
if self.whiteToMove:
self.moves_manager.moves_count += 1
else:
self.selected_square = list()
self.playerclick = list()
self.selected_box = None
print("Black -- legal moves",self.moves_manager.legal_moves)
elif self.my_turn:
self.selected_box = None
self.selected_square = []
self.playerclick = list()
self.selected_square = list()
self.moves_manager.legal_moves = []
self.moves_manager.selected_piece = None
# print('8')
print(len(self.opponentclick),self.selected_square,coords,self.opponent_turn)
if self.opponent_turn and len(self.opponentclick) == 0: # player clicks on first square
#print("True 1")
if self.grid[coords[0]][coords[1]].is_empty == False: # if the square selected is not empty
self.selected_square = coords
print("selected sq",self.selected_square)
self.opponentclick.append(self.selected_square)
# print(self.playerclick)
# print('1')
elif self.opponent_turn and len(self.opponentclick) == 1: # player clicks on second square
#print("True 2")
if self.grid[coords[0]][coords[1]].is_empty == False: # if selected square is not empty
if self.grid[coords[0]][coords[1]].piece.color == my_color:
# print(self.moves_manager.selected_piece)
self.opponent_turn =False
self.my_turn = True
print("From opponent move:",self.opponent_turn)
adjustment_name = self.grid[self.opponentclick[0][0]][self.opponentclick[0][1]].piece.color[0].upper()+ self.grid[self.opponentclick[0][0]][self.opponentclick[0][1]].piece.name[0].upper() + self.grid[self.opponentclick[0][0]][self.opponentclick[0][1]].piece.name[1:]
self.move(self.grid[self.opponentclick[0][0]][self.opponentclick[0][1]].piece, coords, self.grid,
self.position_adjustment['type{}'.format(self.piece_type)][
adjustment_name])
# print('6')
self.selected_square = list()
self.opponentclick = list()
else:
# print(self.moves_manager.selected_piece)
print("3")
self.opponent_turn =False
self.my_turn = True
print("From opponent move:",self.opponent_turn)
adjustment_name = self.grid[self.opponentclick[0][0]][self.opponentclick[0][1]].piece.color[0].upper() + self.grid[self.opponentclick[0][0]][self.opponentclick[0][1]].piece.name[0].upper() + self.grid[self.opponentclick[0][0]][self.opponentclick[0][1]].piece.name[1:]
self.move(self.grid[self.opponentclick[0][0]][self.opponentclick[0][1]].piece, coords, self.grid,
self.position_adjustment['type{}'.format(self.piece_type)][
adjustment_name])
# print('7')
self.selected_square = list()
self.playerclick = list()
#self.whiteToMove = not self.whiteToMove
#if self.whiteToMove:
# self.moves_manager.moves_count += 1
elif self.opponent_turn:
self.selected_box = None
self.opponentclick = list()
self.selected_square = list()
self.moves_manager.legal_moves = []
self.moves_manager.selected_piece = None
# print('8')
def highlight_selected_box(self):
if self.selected_box:
pygame.draw.rect(self.screen, (0, 255, 0),
[self.selected_box.xstart, self.selected_box.ystart, self.selected_box.width,
self.selected_box.height], 3)
def highlight_legal_moves(self):
if self.selected_box:
if self.moves_manager.legal_moves:
for i in self.moves_manager.legal_moves:
pygame.draw.rect(self.screen, (0, 255, 0), [i.xstart, i.ystart, i.width, i.height], 4)
ranks_to_rows = {"1": 7, "2": 6, "3": 5, "4": 4,
"5": 3, "6": 2, "7": 1, "8": 0}
rows_to_ranks = {v: k for k, v in ranks_to_rows.items()}
files_to_cols = {"a": 0, "b": 1, "c": 2, "d": 3,
"e": 4, "f": 5, "g": 6, "h": 7}
cols_to_files = {v: k for k, v in files_to_cols.items()}
def chess_notation(self, piece, destination, board):
if piece.color == 'white':
print(self.moves_manager.moves_count, end=" ")
if piece.name == 'pawn':
if board[destination[0]][destination[1]].is_empty == True:
return self.rank_file(destination[0], destination[1])
else:
return self.cols_to_files[piece.position[0]] + "x" + self.rank_file(destination[0], destination[1])
elif piece.name == 'knight':
if board[destination[0]][destination[1]].is_empty == True:
return "N" + self.rank_file(destination[0], destination[1])
else:
return "Nx" + self.rank_file(destination[0], destination[1])
elif piece.name == 'king':
if board[destination[0]][destination[1]].is_empty == True:
if self.my_piece_color == 'White':
if (piece.position == [7, 4] and destination == [7, 6]):
return "0-0"
elif (piece.position == [7, 4] and destination == [7, 2]):
return "0-0-0"
elif self.my_piece_color == 'Black':
if (piece.position == [7, 3] and destination == [7, 1]):
return "0-0"
elif (piece.position == [7, 3] and destination == [7, 5]):
return "0-0-0"
else:
return piece.name[:1].upper() + self.rank_file(destination[0], destination[1])
else:
return piece.name[:1].upper() + "x" + self.rank_file(destination[0], destination[1])
else:
if board[destination[0]][destination[1]].is_empty == True:
return piece.name[:1].upper() + self.rank_file(destination[0], destination[1])
else:
return piece.name[:1].upper() + "x" + self.rank_file(destination[0], destination[1])
def rank_file(self, row, col):
return self.cols_to_files[col] + self.rows_to_ranks[row]
def get_move_type(self, source, destination):
# print(source,destination)
# type value
# [+,+] - 1
# [+,-] - 2
# [-,+] - 3
# [-,-] - 4
# [+,0] - 5
# [0,+] - 6
# [-,0] - 7
# [0,-] - 8
if destination[0] < source[0] and destination[1] > source[1]:
return 1
elif destination[0] > source[0] and destination[1] > source[1]:
return 2
elif destination[0] < source[0] and destination[1] < source[1]:
return 3
elif destination[0] > source[0] and destination[1] < source[1]:
return 4
elif destination[0] == source[0] and destination[1] > source[1]:
return 5
elif destination[0] < source[0] and destination[1] == source[1]:
return 6
elif destination[0] == source[0] and destination[1] < source[1]:
return 7
elif destination[0] > source[0] and destination[1] == source[1]:
return 8
def update_castling_rights(self, moved_piece):
if not self.my_turn:
if moved_piece.color == 'white':
if moved_piece.name == 'king':
self.currentCastleRights.wks = False
self.currentCastleRights.wqs = False
elif moved_piece.name == 'rook':
if moved_piece.position[0] == 7 and moved_piece.position[1] == 0:
self.currentCastleRights.wqs = False
elif moved_piece.position[0] == 7 and moved_piece.position[1] == 7:
self.currentCastleRights.wks = False
else:
if moved_piece.name == 'king':
self.currentCastleRights.bks = False
self.currentCastleRights.bqs = False
elif moved_piece.name == 'rook':
if moved_piece.position[0] == 7 and moved_piece.position[1] == 0:
self.currentCastleRights.bks = False
elif moved_piece.position[0] == 7 and moved_piece.position[1] == 7:
self.currentCastleRights.bqs = False
else:
if moved_piece.color == 'white':
if moved_piece.name == 'king':
self.currentCastleRights.wks = False
self.currentCastleRights.wqs = False
elif moved_piece.name == 'rook':
if moved_piece.position[0] == 0 and moved_piece.position[1] == 0:
self.currentCastleRights.wks = False
elif moved_piece.position[0] == 0 and moved_piece.position[1] == 7:
self.currentCastleRights.wqs = False
else:
if moved_piece.name == 'king':
self.currentCastleRights.bks = False
self.currentCastleRights.bqs = False
elif moved_piece.name == 'rook':
if moved_piece.position[0] == 7 and moved_piece.position[1] == 0:
self.currentCastleRights.bqs = False
elif moved_piece.position[0] == 0 and moved_piece.position[1] == 7:
self.currentCastleRights.bks = False
def move(self, piece, destination, board, adjustment):
global moved_piece,captured_piece_num,captured_piece
#self.moves_manager.enpassant_captured_piece = None
# self.moves_manager.enpassant_sq = list()
# get start and stop positions
#print("Piece capture:",self.grid[destination[0]][destination[1]].piece,self.grid[destination[0]][destination[1]].is_empty)
move_type = self.get_move_type(piece.position, destination)
# print(move_type)
start = [board[piece.position[0]][piece.position[1]].xstart + adjustment[0],
board[piece.position[0]][piece.position[1]].ystart + adjustment[1]]
stop = [board[destination[0]][destination[1]].xstart + adjustment[0],
board[destination[0]][destination[1]].ystart + adjustment[1] + 1]
# print(self.chess_notation(piece, destination, board), end = " ")
moved_piece = piece
self.update_castling_rights(moved_piece)
# pawn promotion condition
print(piece,destination)
if (piece.name == 'pawn' and piece.color == self.my_piece_color.lower() and piece.position[0] == 1 and destination[0] == 0) or (
piece.name == 'pawn' and piece.color != self.my_piece_color.lower() and piece.position[0] == 6 and destination[
0] == 7
):
self.moves_manager.promotion = True
# enpassant condition generation
#self.moves_manager.enpassant = False
#if moved_piece.name == 'pawn' and abs(moved_piece.position[0] - destination[0]) == 2:
# self.moves_manager.enpassant_sq = list()
# if moved_piece.position[1] + 1 <= 7:
# if self.grid[destination[0]][destination[1] + 1].is_empty == False:
# pic = self.grid[destination[0]][destination[1] + 1].piece
# if pic.name == 'pawn' and pic.color != moved_piece.color:
# self.moves_manager.enpassant = True
# self.moves_manager.enpassant_sq.append([pic.position, destination, [
# moved_piece.position[0] - pic.position[0], moved_piece.position[1] - pic.position[1]]])
# if moved_piece.position[1] + 1 >= 0:
# if self.grid[destination[0]][destination[1] - 1].is_empty == False:
# pic = self.grid[destination[0]][destination[1] - 1].piece
# if pic.name == 'pawn' and pic.color != moved_piece.color:
# self.moves_manager.enpassant = True
# self.moves_manager.enpassant_sq.append([pic.position, destination, [
# moved_piece.position[0] - pic.position[0], moved_piece.position[1] - pic.position[1]]])
# setting capture in enpassant
# if piece.name == 'pawn' and self.grid[destination[0]][destination[1]].is_empty == True and [abs(
# piece.position[0] - destination[0]), abs(piece.position[1] - destination[1])] == [1, 1]:
# self.moves_manager.enpassant_captured_piece = self.grid[self.moves_manager.enpassant_sq[0][1][0]][
# self.moves_manager.enpassant_sq[0][1][1]].piece
# captured_piece = self.moves_manager.enpassant_captured_piece
# # print(captured_piece)
# if captured_piece.color == 'white':
# for i in range(len(self.moves_manager.pieces[captured_piece.name])):
# if self.moves_manager.pieces[captured_piece.name][i].position == self.moves_manager.enpassant_sq[0][
# 1]:
# captured_piece_num = i
# # self.moves_manager.pieces[captured_piece.name][i].position = [-1,-1]
# break
# else:
# for i in range(len(self.moves_manager.enemy_pieces[captured_piece.name])):
# if self.moves_manager.enemy_pieces[captured_piece.name][i].position == \
# self.moves_manager.enpassant_sq[0][1]:
# captured_piece_num = i
# # self.moves_manager.enemy_pieces[captured_piece.name][i].position = [-1, -1]
# break
# self.captured_pieces[captured_piece.color[:1] + captured_piece.name] += 1
# self.moves_manager.enpassant_sq = list()
# set the current box of grid to empty
self.grid[piece.position[0]][piece.position[1]].is_empty = True
if self.grid[destination[0]][
destination[1]].is_empty == False: # destination square non-empty means definitely contains black piece
captured_piece = self.grid[destination[0]][destination[1]].piece
#print("capture condition:",self.captured_piece)
'''
setting position of captured piece to [-1,-1] because
[-1,-1] doesn't exist on the grid and so does the captured piece
'''
if not self.my_turn:
for i in range(len(self.moves_manager.enemy_pieces[captured_piece.name])):
if self.moves_manager.enemy_pieces[captured_piece.name][i].position == destination:
captured_piece_num = i
# #self.moves_manager.enemy_pieces[captured_piece.name][i].position = [-1, -1]
break
else:
for i in range(len(self.moves_manager.pieces[captured_piece.name])):
if self.moves_manager.pieces[captured_piece.name][i].position == destination:
captured_piece_num = i
# #self.moves_manager.enemy_pieces[captured_piece.name][i].position = [-1, -1]
break
#print(self.captured_piece)
self.captured_pieces[captured_piece.color[:1] + captured_piece.name] += 1
#else:
# captured_piece = self.moves_manager.enpassant_captured_piece
# print(captured_piece)
# '''
self.grid[destination[0]][destination[1]].piece = piece
# moving rook while castling
if piece.name == 'king' and not self.my_turn:
if self.my_piece_color == 'White':
if piece.position == [7, 4]:
if destination == [7, 6]: # white king-side castling
castling_rook = self.grid[7][7].piece
self.grid[7][7].is_empty = True
self.grid[7][5].is_empty = False
self.grid[7][5].piece = castling_rook
self.grid[7][5].piece.position = [7, 5]
for i in range(len(self.moves_manager.pieces['rook'])):
if self.moves_manager.pieces['rook'][i].position == [7, 7]:
self.moves_manager.pieces['rook'][i].position = [7, 5]
break
elif destination == [7, 2]: # white queen-side castling
castling_rook = self.grid[7][0].piece
self.grid[7][0].is_empty = True
self.grid[7][3].is_empty = False
self.grid[7][3].piece = castling_rook
self.grid[7][3].piece.position = [7, 3]
for i in range(len(self.moves_manager.pieces['rook'])):
if self.moves_manager.pieces['rook'][i].position == [7, 0]:
self.moves_manager.pieces['rook'][i].position = [7, 3]
break
else:
if piece.position == [7, 3]:
if destination == [7, 1]: # black king-side castling
castling_rook = self.grid[7][0].piece
self.grid[7][0].is_empty = True
self.grid[7][2].is_empty = False
self.grid[7][2].piece = castling_rook
self.grid[7][2].piece.position = [7, 2]
for i in range(len(self.moves_manager.pieces['rook'])):
if self.moves_manager.pieces['rook'][i].position == [7, 0]:
self.moves_manager.pieces['rook'][i].position = [7, 2]
break
elif destination == [7, 5]: # black queen-side castling
castling_rook = self.grid[7][7].piece
self.grid[7][7].is_empty = True
self.grid[7][4].is_empty = False
self.grid[7][4].piece = castling_rook
self.grid[7][4].piece.position = [7, 4]
for i in range(len(self.moves_manager.pieces['rook'])):
if self.moves_manager.pieces['rook'][i].position == [7, 7]:
self.moves_manager.pieces['rook'][i].position = [7, 4]
break
else:
if self.my_piece_color == 'White':
if piece.position == [0, 4]:
if destination == [0, 6]: # opponent's king-side castling
castling_rook = self.grid[0][7].piece
self.grid[0][7].is_empty = True
self.grid[0][5].is_empty = False
self.grid[0][5].piece = castling_rook
self.grid[0][5].piece.position = [0, 5]
for i in range(len(self.moves_manager.enemy_pieces['rook'])):
if self.moves_manager.enemy_pieces['rook'][i].position == [0, 7]:
self.moves_manager.enemy_pieces['rook'][i].position = [0, 5]
break
elif destination == [0, 2]: # opponent's queen-side castling
castling_rook = self.grid[0][0].piece
self.grid[0][0].is_empty = True
self.grid[0][3].is_empty = False
self.grid[0][3].piece = castling_rook
self.grid[0][3].piece.position = [0, 3]
for i in range(len(self.moves_manager.enemy_pieces['rook'])):
if self.moves_manager.enemy_pieces['rook'][i].position == [0, 0]:
self.moves_manager.enemy_pieces['rook'][i].position = [0, 3]
break
else:
if piece.position == [0, 3]:
if destination == [0, 1]: # opponent's king-side castling
castling_rook = self.grid[0][0].piece
self.grid[0][0].is_empty = True
self.grid[0][2].is_empty = False
self.grid[0][2].piece = castling_rook
self.grid[0][2].piece.position = [0, 2]
for i in range(len(self.moves_manager.enemy_pieces['rook'])):
if self.moves_manager.enemy_pieces['rook'][i].position == [0, 0]:
self.moves_manager.enemy_pieces['rook'][i].position = [0, 2]
break
elif destination == [0, 5]: # opponent's queen-side castling
castling_rook = self.grid[0][7].piece
self.grid[0][7].is_empty = True
self.grid[0][4].is_empty = False
self.grid[0][4].piece = castling_rook
self.grid[0][4].piece.position = [0, 4]
for i in range(len(self.moves_manager.enemy_pieces['rook'])):
if self.moves_manager.enemy_pieces['rook'][i].position == [0, 7]:
self.moves_manager.enemy_pieces['rook'][i].position = [0, 4]
break
# unlock the piece so that update_pieces function does not show it on screen when it is moving
piece.locked = False
# moving piece
while True:
# keep updating the screen and pieces while moving piece
self.update(pygame.mouse.get_pos())
self.update_pieces()
self.Interface.print_messages()
# add animation conditions for different pieces
# diagonal up right
if move_type == 1 and piece.name in ['pawn', 'bishop', 'queen', 'king']:
if start[0] <= stop[0] and start[1] >= stop[1]:
start[0] += 6
start[1] -= 6
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
# diagonal down right
elif move_type == 2 and piece.name in ['pawn', 'bishop', 'queen', 'king']:
if start[0] <= stop[0] and start[1] <= stop[1]:
start[0] += 6
start[1] += 6
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
# diagonal up left
elif move_type == 3 and piece.name in ['pawn', 'bishop', 'queen', 'king']:
if start[0] >= stop[0] and start[1] >= stop[1]:
start[0] -= 6
start[1] -= 6
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
# diagonal down left
elif move_type == 4 and piece.name in ['pawn', 'bishop', 'queen', 'king']:
if start[0] >= stop[0] and start[1] <= stop[1]:
start[0] -= 6
start[1] += 6
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
# straight upward
elif move_type == 6 and piece.name in ['king', 'pawn', 'queen', 'rook']:
if start[1] >= stop[1]:
start[1] -= 6
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
# straight downward
elif move_type == 8 and piece.name in ['king', 'pawn', 'queen', 'rook']:
if start[1] <= stop[1]:
start[1] += 6
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
elif move_type == 5 and piece.name in ['king', 'queen', 'rook']:
if start[0] <= stop[0]:
start[0] += 6
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
piece.locked = True
break
elif move_type == 7 and piece.name in ['king', 'queen', 'rook']:
if start[0] >= stop[0]:
start[0] -= 6
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
piece.locked = True
break
########################################### Movement of Knights ########################################################
# upwards right
elif move_type == 1 and "knight" == piece.name:
if start[0] <= stop[0] and start[1] >= stop[1]:
if abs(piece.position[0] - destination[0]) == 2 and abs(
piece.position[1] - destination[1]) == 1:
start[0] += 2
start[1] -= 4
else:
start[0] += 4
start[1] -= 2
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
# downward right
elif move_type == 2 and "knight" == piece.name:
if start[0] <= stop[0] and start[1] <= stop[1]:
if abs(piece.position[0] - destination[0]) == 1 and abs(piece.position[1] - destination[1]) == 2:
start[0] += 4
start[1] += 2
else:
start[0] += 2
start[1] += 4
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
# upward left
elif move_type == 3 and "knight" == piece.name:
if start[0] >= stop[0] and start[1] >= stop[1]:
if abs(piece.position[0] - destination[0]) == 1 and abs(piece.position[1] - destination[1]) == 2:
start[0] -= 4
start[1] -= 2
else:
start[0] -= 2
start[1] -= 4
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
# downward left
elif move_type == 4 and "knight" == piece.name:
if start[0] >= stop[0] and start[1] <= stop[1]:
if abs(piece.position[0] - destination[0]) == 1 and abs(piece.position[1] - destination[1]) == 2:
start[0] -= 4
start[1] += 2
else:
start[0] -= 2
start[1] += 4
self.screen.blit(piece.image, (start[0], start[1]))
pygame.display.flip()
else:
piece.position = destination
# self.moves_manager.wking_loc = self.moves_manager.pieces['king'][0].position
# self.moves_manager.bking_loc = self.moves_manager.enemy_pieces['king'][0].position
# print(self.moves_manager.wking_loc, self.moves_manager.bking_loc)
piece.locked = True
break
if self.moves_manager.promotion:
promotedpiece = 'Queen'
#promoted_piece = Queen / Rook / Bishop / Knight
if self.grid[destination[0]][destination[1]].is_empty == False:
self.grid[destination[0]][destination[1]].piece.is_alive = False
if not self.my_turn:
#Queen promoted from my_turn condition
#Promoted queen's color
Promoted_Piece = Piece('queen', destination, 'white')
if self.my_piece_color == 'Black':
Promoted_Piece.color = 'black'
Promoted_Piece.image = self.white_pieces_images[promotedpiece]
Promoted_Piece.pos_adjustment = self.position_adjustment['type3'][
self.my_piece_color[0] + promotedpiece]
self.moves_manager.pieces[promotedpiece.lower()].append(Promoted_Piece)
else:
Promoted_Piece = Piece('queen', destination, 'white')
Promoted_Piece.image = self.black_pieces_images[promotedpiece]
Promoted_Piece.pos_adjustment = self.position_adjustment['type3'][
self.enemy_piece_color[0] + promotedpiece]
if self.my_piece_color == 'White':
Promoted_Piece.color = 'black'
self.moves_manager.enemy_pieces[promotedpiece.lower()].append(Promoted_Piece)
'''
if self.my_piece_color == 'White':
Promoted_Piece.image = self.white_pieces_images[promotedpiece]
Promoted_Piece.pos_adjustment = self.position_adjustment['type3'][self.my_piece_color[0] + promotedpiece]
self.moves_manager.pieces[promotedpiece.lower()].append(Promoted_Piece)
elif self.my_piece_color == 'Black':
Promoted_Piece.image = self.black_pieces_images[promotedpiece]
Promoted_Piece.pos_adjustment = self.position_adjustment['type3'][self.my_piece_color[0] + promotedpiece]
Promoted_Piece.color = 'black'
self.moves_manager.pieces[promotedpiece.lower()].append(Promoted_Piece)
'''
#print(Promoted_Piece)
#self.moves_manager.promotion = True
self.grid[piece.position[0]][piece.position[1]].is_empty = True
#self.update_pieces()
self.grid[destination[0]][destination[1]].piece = Promoted_Piece
#Promoted_Queen.locked = True
#self.screen.blit(Promoted_Queen.image, (self.grid[destination[0]][destination[1]].xstart + Promoted_Queen.pos_adjustment[0],
# self.grid[destination[0]][destination[1]].ystart + Promoted_Queen.pos_adjustment[1]))
#self.update_pieces()
#pygame.display.flip()
#print(captured_piece)
if captured_piece:
# if captured_piece.color == 'white':
# self.moves_manager.pieces[captured_piece.name][captured_piece_num].is_alive = False
# else:
# self.moves_manager.enemy_pieces[captured_piece.name][captured_piece_num].is_alive = False
#print("In actual capturing",captured_piece)
if not self.my_turn:
self.moves_manager.enemy_pieces[captured_piece.name][captured_piece_num].is_alive = False
else:
self.moves_manager.pieces[captured_piece.name][captured_piece_num].is_alive = False
adjustment = self.position_adjustment['type{}'.format(self.piece_type)][
captured_piece.color[0].upper() + captured_piece.name[0].upper() + captured_piece.name[1:]]
start = [board[piece.position[0]][piece.position[1]].xstart + adjustment[0],
board[piece.position[0]][piece.position[1]].ystart + adjustment[1]]
if captured_piece.name == "pawn" and captured_piece.color == "white":
stop = [1110, 110]
elif captured_piece.name == "pawn" and captured_piece.color == "black":
print("Captured black pawn")
stop = [1110, 208]
elif captured_piece.name == "rook" and captured_piece.color == "white":
stop = [1190, 109]
elif captured_piece.name == "rook" and captured_piece.color == "black":
stop = [1190, 206]
elif captured_piece.name == "queen" and captured_piece.color == "white":
stop = [1430, 106]
elif captured_piece.name == "queen" and captured_piece.color == "black":
stop = [1430, 201]
elif captured_piece.name == "bishop" and captured_piece.color == "white":
stop = [1275, 107]
elif captured_piece.name == "bishop" and captured_piece.color == "black":
stop = [1275, 203]
elif captured_piece.name == "knight" and captured_piece.color == "white":
stop = [1355, 105]
elif captured_piece.name == "knight" and captured_piece.color == "black":
stop = [1355, 203]
dest = [int((stop[0] - self.Interface.xstart) // (self.Interface.boardwidth // 8)),
int((stop[1] - self.Interface.ystart) // (self.Interface.boardheight // 8))]
# print(dest,captured_piece.position)
if captured_piece.position[0] < dest[1]:
move_type = "downright"
elif captured_piece.position[0] == dest[1]:
move_type = "straight_right"
else:
move_type = "upright"
print("Move type",move_type)
while True:
self.screen.fill((255, 255, 255))
self.update(pygame.mouse.get_pos())
self.update_pieces()
self.Interface.print_messages()
# print(start,stop)
if move_type == "upright":
if start[0] <= stop[0] and start[1] >= stop[1]:
start[0] += abs(captured_piece.position[1] - dest[0])+2
start[1] -= abs(captured_piece.position[0] - dest[1])+2
self.screen.blit(captured_piece.image, (start[0], start[1]))
pygame.display.flip()
else:
break
elif move_type == "downright":
if start[0] <= stop[0] and start[1] <= stop[1]:
start[0] += abs(captured_piece.position[1] - dest[0])+2
start[1] += abs(captured_piece.position[0] - dest[1])+2
self.screen.blit(captured_piece.image, (start[0], start[1]))
pygame.display.flip()
else:
break
elif move_type == "straight_right":
if start[0] <= stop[0]:
start[0] += abs(captured_piece.position[1] - dest[0])+2
self.screen.blit(captured_piece.image, (start[0], start[1]))
pygame.display.flip()
else:
break
# print(captured_piece)
'''
if captured_piece is not None:
if captured_piece.color == 'white':
for i in range(len(self.moves_manager.pieces[captured_piece.name])):
if captured_piece.position == self.moves_manager.pieces[captured_piece.name][
i].position and self.moves_manager.pieces[captured_piece.name][i].is_alive == False:
self.moves_manager.pieces[captured_piece.name].remove(self.moves_manager.pieces[captured_piece.name][
i])
break
elif captured_piece.color == 'black':
for i in range(len(self.moves_manager.enemy_pieces[captured_piece.name])):
if captured_piece.position == self.moves_manager.enemy_pieces[captured_piece.name][
i].position and self.moves_manager.enemy_pieces[captured_piece.name][i].is_alive == False:
self.moves_manager.enemy_pieces[captured_piece.name].remove(self.moves_manager.enemy_pieces[captured_piece.name][
i])
break
'''
if self.moves_manager.promotion:
self.update_pieces()
self.screen.blit(Promoted_Piece.image,
(self.grid[destination[0]][destination[1]].xstart + Promoted_Piece.pos_adjustment[0],
self.grid[destination[0]][destination[1]].ystart + Promoted_Piece.pos_adjustment[1]))
pygame.display.flip()
self.moves_manager.promotion = False
self.moves_manager.selected_piece = None
self.moves_manager.legal_moves = []
self.selected_box = None
self.grid[destination[0]][destination[1]].is_empty = False
captured_piece = None
captured_piece_num = None
def update_castle(self):
return self.currentCastleRights
def update_wtm(self):
return self.whiteToMove
def decode_messages(self):
while True:
try:
message = self.Interface.client.board_messages.pop()
if message['ID'] == 60:
if message['Start']:
start = message['Start']
start = [7-start[0],7-start[1]]
if message['Stop']:
stop = message['Stop']
stop = [7 - stop[0], 7 - stop[1]]
#print(start,stop)
if message['Turn']:
self.whiteToMove = True if (
message['Turn'] == "white" and self.my_piece_color == "White") else False
try:
self.moves_manager.moves_count += 1
except:
pass
try:
piece = self.grid[start[0]][start[1]].piece
except:
pass
#print("count:",self.moves_manager.moves_count)
try:
self.opponentclick = []
self.opponent_click = start
self.opponent_coords = stop
except:
pass
if bool(message['Checkmate']):
self.opponent_checkmate = True
elif bool(message['Forfeit']):
self.opponent_forfeited = True
elif bool(message['Stalemate']):
self.stalemate = True
elif bool(message['Left']):
self.opponent_left = True
except:
pass
# graphical
def get_captured_pieces_numbers(self):
num = FONT.render("0", True, RED)
rects = [num.get_rect() for i in range(10)]
rects[0].center = (1170, 183)
rects[1].center = (1255, 183)
rects[2].center = (1337, 183)
rects[3].center = (1420, 183)
rects[4].center = (1503, 183)
rects[5].center = (1170, 281)
rects[6].center = (1255, 281)
rects[7].center = (1337, 281)
rects[8].center = (1420, 281)
rects[9].center = (1503, 281)
pieces = ['wpawn', 'wrook', 'wbishop', 'wknight', 'wqueen', 'bpawn', 'brook', 'bbishop', 'bknight', 'bqueen']
for i in range(len(pieces)):
num = FONT.render(str(self.captured_pieces[pieces[i]]), True, RED)
self.captured_pieces_count[pieces[i]] = [num, rects[i]]
def get_axes(self):
a = AXIS_COORD_FONT.render("a", True, BLACK)
b = AXIS_COORD_FONT.render("b", True, BLACK)
c = AXIS_COORD_FONT.render("c", True, BLACK)
d = AXIS_COORD_FONT.render("d", True, BLACK)
e = AXIS_COORD_FONT.render("e", True, BLACK)
f = AXIS_COORD_FONT.render("f", True, BLACK)
g = AXIS_COORD_FONT.render("g", True, BLACK)
h = AXIS_COORD_FONT.render("h", True, BLACK)
self.x_axis_coords = {"a": [a, a.get_rect()], "b": [b, b.get_rect()], "c": [c, c.get_rect()],
"d": [d, d.get_rect()],
"e": [e, e.get_rect()], "f": [f, f.get_rect()], "g": [g, g.get_rect()],
"h": [h, h.get_rect()]}
self.x_axis_coords["a"][1].center = (315, 773)
self.x_axis_coords["b"][1].center = (412, 773)
self.x_axis_coords["c"][1].center = (509, 773)
self.x_axis_coords["d"][1].center = (606, 773)
self.x_axis_coords["e"][1].center = (703, 773)
self.x_axis_coords["f"][1].center = (800, 773)
self.x_axis_coords["g"][1].center = (897, 773)
self.x_axis_coords["h"][1].center = (994, 773)
one = AXIS_COORD_FONT.render("1", True, BLACK)
two = AXIS_COORD_FONT.render("2", True, BLACK)
three = AXIS_COORD_FONT.render("3", True, BLACK)
four = AXIS_COORD_FONT.render("4", True, BLACK)
five = AXIS_COORD_FONT.render("5", True, BLACK)
six = AXIS_COORD_FONT.render("6", True, BLACK)
seven = AXIS_COORD_FONT.render("7", True, BLACK)
eight = AXIS_COORD_FONT.render("8", True, BLACK)
self.y_axis_coords = {"one": [one, one.get_rect()], "two": [two, two.get_rect()],
"three": [three, three.get_rect()], "four": [four, four.get_rect()],
"five": [five, five.get_rect()], "six": [six, six.get_rect()],
"seven": [seven, seven.get_rect()], "eight": [eight, eight.get_rect()]}
self.y_axis_coords["one"][1].center = (315, 700)
self.y_axis_coords["two"][1].center = (315, 603)
self.y_axis_coords["three"][1].center = (315, 506)
self.y_axis_coords["four"][1].center = (315, 409)
self.y_axis_coords["five"][1].center = (315, 312)
self.y_axis_coords["six"][1].center = (315, 215)
self.y_axis_coords["seven"][1].center = (315, 118)
self.y_axis_coords["eight"][1].center = (315, 21)
def update(self, pos):
# Board - Border
pygame.draw.rect(self.screen, BLACK, [self.Interface.xstart, self.Interface.ystart, self.Interface.boardwidth,
self.Interface.boardheight], 3)
# Settings Panel - Border
pygame.draw.rect(self.screen, BLACK,
[self.Interface.panel_xstart, self.Interface.panel_ystart, self.Interface.panelwidth,
self.Interface.panelheight], 2)
# Captured Pieces - Border
pygame.draw.rect(self.screen, BLACK,
[self.Interface.killed_xstart, self.Interface.killed_ystart, self.Interface.killed_box_width,
self.Interface.killed_box_height], 2)
# Chat box - Border
pygame.draw.rect(self.screen, BLACK,
[self.Interface.chatbox_xstart, self.Interface.chatbox_ystart, self.Interface.chatbox_width,
self.Interface.chatbox_height], 2)
# Player 1 - Border
pygame.draw.rect(self.screen, BLACK,
[self.Interface.game_info_box1_coords[0], self.Interface.game_info_box1_coords[1],
self.Interface.game_info_box1_width, self.Interface.game_info_box1_height], 3)
# Player 2 - Border
pygame.draw.rect(self.screen, BLACK,
[self.Interface.game_info_box2_coords[0], self.Interface.game_info_box2_coords[1],
self.Interface.game_info_box2_width, self.Interface.game_info_box2_height], 3)
# Board
self.Interface.draw_chess_board()
# Settings Panel
pygame.draw.rect(self.screen, (0, 102, 50), [self.Interface.panel_xstart + 2, self.Interface.panel_ystart + 2,
self.Interface.panelwidth - 2.5, self.Interface.panelheight - 2.5])
# Captured Pieces
pygame.draw.rect(self.screen, GREEN, [self.Interface.killed_xstart + 2, self.Interface.killed_ystart + 2,
self.Interface.killed_box_width - 2.5,
self.Interface.killed_box_height - 2.5])
# Chat box
pygame.draw.rect(self.screen, (23, 28, 38),
[self.Interface.chatbox_xstart + 2, self.Interface.chatbox_ystart + 2.5,
self.Interface.chatbox_width - 2.5, self.Interface.chatbox_height - 2.5])
# Chat box text bar - Border
#if self.Interface.chat_panel.selected == "chat":
pygame.draw.rect(self.screen, WHITE,
[self.Interface.messsage_input_xstart, self.Interface.messsage_input_ystart,
self.Interface.messsage_input_width, self.Interface.messsage_input_height], 2)
# Chat box text bar
pygame.draw.rect(self.screen, BLACK,
[self.Interface.messsage_input_xstart + 2, self.Interface.messsage_input_ystart + 2,
self.Interface.messsage_input_width - 3, self.Interface.messsage_input_height - 3])
if self.Interface.cursor_blink():
pygame.draw.line(self.screen, WHITE,
(self.Interface.cursor_coord[0][0], self.Interface.cursor_coord[0][1]),
(self.Interface.cursor_coord[1][0], self.Interface.cursor_coord[1][1]), 2)
# Captured pieces
self.screen.blit(self.white_pieces_images['Pawn'], (1110, 110))
self.screen.blit(self.white_pieces_images['Rook'], (1190, 109))
self.screen.blit(self.white_pieces_images['Bishop'], (1275, 107))
self.screen.blit(self.white_pieces_images['Knight'], (1355, 105))
self.screen.blit(self.white_pieces_images['Queen'], (1430, 106))
self.screen.blit(self.black_pieces_images['Pawn'], (1110, 208))
self.screen.blit(self.black_pieces_images['Rook'], (1190, 206))
self.screen.blit(self.black_pieces_images['Bishop'], (1275, 203))
self.screen.blit(self.black_pieces_images['Knight'], (1355, 203))
self.screen.blit(self.black_pieces_images['Queen'], (1430, 201))
pygame.draw.circle(self.screen, BLACK, (1170, 281), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1170, 281), 10)
pygame.draw.circle(self.screen, BLACK, (1255, 281), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1255, 281), 10)
pygame.draw.circle(self.screen, BLACK, (1337, 281), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1337, 281), 10)
pygame.draw.circle(self.screen, BLACK, (1420, 281), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1420, 281), 10)
pygame.draw.circle(self.screen, BLACK, (1503, 281), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1503, 281), 10)
pygame.draw.circle(self.screen, BLACK, (1170, 183), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1170, 183), 10)
pygame.draw.circle(self.screen, BLACK, (1255, 183), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1255, 183), 10)
pygame.draw.circle(self.screen, BLACK, (1337, 183), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1337, 183), 10)
pygame.draw.circle(self.screen, BLACK, (1420, 183), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1420, 183), 10)
pygame.draw.circle(self.screen, BLACK, (1503, 183), 12, 3)
pygame.draw.circle(self.screen, WHITE, (1503, 183), 10)
self.screen.blit(self.captured_pieces_count['wpawn'][0], self.captured_pieces_count['wpawn'][1])
self.screen.blit(self.captured_pieces_count['wrook'][0], self.captured_pieces_count['wrook'][1])
self.screen.blit(self.captured_pieces_count['wbishop'][0], self.captured_pieces_count['wbishop'][1])
self.screen.blit(self.captured_pieces_count['wknight'][0], self.captured_pieces_count['wknight'][1])
self.screen.blit(self.captured_pieces_count['wqueen'][0], self.captured_pieces_count['wqueen'][1])
self.screen.blit(self.captured_pieces_count['bpawn'][0], self.captured_pieces_count['bpawn'][1])
self.screen.blit(self.captured_pieces_count['brook'][0], self.captured_pieces_count['brook'][1])
self.screen.blit(self.captured_pieces_count['bbishop'][0], self.captured_pieces_count['bbishop'][1])
self.screen.blit(self.captured_pieces_count['bknight'][0], self.captured_pieces_count['bknight'][1])
self.screen.blit(self.captured_pieces_count['bqueen'][0], self.captured_pieces_count['bqueen'][1])
#self.Interface.chat_panel.mount(self.Interface.chatbox_xstart, self.Interface.chatbox_ystart)
for coord in self.x_axis_coords:
self.screen.blit(self.x_axis_coords[coord][0], self.x_axis_coords[coord][1])
for coord in self.y_axis_coords:
self.screen.blit(self.y_axis_coords[coord][0], self.y_axis_coords[coord][1])
pygame.draw.rect(self.screen, (0, 0, 0), [1115, 20, 140, 53], 2)
pygame.draw.rect(self.screen, (0, 0, 0), [1275, 20, 100, 53], 2)
pygame.draw.rect(self.screen, (0, 0, 0), [1395, 20, 110, 53], 2)
pygame.draw.rect(self.screen, (255, 255, 255), [1117, 22, 137, 50])
pygame.draw.rect(self.screen, (255, 255, 255), [1277, 22, 97, 50])
pygame.draw.rect(self.screen, (255, 255, 255), [1397, 22, 107, 50])
# focusing buttons
if pos[0] <= 1255 and pos[0] >= 1115 and pos[1] <= 73 and pos[1] >= 20:
pygame.draw.rect(self.screen, (94, 118, 128), [1117, 22, 137, 50])
elif pos[0] <= 1375 and pos[0] >= 1275 and pos[1] <= 73 and pos[1] >= 20:
pygame.draw.rect(self.screen, (94, 118, 128), [1277, 22, 97, 50])
elif pos[0] <= 1505 and pos[0] >= 1395 and pos[1] <= 73 and pos[1] >= 20:
pygame.draw.rect(self.screen, (94, 118, 128), [1397, 22, 107, 50])
if self.main_menu.settings_object.music:
self.screen.blit(self.music_on_button, (1125, 35))
else:
self.screen.blit(self.music_off_button,(1120,35))
self.screen.blit(self.forfeit_button, (1285, 35))
self.screen.blit(self.leave_button, (1415, 35))
self.screen.blit(self.myprofimg,(15,407))
self.screen.blit(self.enemyprofimg,(15,10))
self.screen.blit(self.enemyname,(50,349))
def __del__(self):
print("Game object deleted")
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,750
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/User.py
|
import pickle
#from Room import Room
from NewRoom import Room
import time
import random
import threading
import sys
class Client(object):
def __init__(self, UserID, conn, database, users, rooms, quickplay, message_queue):
self._userid = UserID
self.conn = conn
self.db = database
self.Users = users
self.Rooms = rooms
self.room = None
self.spectating = False
self.playing = False
self.imgbuf = b''
self.pieces = None
self.piece_no = None
self.quickplay = quickplay
self.message_queue = message_queue
self.request = False
self.cancel = False
self.thread = None
self.timeout = False
self.friends = None
def start(self):
LOGOUT = False
friends = self.db.get_friends_list(self._userid)
self.friends = friends
friends_requests = self.db.get_friends_request_list(self._userid)
friends_rejected = self.db.get_friends_rejected_list(self._userid)
online_friends = self.get_online_friends(friends, True)
busy_friends = self.get_busy_friends(online_friends)
online_rooms = self.get_online_rooms(friends)
data = {
'ID': 10,
'Friends': friends,
'Friend_Requests': friends_requests,
'Friends_Rejected': friends_rejected,
'Online_Friends': online_friends,
'Busy_Friends': list(busy_friends),
'Rooms': list(online_rooms)
}
sdata = pickle.dumps(data)
self.conn.send(sdata)
while not LOGOUT:
try:
rec = self.conn.recv(2048)
if rec :
data = pickle.loads(rec)
print("The test data ", data)
id = data['ID']
if id == 20: #sending requst to the friend with friendid for playing
friendId = data['FriendID']
req = {
'ID' : 50,
'Sender': self._userid,
'Reciever': friendId,
'Message': 'Friend request from user to play chess'
}
reqdata = pickle.dumps(req)
for u in self.Users:
if friendId == u['UserID']:
client = u['Client']
cconn = u['conn']
cconn.send(reqdata)
print("Message sent")
break
else:
continue
# if client:
# req = {
# 'ID' : 50,
# 'Sender': self._userid,
# 'Reciever': friendId,
# 'Message': 'Friend request from user to play chess'
# }
# reqdata = pickle.dumps(req)
# client.conn.send(reqdata)
# print("Message sent")
# else:
# continue
elif id == 24: ##Check existance of user
fid = data['FriendID']
data = self.db.check_existance_of_user(fid)
if data:
rev = {
'ID':24,
'Data': data,
'Status': True
}
self.conn.send(pickle.dumps(rev))
else:
res = {
'ID': 7,
'Message': "No user with given ID",
'Status': False
}
res = pickle.dumps(res)
self.conn.send(res)
elif id == 25: ##Sending friend request status => request accept or reject normal request
uid = data['UserID']
fid = data['FriendID']
if self.db.add_new_friend_request(uid, fid):
res = {
'ID': 25,
'Message': 'Request added successfully'
}
for usr in self.Users:
if usr['UserID'] == fid:
fconn = usr['conn']
fdata = {
'ID':27, ##Send online friend request
'UserID':fid,
'FriendID':uid,
'Message':"Friend request sent by friend"
}
fdata = pickle.dumps(fdata)
fconn.send(fdata)
break
else:
continue
else:
res = {
'ID': 7,
'Message': "Error While processing data"
}
res = pickle.dumps(res)
self.conn.send(res)
elif id == 26: ##Accept or reject the friend request
fid = data['FriendID']
self.db.add_friends_request_status(data)
elif id == 28: #delete friend from friend list
friendID = data['FriendID']
if self.db.remove_friend_from_friendlist(self._userid, friendID):
data = {
'ID':28,
'UserID':self._userid,
'FriendID':friendID,
'Message':'Friend deleted from friend list'
}
else:
data = {
'ID' : 7,
'Message': "Error while deleting friend"
}
data = pickle.dumps(data)
self.conn.send(data)
elif id == 30: ## Sending chat messages includes self uid room_id
#self.room.chat_messages.append(data)
#self.room.board_messaes.append(data)
print("The recieved mesage is {}".format(data))
room = data['RoomID']
chatroom = None
for croom in self.Rooms:
if croom['RoomID'] == room:
chatroom = croom['Room']
break
#chatroom.chat_messages.append(data)
chatroom.board_messages.append(data)
#chatroom.board_messages.append(data)
# continue
elif id == 31:
print("Board message recieved")
print(data)
room = data['RoomID']
boardroom = None
for broom in self.Rooms:
if broom['RoomID'] == room:
boardroom = broom['Room']
break
boardroom.board_messages.append(data)
elif id == 35: ## Sending spectete message includes self uid room_id
roomid = data['RoomID']
if self.room == None:
for room in self.Rooms:
if roomid == room['RoomID']:
self.room = room['Room']
break
newuser = {
'UserID': self._userid,
'conn' : self.conn,
}
self.room.spectators.append(newuser)
self.spectating = True
res = {
'ID': 35,
'Message': "You have been added to the spectators list"
}
data = pickle.dumps(res)
self.conn.send(data)
move_log = self.room.read_from_file()
res = {
'ID': 450,
'MoveLog': move_log
}
data = pickle.dumps(res)
self.conn.send(data)
else:
res = {
'ID': 7,
'Message': "Room with given ID does not exist"
}
res = pickle.dumps(res)
self.conn.send(res)
elif id == 40: ## Get user profile
profile = self.db.get_profile(self._userid)
email = self.db.get_emailid(self._userid)[0]
res = {
'ID': 40,
#'Profile': profile,
'UserID':profile[0][0],
'Matches_Played':profile[0][2],
'Matches_Won':profile[0][3],
'Matches_Lost':profile[0][2] - profile[0][3],
'Points':profile[0][4],
'Email':email,
'Message': 'User Profile'
}
res = pickle.dumps(res)
self.conn.send(res)
elif id == 41: ##Update User Profile
self.imgbuf += data['Image']
self.piece_no = data['Piece_No']
self.pieces = data['Pieces']
print("{} recieved ".format(self.piece_no))
# if self.db.update_user_profile(self._userid, data):
# data = {
# 'ID':41,
# 'Message': 'User profile updated successfully'
# }
# else:
# data = {
# 'ID': 7,
# 'Message': 'Failed to update user profile'
# }
# rev = pickle.dumps(data)
# self.conn.send(rev)
elif id == 45: ## Friend request from friend to play chess
req = {
'ID': 50,
'Sender': data['Sender'],
'Message': 'Friend request from {}'.format(data['Sender'])
}
reqdata = pickle.dumps(req)
self.conn.send(reqdata)
elif id == 55: ## Game play request accept or reject
status = data['Status']
if status == 'Accepted':
roomid = self.generate_roomid()
self.playing = True
user1 = {
'UserID': self._userid,
'Conn': self.conn
}
for client in self.Users:
if data['FriendID'] == client['UserID']:
c = client
break
clientconn = c['conn']
user2 = {
'UserID': c['UserID'],
'Conn': clientconn
}
playroom = Room(roomid, user1, user2, db = self.db, rooms=self.Rooms)
nrec = {
'ID' : 55,
'Sender' : data['FriendID'],
'Reciever': self._userid,
'Message': "Friend request accepted",
'Status': status,
'RoomID': roomid,
#'Room' : playroom
}
clientconn.send(pickle.dumps(nrec))
newroom = {
'Room': playroom,
'RoomID': roomid,
}
self.Rooms.append(newroom)
self.room = playroom
c['Client'].room = playroom
print(bool(self.room))
self.room.start()
#playroom.start()
#self.room = playroom
else :
rec = {
'ID' : 55,
'Sender' : self._userid,#data['FriendID'],
'Reciever': data['FriendID'], #self._userid,
'Message': "Friend request rejected",
'Status': status
}
srec = pickle.dumps(rec)
self.conn.send(srec)
# continue
elif id == 56: ###Quick play message
# self.quickplay.append({'UserID':self._userid, 'conn':self.conn})
# self.thread = threading.Thread(target=self.get_opponent)
# self.thread.start()
# while not self.cancel:
# if self.request:
# self.thread.join()
# break
# else:
# continue
self.message_queue.append({"UserID":self._userid, 'conn':self.conn})
self.cancel = False
self.thread = threading.Thread(target=self.get_connections)
self.thread.start()
print("Thread started for getting connections")
elif id == 58: ##Quick play room creating
uid = data['UserID']
fid = data['FriendID']
for usr in self.Users:
if usr['UserID'] == fid:
c = usr
break
c['Client'].playing = True
self.playing = True
roomid = self.generate_roomid()
user1 = {
'Conn':self.conn,
'UserID':self._userid
}
user2 = {
'Conn' : c['conn'],
'UserID' : fid,
}
playroom = Room(roomid=roomid, user1=user1, user2=user2, db = self.db, rooms=self.Rooms)
self.room = playroom
c['Client'].room = playroom
aroom = {
'Room':playroom,
'RoomID':roomid
}
self.send_busy_message()
c['Client'].send_busy_message()
self.Rooms.append(aroom)
self.room.start()
elif id == 59:
self.cancel = True
self.timeout = True
#self.quickplay.remove({'UserID':self._userid, 'conn':self.conn})
try:
self.thread.join()
except:
pass
elif id == 60: ##Board messages
self.room.board_messages.append(data)
elif id == 65: #LOGOUT
print("Recieved logout message from {}".format(self._userid))
if self.playing:
res = {
'ID': 7,
'Message': "You cannot logout while playing"
}
elif self.spectating:
newuser = {
'UserID': self._userid,
'conn' : self.conn,
}
try:
self.room.spectators.remove(newuser)
except:
print("Error while removing spectator from list")
self.get_online_friends(friends, False)
print("Thread joined and logout successful")
LOGOUT = True
sys.exit()
elif id == 70:
print("Keep Alive message From {}".format(self._userid))
else:
print("Data : {}".format(data))
continue
else:
continue
except (ConnectionResetError, KeyboardInterrupt, BrokenPipeError):
return
return
def get_online_friends(self, friends, flag): ## get the list of friends who are the friends of user and are online
data = []
for user in self.Users:
if user['UserID'] in friends:
data.append(user['UserID'])
if flag:
#conn = user['conn']
online_friend = {
'ID' : 11,
'FriendID': self._userid,
'UserID': user['UserID']
}
conn = user['conn']
conn.send(pickle.dumps(online_friend))
else:
offline_friend = {
'ID':12,
'FriendID': self._userid,
'UserID': user['UserID'],
'Message': "Friend is offline"
}
conn = user['conn']
conn.send(pickle.dumps(offline_friend))
else:
continue
return data
def get_busy_friends(self, friends): ##Get list of friends who are playing with others
data = []
for room in self.Rooms:
if room['User1'] in friends:
data.append(room['User1'])
elif room['User2'] in friends:
data.append(room['User2'])
else:
continue
return set(data)
def generate_roomid(self):
id = ['C', 'h', 'e', 's', 's', '-']
for i in range(4):
num = random.randint(0, 9)
id.append(str(num))
roomid = ''.join(id)
if self.db.existance_of_roomid(roomid):
return roomid
else:
self.generate_roomid()
def get_online_rooms(self, friends):
rooms = []
for room in self.Rooms:
playroom = room['Room']
if playroom.User1 in friends:
data = {
'FriendID':playroom.User1,
'RoomID': room['RoomID']
}
rooms.append(data)
elif playroom.User2 in friends:
data = {
'FriendID':playroom.User2,
'RoomID': room['RoomID']
}
rooms.append(data)
else:
continue
return set(rooms)
def send_busy_message(self):
for usr in self.Users:
if usr['UserID'] in self.friends:
data = {
'ID':13,
'UserID': usr['UserID'],
'FriendID':self._userid,
'Message': "Friend is busy"
}
conn = usr['conn']
rev = pickle.dumps(data)
conn.send(rev)
else:
continue
return
# def get_opponent(self):
# print("Inside get_opponent")
# print(self.lock, self._userid)
# # while self.lock:
# # if self.request:
# # return
# # else:
# # continue
# self.lock = True
# print(self.quickplay)
# self.quickplay.remove({'UserID':self._userid, 'conn': self.conn})
# self.timeout = False
# while not self.timeout:
# if len(self.quickplay) > 1:
# opponent = self.quickplay.pop()
# self.lock = False
# print(self.quickplay)
# opp_uid = opponent['UserID']
# for usr in self.Users:
# if usr['UserID'] == opp_uid:
# opp_usr = usr
# break
# if opp_usr:
# opp_client = opp_usr['Client']
# opp_client.request = True
# data = {
# 'ID':56,
# 'FriendID': opp_uid,
# 'UserID': self._userid,
# 'Message': "Quick play request matched with given friendid"
# }
# rev = pickle.dumps(data)
# self.conn.send(rev)
# opp_conn = opponent['conn']
# data = {
# 'ID':57,
# 'FriendID':self._userid,
# 'UserID':opp_uid,
# 'Message':"Quick play request matched with given FriendID wait for 2200"
# }
# rev = pickle.dumps(data)
# opp_conn.send(rev)
# else :
# continue
# # data = {
# # 'ID':400,
# # 'UserID':self._userid,
# # 'Message': 'Opponent not exist'
# # }
# #rev = pickle.dumps(data)
# #self.conn.send(rev)
# self.cancel = True
# #self.quickplay.remove({'UserID':self._userid, 'conn': self.conn})
# self.cancel = True
# return
def get_connections(self):
while not self.cancel:
if len(self.quickplay) >=2:
opponent = self.quickplay.pop()
player = self.quickplay.pop()
print("Player {} and opponent = {}".format(player, opponent))
data1 = {
'ID':56,
'UserID':self._userid,
'FriendID':opponent['UserID'],
'Message':"Quick play request matched with given friendID"
}
data2 = {
'ID':57,
'UserID':opponent['UserID'],
'FriendID':self._userid,
'Message':"Quick play request matched with given friendID wait for 2200 message"
}
rec1 = pickle.dumps(data1)
rec2 = pickle.dumps(data2)
self.conn.send(rec1)
opponent['conn'].send(rec2)
print("Opponent messages sent ")
self.cancel = False
elif len(self.message_queue):
message = self.message_queue.pop()
self.quickplay.append(message)
print("New request recieved")
return
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,751
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/testserver.py
|
import socket
import pickle
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("", 12000))
sock.listen(10)
CLOSE = False
while not CLOSE:
try:
conn, addr = sock.accept()
print("Connected to conn = {} and addr = {}".format(conn, addr))
rev = conn.recv(1024)
print("The length of data is {}".format(len(rev)))
data = pickle.loads(rev)
print(data)
print("Sent data is User = {} and Password = {}".format(data['Username'], data['Password']))
except KeyboardInterrupt:
CLOSE = True
except:
print("Erro occured")
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,752
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/NewRoom.py
|
import threading
import pickle
import random
class Room(object):
def __init__(self, roomid, user1, user2, db, rooms):
self.RoomID = roomid
self.User1 = user1['UserID']
self.User2 = user2['UserID']
self.conn1 = user1['Conn']
self.conn2 = user2['Conn']
self.db = db
self.Rooms = rooms
self.spectators = [{'UserID':self.User1, 'conn':self.conn1}, {'UserID':self.User2, 'conn': self.conn2}]
self.board_messages = []
self.win = None
self.lost = None
self.game_end = False
self.thread = threading.Thread(target=self.broadcast_messages)
with open('./Rooms/{}.csv'.format(self.RoomID), 'a') as f:
pass ##Update it
self.moveno = None
self.move = None
self.white = None
self.black = None
self.lost = None
self.win = None
def update_database(self, message):
self.move_log = b'000000'#self.read_move_log()
self.db.insert_History_details(self.RoomID, self.move_log)
self.db.update_lost_user_points(self.lost, message)
#self.db.update_lost_status(self.lost)
print("Data added to the database successfully")
return
def read_move_log(self):
with open('./Rooms/{}.csv'.format(self.RoomID), 'rb') as fdata:
rdata = fdata.read()
return rdata
def set_turns(self):
num = random.randint(1, 100)
if num%2 == 0:
data1 = {
'ID': 2200,
'Turn': 'White',
'Message': 'Start game with white pieces',
'RoomID': self.RoomID
}
self.white = [self.User1, 'White']
data2 = {
'ID': 2200,
'Turn': 'Black',
'Message': 'Start game with black pieces',
'RoomID': self.RoomID
}
self.black = [self.User2, 'Black']
else:
self.white = [self.User2, 'White']
data2 = {
'ID': 2200,
'Turn': 'White',
'Message': 'Start game with white pieces',
'RoomID': self.RoomID
}
self.black = [self.User1, 'Black']
data1 = {
'ID': 2200,
'Turn': 'Black',
'Message': 'Start game with black pieces',
'RoomID': self.RoomID
}
res1 = pickle.dumps(data1)
res2 = pickle.dumps(data2)
self.conn1.send(res1)
self.conn2.send(res2)
with open('./Rooms/{}.csv'.format(self.RoomID), 'a') as fdata:
fdata.write("UserID\tColor\n")
fdata.write("{}\t{}\n".format(self.black[0],self.black[1]))
fdata.write("{}\t{}\n".format(self.white[0],self.white[1]))
print("Turns are set")
return
def write_to_file(self, moveno, uid, start, stop):
with open('./Rooms/{}.csv'.format(self.RoomID), 'a') as fdata:
fdata.write('{}\t{}\t{}\t{}\n'.format(moveno, uid, start, stop))
return
def read_from_file(self,):
with open("./Rooms/{}.csv".format(self.RoomID), 'r') as fdata:
data = fdata.read()
return data
def broadcast_messages(self):
with open('./Rooms/{}.csv'.format(self.RoomID), 'a') as fdata:
fdata.write("Moveno\tUserID\tStart\tStop\n")
while not self.game_end:
if len(self.board_messages) > 0:
print("The messages list contain {}".format(self.board_messages))
message = self.board_messages.pop()
print(message)
uid = message['UserID']
if message['ID'] == 60:
if message['Checkmate'] or message['Stalemate'] or message['Forfeit'] or message['Left']:
self.lost = uid
if uid == self.User1:
self.win = self.User2
else:
self.win = self.User1
self.game_end = True
moveno = message['MoveNo']
start = message['Start']
stop = message['Stop']
self.write_to_file(moveno, uid, start, stop)
print("Written to file")
data = pickle.dumps(message)
for user in self.spectators:
if user['UserID'] == uid:
continue
else:
conn = user['conn']
conn.send(data)
#print("Message sent to uid {}".format(user['UserID']))
#print("Message with {} uid sent to all users".format(uid))
else:
continue
self.update_database(message)
print("All messages sent")
return
def start(self):
print("Room is started ")
print("User 1 {}".format(self.User1))
print("User 2 {}".format(self.User2))
print("conn 1 {}".format(self.conn1))
print("conn 2 {}".format(self.conn2))
self.set_turns()
self.thread.start()
print("Returning from start")
return
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,753
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/player_profile.py
|
import pygame
from pygame.locals import *
import random
import pickle
import matplotlib.pyplot as plt
import numpy as np
pygame.init()
FONT = pygame.font.SysFont('freesansbold.ttf', 40)
FONT1 = pygame.font.SysFont('calibri',25,True)
FONT2 = pygame.font.SysFont('calibri',30,True)
FONT3 = pygame.font.SysFont('calibri',20,True)
class Profile:
def __init__(self,screen,clock,client):
self.profile_picture = pygame.transform.scale(pygame.image.load('Media/prof.png'),(280,280))
self.screen = screen
self.clock = clock
self.client = client
self.data = {}
self.fields = {}
message = {'ID':40,'UserID':self.client.uID}
self.client.sock.send(pickle.dumps(message))
self.get_friends()
self.get_buttons()
self.goback = FONT.render("Go Back",True,(0,255,0))
def get_buttons(self):
self.remove_friend_buttons_pos = [166+i*50 for i in range(12)]
self.rem = FONT3.render("Remove",True,(255,0,0))
self.accept_reject_buttons_pos = [464+i*50 for i in range(6)]
self.add = FONT2.render("+",True,(0,255,0))
self.rej = FONT2.render("-",True,(255,0,0))
#print([i+25 for i in self.accept_reject_buttons_pos])
def get_friends(self):
self.Friends_list = self.client.Flist['Friends']
#print(self.Friends_list)
self.Friends_texts = [FONT1.render(i,True,(random.randrange(1,256),random.randrange(1,256),random.randrange(1,256))) for i in self.Friends_list]
#self.Friends_texts = [FONT1.render(i,True,(255,255,255)) for i in self.Friends_list]
self.Friends_texts_rects = [i.get_rect() for i in self.Friends_texts]
self.first_friend_index = 0
self.last_friend_index = len(self.Friends_list)
self.p_req_text = FONT2.render("Pending Requests",True,(0,255,0))
self.pending_requests = self.client.Flist['Friend_Requests']
self.p_reqs = [FONT1.render(i,True,(random.randrange(1,256),random.randrange(1,256),random.randrange(1,256))) for i in self.pending_requests]
self.p_reqs_rects = [i.get_rect() for i in self.p_reqs]
self.first_pending_req = 0
self.last_pending_req = len(self.pending_requests)
self.get_centers()
def get_centers(self):
x,y = 1140,180
for i in self.Friends_texts_rects[self.first_friend_index:self.last_friend_index]:
i.center = (x+i.width/2,y)
y += 50
j,k = 710,480
for i in self.p_reqs_rects[self.first_pending_req:self.last_pending_req]:
i.center = (j+i.width/2,k)
k += 50
def get_fields(self):
self.email = "Email {}".format(self.data["email"])
self.gameid = "Game ID {}".format(self.data["gameid"])
self.total_matches_played = "Matches played {}".format(self.data["total_matches_played"])
self.points = "Points {}".format(self.data["points"])
self.total_matches_won = "Total wins {}".format(self.data["Wins"])
self.friends = "Friends({})".format(len(self.Friends_list))
self.g_figure = plt.figure()
self.graph = np.array([self.data["Wins"],self.data["total_matches_played"]-self.data["Wins"]])
self.graph_labels = ["Win rate","Loss rate"]
plt.pie(self.graph,labels=self.graph_labels)
self.g_figure.savefig('./Media/stats.png')
self.email = FONT1.render(self.email,True,(255,255,255))
self.email_rect = self.email.get_rect()
self.email_rect.center = (415+(self.email_rect.width/2),(110+self.email_rect.center[1]+self.email_rect.height/2))
self.gameid = FONT1.render(self.gameid,True,(255,255,255))
self.gameid_rect = self.gameid.get_rect()
self.gameid_rect.center = (415+(self.gameid_rect.width/2),(35+self.email_rect.center[1]+self.gameid_rect.height/2))
self.total_matches_played = FONT1.render(self.total_matches_played,True,(255,255,255))
self.total_matches_played_rect = self.total_matches_played.get_rect()
self.total_matches_played_rect.center = (415+(self.total_matches_played_rect.width/2),
(35+self.gameid_rect.center[1]+self.total_matches_played_rect.height/2))
self.points = FONT1.render(self.points,True,(255,255,255))
self.points_rect = self.points.get_rect()
self.points_rect.center = (415+(self.points_rect.width/2),(35+self.total_matches_played_rect.center[1]+self.points_rect.height/2))
self.total_matches_won = FONT1.render(self.total_matches_won,True,(255,255,255))
self.total_matches_won_rect = self.total_matches_won.get_rect()
self.total_matches_won_rect.center = (415+(self.total_matches_won_rect.width/2),(35+self.points_rect.center[1]+self.total_matches_won_rect.height/2))
self.friends = FONT2.render(self.friends,True,(0,255,0))
self.friends_rect = self.friends.get_rect()
self.friends_rect.center = (1287.5,100+self.friends_rect.height)
self.fields[self.email] = self.email_rect
self.fields[self.gameid] = self.gameid_rect
self.fields[self.total_matches_played] = self.total_matches_played_rect
self.fields[self.points] = self.points_rect
self.fields[self.total_matches_won] = self.total_matches_won_rect
self.fields[self.friends] = self.friends_rect
def get_profile_section_messages(self):
try:
message = self.client.profile_section_messages.pop()
if message['ID'] == 27:
self.pending_requests.append(message['FriendID'])
p_req_text = FONT1.render(message['FriendID'],True,random.choice([(0,255,0),(0,0,255)]))
self.last_pending_req += 1
elif message['ID'] == 28:
print("Removed {} from friend list successfully ...".format(message['FriendID']))
elif message['ID'] == 40:
self.data["email"] = message['Email']
self.data["gameid"] = message['UserID']
self.data["total_matches_played"] = message['Matches_Played']
self.data["points"] = message['Points']
self.data["Wins"] = message['Matches_Won']
self.get_fields()
self.pie_chart = pygame.transform.scale(pygame.image.load('Media/stats.png'),(595,345))
except:
pass
def update(self):
while True:
self.get_profile_section_messages()
self.screen.fill("#17252A")
pos = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 4:
#print("Scroll Up")
if pos[0]<1450 and pos[0]>1125 and pos[1]<750 and pos[1] >153:
if self.first_friend_index > 0:
self.first_friend_index -= 1
self.last_friend_index -= 1
self.get_centers()
if pos[0]<=1050 and pos[0]>=700 and pos[1]<=750 and pos[1]>=400:
if self.first_pending_req > 0:
self.first_pending_req -= 1
self.last_pending_req -= 1
self.get_centers()
if event.button == 5:
#print("Scroll Down")
if pos[0]<1450 and pos[0]>1125 and pos[1]<750 and pos[1] >153:
if self.last_friend_index < len(self.Friends_list):
self.first_friend_index += 1
self.last_friend_index += 1
self.get_centers()
if pos[0]<=1050 and pos[0]>=700 and pos[1]<=750 and pos[1]>=400:
if self.last_pending_req < len(self.pending_requests):
self.first_pending_req += 1
self.last_pending_req += 1
self.get_centers()
if event.button == 1:
#print(pos)
#remove buttons
if len(self.Friends_list)>0:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=191 and pos[1]>= 166:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index]))
if len(self.Friends_list)>1:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=241 and pos[1]>= 216:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+1]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+1])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+1])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+1]))
if len(self.Friends_list)>2:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=291 and pos[1]>= 266:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+2]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+2])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+2])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+2]))
if len(self.Friends_list)>3:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=341 and pos[1]>= 316:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+3]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+3])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+3])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+3]))
if len(self.Friends_list)>4:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=391 and pos[1]>= 366:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+4]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+4])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+4])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+4]))
if len(self.Friends_list)>5:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=441 and pos[1]>= 416:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+5]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+5])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+5])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+5]))
if len(self.Friends_list)>6:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=491 and pos[1]>= 466:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+6]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+6])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+6])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+6]))
if len(self.Friends_list)>7:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=541 and pos[1]>= 516:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+7]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+7])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+7])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+7]))
if len(self.Friends_list)>8:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=591 and pos[1]>= 566:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+8]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+8])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+8])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+8]))
if len(self.Friends_list)>9:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=641 and pos[1]>= 616:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+9]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+9])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+9])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+9]))
if len(self.Friends_list)>10:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=691 and pos[1]>= 666:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+10]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+10])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+10])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+10]))
if len(self.Friends_list)>11:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=741 and pos[1]>= 716:
message = {'ID':28,'UserID':self.client.uID,'FriendID':self.Friends_list[self.first_friend_index+11]}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.remove(self.Friends_list[self.first_friend_index+11])
self.Friends_texts.remove(self.Friends_texts[self.first_friend_index+11])
self.friends = "Friends({})".format(len(self.Friends_list))
#print("Removed {}".format(self.Friends_list[self.first_friend_index+11]))
#accept buttons
if len(self.pending_requests)>0:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=489 and pos[1]>=464:
message = {'ID':26,'Status':'Accepted'}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.append(self.pending_requests[self.first_pending_req])
self.Friends_texts.append(self.pending_requests[self.first_pending_req],True,(255,255,255))
self.get_centers()
self.pending_requests.remove(self.pending_requests[self.first_pending_req])
self.p_reqs.remove(self.p_reqs[self.first_friend_index])
print("Accepted {}".format(self.pending_requests[self.first_pending_req]))
if len(self.pending_requests)>1:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=539 and pos[1]>=514:
message = {'ID':26,'Status':'Accepted'}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.append(self.pending_requests[self.first_pending_req+1])
self.Friends_texts.append(self.pending_requests[self.first_pending_req+1],True,(255,255,255))
self.get_centers()
self.pending_requests.remove(self.pending_requests[self.first_pending_req+1])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+1])
print("Accepted {}".format(self.pending_requests[self.first_pending_req+1]))
if len(self.pending_requests)>2:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=589 and pos[1]>=564:
message = {'ID':26,'Status':'Accepted'}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.append(self.pending_requests[self.first_pending_req+2])
self.Friends_texts.append(self.pending_requests[self.first_pending_req+2],True,(255,255,255))
self.get_centers()
self.pending_requests.remove(self.pending_requests[self.first_pending_req+2])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+2])
print("Accepted {}".format(self.pending_requests[self.first_pending_req+2]))
if len(self.pending_requests)>3:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=639 and pos[1]>=614:
message = {'ID':26,'Status':'Accepted'}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.append(self.pending_requests[self.first_pending_req+3])
self.Friends_texts.append(self.pending_requests[self.first_pending_req+3],True,(255,255,255))
self.get_centers()
self.pending_requests.remove(self.pending_requests[self.first_pending_req+3])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+3])
print("Accepted {}".format(self.pending_requests[self.first_pending_req+3]))
if len(self.pending_requests)>4:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=689 and pos[1]>=664:
message = {'ID':26,'Status':'Accepted'}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.append(self.pending_requests[self.first_pending_req+4])
self.Friends_texts.append(self.pending_requests[self.first_pending_req+4],True,(255,255,255))
self.get_centers()
self.pending_requests.remove(self.pending_requests[self.first_pending_req+4])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+4])
print("Accepted {}".format(self.pending_requests[self.first_pending_req+4]))
if len(self.pending_requests)>5:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=739 and pos[1]>=714:
message = {'ID':26,'Status':'Accepted'}
self.client.sock.send(pickle.dumps(message))
self.Friends_list.append(self.pending_requests[self.first_pending_req+5])
self.Friends_texts.append(self.pending_requests[self.first_pending_req+5],True,(255,255,255))
self.get_centers()
self.pending_requests.remove(self.pending_requests[self.first_pending_req+5])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+5])
print("Accepted {}".format(self.pending_requests[self.first_pending_req+5]))
if len(self.pending_requests)>0:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=489 and pos[1]>=464:
message = {'ID':26,'Status':'Rejected'}
self.client.sock.send(pickle.dumps(message))
self.pending_requests.remove(self.pending_requests[self.first_pending_req])
self.p_reqs.remove(self.p_reqs[self.first_friend_index])
print("Rejected {}".format(self.pending_requests[self.first_pending_req]))
if len(self.pending_requests)>1:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=539 and pos[1]>=514:
message = {'ID':26,'Status':'Rejected'}
self.client.sock.send(pickle.dumps(message))
self.pending_requests.remove(self.pending_requests[self.first_pending_req+1])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+1])
print("Rejected {}".format(self.pending_requests[self.first_pending_req+1]))
if len(self.pending_requests)>2:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=589 and pos[1]>=564:
message = {'ID':26,'Status':'Rejected'}
self.client.sock.send(pickle.dumps(message))
self.pending_requests.remove(self.pending_requests[self.first_pending_req+2])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+2])
print("Rejected {}".format(self.pending_requests[self.first_pending_req+2]))
if len(self.pending_requests)>3:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=639 and pos[1]>=614:
message = {'ID':26,'Status':'Rejected'}
self.client.sock.send(pickle.dumps(message))
self.pending_requests.remove(self.pending_requests[self.first_pending_req+3])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+3])
print("Rejected {}".format(self.pending_requests[self.first_pending_req+3]))
if len(self.pending_requests)>4:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=689 and pos[1]>=664:
message = {'ID':26,'Status':'Rejected'}
self.client.sock.send(pickle.dumps(message))
self.pending_requests.remove(self.pending_requests[self.first_pending_req+4])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+4])
print("Rejected {}".format(self.pending_requests[self.first_pending_req+4]))
if len(self.pending_requests)>5:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=739 and pos[1]>=714:
message = {'ID':26,'Status':'Rejected'}
self.client.sock.send(pickle.dumps(message))
self.pending_requests.remove(self.pending_requests[self.first_pending_req+5])
self.p_reqs.remove(self.p_reqs[self.first_friend_index+5])
print("Rejected {}".format(self.pending_requests[self.first_pending_req+5]))
if pos[0]<=1530 and pos[0]>=1410 and pos[1]<=56 and pos[1]>=6:
return
self.screen.blit(self.profile_picture,(55,85))
#profile picture border
pygame.draw.rect(self.screen,(0,0,0),[70,100,250,250],3)
#Info border
pygame.draw.rect(self.screen,(0,0,0),[395,100,655,250],3)
pygame.draw.rect(self.screen,(255,255,255),[1410,6,120,50],2)
if pos[0]<=1530 and pos[0]>=1410 and pos[1]<=56 and pos[1]>=6:
pygame.draw.rect(self.screen,(51, 148, 163),[1412,8,118,48])
self.screen.blit(self.goback,(1415,15))
for field in self.fields:
self.screen.blit(field,self.fields[field])
for friend in self.Friends_texts[self.first_friend_index:self.last_friend_index]:
self.screen.blit(friend,self.Friends_texts_rects[self.Friends_texts.index(friend)])
for req in self.p_reqs[self.first_pending_req:self.last_pending_req]:
self.screen.blit(req,self.p_reqs_rects[self.p_reqs.index(req)])
#graph
pygame.draw.rect(self.screen,(0,0,0),[70,400,600,350],3)
try:
self.screen.blit(self.pie_chart,(72,402))
except:
pass
#pending requests border
pygame.draw.rect(self.screen,(0,0,0),[700,400,350,350],3)
#accept buttons focus
if len(self.pending_requests)>0:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=489 and pos[1]>=464:
pygame.draw.rect(self.screen,(255,255,255),[960,464,25,25])
if len(self.pending_requests)>1:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=539 and pos[1]>=514:
pygame.draw.rect(self.screen,(255,255,255),[960,514,25,25])
if len(self.pending_requests)>2:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=589 and pos[1]>=564:
pygame.draw.rect(self.screen,(255,255,255),[960,564,25,25])
if len(self.pending_requests)>3:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=639 and pos[1]>=614:
pygame.draw.rect(self.screen,(255,255,255),[960,614,25,25])
if len(self.pending_requests)>4:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=689 and pos[1]>=664:
pygame.draw.rect(self.screen,(255,255,255),[960,664,25,25])
if len(self.pending_requests)>5:
if pos[0]<=985 and pos[0]>=960 and pos[1]<=739 and pos[1]>=714:
pygame.draw.rect(self.screen,(255,255,255),[960,714,25,25])
#reject button focus
if len(self.pending_requests)>0:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=489 and pos[1]>=464:
pygame.draw.rect(self.screen,(255,255,255),[1000,464,25,25])
if len(self.pending_requests)>1:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=539 and pos[1]>=514:
pygame.draw.rect(self.screen,(255,255,255),[1000,514,25,25])
if len(self.pending_requests)>2:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=589 and pos[1]>=564:
pygame.draw.rect(self.screen,(255,255,255),[1000,564,25,25])
if len(self.pending_requests)>3:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=639 and pos[1]>=614:
pygame.draw.rect(self.screen,(255,255,255),[1000,614,25,25])
if len(self.pending_requests)>4:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=689 and pos[1]>=664:
pygame.draw.rect(self.screen,(255,255,255),[1000,664,25,25])
if len(self.pending_requests)>5:
if pos[0]<=1025 and pos[0]>=1000 and pos[1]<=739 and pos[1]>=714:
pygame.draw.rect(self.screen,(255,255,255),[1000,714,25,25])
#accept/reject buttons
for i in self.accept_reject_buttons_pos:
if len(self.pending_requests)>self.accept_reject_buttons_pos.index(i):
pygame.draw.rect(self.screen,(255,255,255),[960,i,25,25],2)
pygame.draw.rect(self.screen,(255,255,255),[1000,i,25,25],2)
self.screen.blit(self.add,(965,i-2))
self.screen.blit(self.rej,(1009,i-1))
#friends box border
pygame.draw.rect(self.screen,(0,0,0),[1125,100,325,650],3)
#pygame.draw.rect(self.screen,(255,255,255),[1128,103,319,50])
pygame.draw.line(self.screen,(0,0,0),(1125,153),(1450,153),3)
pygame.draw.line(self.screen,(0,0,0),(700,450),(1050,450),3)
#remove buttons rects
for i in self.remove_friend_buttons_pos:
if len(self.Friends_list)>self.remove_friend_buttons_pos.index(i):
pygame.draw.rect(self.screen,(255,255,255),[1350,i,80,25],2)
self.screen.blit(self.p_req_text,(765,410))
#remove buttons focus
if len(self.Friends_list)>0:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=191 and pos[1]>= 166:
pygame.draw.rect(self.screen,(255,255,255),[1352,168,80,25])
if len(self.Friends_list)>1:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=241 and pos[1]>= 216:
pygame.draw.rect(self.screen,(255,255,255),[1352,218,80,25])
if len(self.Friends_list)>2:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=291 and pos[1]>= 266:
pygame.draw.rect(self.screen,(255,255,255),[1352,268,80,25])
if len(self.Friends_list)>3:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=341 and pos[1]>= 316:
pygame.draw.rect(self.screen,(255,255,255),[1352,318,80,25])
if len(self.Friends_list)>4:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=391 and pos[1]>= 366:
pygame.draw.rect(self.screen,(255,255,255),[1352,368,80,25])
if len(self.Friends_list)>5:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=441 and pos[1]>= 416:
pygame.draw.rect(self.screen,(255,255,255),[1352,418,80,25])
if len(self.Friends_list)>6:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=491 and pos[1]>= 466:
pygame.draw.rect(self.screen,(255,255,255),[1352,468,80,25])
if len(self.Friends_list)>7:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=541 and pos[1]>= 516:
pygame.draw.rect(self.screen,(255,255,255),[1352,518,80,25])
if len(self.Friends_list)>8:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=591 and pos[1]>= 566:
pygame.draw.rect(self.screen,(255,255,255),[1352,568,80,25])
if len(self.Friends_list)>9:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=641 and pos[1]>= 616:
pygame.draw.rect(self.screen,(255,255,255),[1352,618,80,25])
if len(self.Friends_list)>10:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=691 and pos[1]>= 666:
pygame.draw.rect(self.screen,(255,255,255),[1352,668,80,25])
if len(self.Friends_list)>11:
if pos[0]<=1430 and pos[0]>=1350 and pos[1]<=741 and pos[1]>= 716:
pygame.draw.rect(self.screen,(255,255,255),[1352,718,80,25])
for i in range(len(self.Friends_list)):
self.screen.blit(self.rem,(1357,170+i*50))
pygame.display.flip()
self.clock.tick(60)
#width,height = 1536,801
#clock = pygame.time.Clock()
#screen = pygame.display.set_mode((width,height))
#profile = Profile(screen,clock)
#profile.update()
#pygame.quit()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,754
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/configure.py
|
def read_settings():
try:
file = open("game.ini","r+")
settings = {}
for each in file:
i = each.split(":")
i = [j.strip() for j in i]
if bool(i[0]):
settings[i[0]]=i[1]
#print(settings)
file.close()
return settings
except:
print("File does not exist!")
return
def update_settings(**kwargs):
try:
file = open("game.ini","r+")
settings = {}
for each in file:
i = each.split(":")
i = [j.strip() for j in i]
if bool(i[0]):
settings[i[0]]=i[1]
if 'UserID' in kwargs and kwargs['UserID']:
settings['UserID'] = kwargs['UserID']
settings['Password'] = kwargs['Password']
settings['Remember Credentials'] = 'True'
file.seek(0)
for i in settings:
file.write("\n{}:{}".format(i,settings[i]))
file.truncate()
else:
settings['UserID'] = ''
settings['Password'] = ''
settings['Remember Credentials'] = 'False'
if 'music' in kwargs:
settings['Music'] = kwargs['music']
settings['Piece Appearance'] = kwargs['ptype']
settings['Board Theme'] = kwargs['ctype']
settings['Volume'] = kwargs['volume']
file.seek(0)
for i in settings:
file.write("\n{}:{}".format(i,settings[i]))
file.truncate()
file.close()
read_settings()
except:
print("\nConf file does not exist\nCreating game.ini...")
try:
print("game.ini created successfully!")
file = open("game.ini","w")
file.write("\nUserID:")
file.write("\nPassword:")
file.write("\nMusic:ON")
file.write("\nPiece Appearance:3")
file.write("\nBoard Theme:2")
file.write("\nVolume:50")
file.write("\nRemember Credentials:False")
file.close()
except:
print("Error in creating game.conf!")
return
return
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,755
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/testclient.py
|
import socket
import pickle
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("", 12000))
user = {
'Username': 'Akash2918',
'Password': 'Akash@123',
}
user1 = {
'Username': 'Rutvik123',
'Password': 'Rutvik@123',
}
data = pickle.dumps(user1)
print("The length of data is {}".format(len(data)))
sock.send(data)
print("Data send successfully")
sock.close()
print("Socket closed")
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,756
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/test.py
|
mes = "Hello World"
class Test():
def __init__(self):
self.message = mes
print("Hello World")
test = Test()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,757
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/Docs/network_client.py
|
from socket import *
from threading import Thread
import sys
from pygame.locals import *
import pygame
import random
pygame.init()
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (102, 204, 0)
LIGHTBLUE = (51, 153, 255)
COLOR1 = (48,128,42)
COLOR2 = (118,196,112)
LIGHTGREEN = (102,255,102)
LIGHTNAVY = (153,153,255)
RED = (255,0,0)
FONT = pygame.font.SysFont('freesansbold.ttf', 25)
class Network:
def __init__(self,server_ip,port_no):
self.server = server_ip
self.port = port_no
self.username = "Hrishi"
def connect_to_server(self):
try:
self.sock = socket(AF_INET,SOCK_STREAM)
print ("Socket successfully created")
except error as err:
print ("socket creation failed with error %s" %(err))
self.sock.connect((self.server,self.port))
self.sock.send(self.username.encode())
def get_username_and_message(self,message):
username = ""
msg = ""
for i in message:
if i != ":":
username += i
else:
break
msg = message[len(username)+1:]
return username,msg
def receive_messages(self,msg_buffer,msg_graphical_buffer,last_msg,first_msg):
while True:
try:
message = self.sock.recv(1024).decode()
username,message = self.get_username_and_message(message)
print(username,message,"message:",message)
msg_buffer.append(message)
username = FONT.render(username+":",True,random.choice([RED,GREEN,LIGHTBLUE,LIGHTNAVY]))
uname_rect = username.get_rect()
message = FONT.render(message,True,BLACK)
message_rect = message.get_rect()
msg_graphical_buffer.append(([username,uname_rect],[message,message_rect]))
last_msg += 1
if last_msg>=12:
first_msg +=1
except:
print("Error receiving!!")
self.sock.close()
break
def send_message(self,message):
try:
self.sock.send(message.encode())
except:
print("Error sending message!!")
self.sock.close()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,758
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/qplay.py
|
import pygame
import sys
from pygame.locals import *
import pickle
from threading import Timer
pygame.init()
FONT1 = pygame.font.SysFont('calibri',40,True)
class Quickplay:
def __init__(self,screen,clock,client):
self.client = client
self.screen = screen
self.clock = clock
self.profile_picture = pygame.transform.scale(pygame.image.load('Media/prof.png'),(240,240))
self.current_time = pygame.time.get_ticks()
self.count = 0
self.loading_text = FONT1.render("MATCHING",True,(255,255,255))
self.dots = [FONT1.render(".",True,(255,255,255)),FONT1.render("..",True,(255,255,255)),FONT1.render("...",True,(255,255,255))]
self.notification = None
self.opponent = None
self.myname = FONT1.render(self.client.uID,True,(255,255,255))
self.player1 = FONT1.render("Player 1",True,(255,255,255))
self.timed_out = False
def count_down(self):
message = {'ID':59,'UserID':self.client.uID}
try:
if not self.client.room_id:
self.client.sock.send(pickle.dumps(message))
except:
pass
self.timed_out = True
self.timer.join()
print("Auto matching timed out ... Looks like nobody is online ... Try again")
def loading(self):
#return pygame.time.get_ticks()-self.current_time
if pygame.time.get_ticks()-self.current_time >= 500:
self.current_time = pygame.time.get_ticks()
self.count += 1
if self.count <= 3:
return self.count
self.count = 0
return 0
return 0
def get_quickplay_section_messages(self):
if self.client.quickplay_section_messages:
self.notification = self.client.quickplay_section_messages.pop()
if self.notification['ID'] == 56:
self.opponent = self.notification['FriendID']
print("opponent found:",self.opponent)
message = {'ID':58,'UserID':self.client.uID,'FriendID':self.opponent}
self.client.sock.send(pickle.dumps(message))
print("58 message sent")
if self.notification['ID'] == 2200:
self.client.main_page_messages = []
self.client.pwf_section_messages = []
self.client.room_id = self.notification['RoomID']
self.client.color = self.notification['Turn']
def update(self):
self.timer = Timer(20.0,self.count_down)
self.timer.start()
while True:
self.get_quickplay_section_messages()
self.screen.fill((114,6,6))
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
pygame.draw.rect(self.screen,(140,44,44),[440,100,300,500],border_radius=20)
pygame.draw.rect(self.screen,(82,0,2),[460,120,260,220],border_radius=20)
pygame.draw.rect(self.screen,(140,44,44),[796,100,300,500],border_radius=20)
pygame.draw.rect(self.screen,(82,0,2),[816,120,260,220],border_radius=20)
pygame.draw.line(self.screen,(0,150,0),(768,70),(768,630),2)
self.screen.blit(self.player1,(520,360))
self.screen.blit(self.myname,(500,430))
self.screen.blit(self.profile_picture,(468,110))
self.screen.blit(self.profile_picture,(824,110))
self.screen.blit(self.loading_text,(650,680))
self.loading()
if self.count == 1:
self.screen.blit(self.dots[0],(840,680))
elif self.count == 2:
self.screen.blit(self.dots[1],(840,680))
elif self.count == 3:
self.screen.blit(self.dots[2],(840,680))
if self.client.room_id:
return
if self.timed_out:
self.timed_out = False
return
pygame.display.flip()
self.clock.tick(60)
#width,height = 1536,801
#clock = pygame.time.Clock()
#screen = pygame.display.set_mode((width,height))
#pygame.display.set_caption("Quickplay")
#quickplay = Quickplay(screen,clock)
#quickplay.update()
#pygame.quit()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,759
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/login_register.py
|
from tkinter import *
from PIL import Image,ImageTk
import sys
from socket import *
import pickle
from configure import *
import threading
password = ""
class Login_Register:
def __init__(self):
self.window = Tk()
self.window.overrideredirect(1)
self.window.geometry('350x650+500+50')
self.window.title("Login")
self.settings = read_settings()
if not self.settings:
update_settings()
self.settings = read_settings()
render = ImageTk.PhotoImage(image=Image.open('Media/cross.png').resize((20,20),Image.ANTIALIAS))
self.cross = Button(image=render,command=self.close)
self.cross.image = render
self.cross.place(x=320,y=5)
#self.window.config(bg="BLACK")
self.label1 = Label(self.window, text="Online chess game", font=("Arial Bold", 25),fg="BLACK")
self.label1.place(relx=0.07,rely=0.08)
self.load_login_widgets()
self.get_server()
#self.load_register_widgets()
self.invalid_creds = Label(self.window,text="Invalid Credentials",font=("Consolas",15),fg="RED")
self.logged_in = Label(self.window,text="Logged in successfully",font=('Consolas',15),fg="GREEN")
self.invalid_code = Label(self.window,text="Invalid code",font=('Consolas',15),fg="RED")
self.mandatory = Label(self.window,text="All fields are required !",font=('Consolas',15),fg="RED")
self.pass_mismatch = Label(self.window,text="Passwords dont match !",font=('Consolas',15),fg="RED")
self.already_in_use = Label(self.window,text="Email already in use !",font=('Consolas',15),fg="RED")
self.length_error = Label(self.window,text="Password must contain at least 5 characters",font=('Consolas',15),fg="RED")
self.nouser = Label(self.window,text="No such user exits !",font=('Consolas',15),fg="RED")
def get_server(self):
self.ip = '65.0.204.13'
self.port = 13000
def receive(self):
while True:
try:
self.data = sock.recv(4096)
except:
print("Error occured while receiving")
self.sock.close()
def load_login_widgets(self):
self.label2 = Label(self.window, text="Login", font=("Arial Bold", 20),fg="BLACK")
self.label2.place(relx=0.38,rely=0.18)
self.username = Entry(self.window,width=21,font=('Impact',15),fg="BLACK",bd=2)
self.password = Entry(self.window,width=21,font=('Impact',15),fg="BLACK",bd=2)
if self.settings['Remember Credentials']=="True":
self.username.insert(0,self.settings['UserID'])
self.password.insert(0,self.settings['Password'])
self.password.config(show = "*")
else:
self.username.insert(0,"GameID")
self.password.insert(0,"Password")
self.username.place(relx=0.15,rely=0.3)
self.username.bind("<Button-1>",self.uname_click)
self.password.place(relx=0.15,rely=0.4)
self.password.bind("<Button-1>",self.pass_click)
self.show_pass = IntVar()
self.show_pass_check = Checkbutton(text="Show Password",font=('Impact',15),variable=self.show_pass,onvalue=1,offvalue=0,command=self.login_show_pass)
self.show_pass_check.place(relx=0.15,rely=0.5)
if self.settings['Remember Credentials']=="True":
self.remem = IntVar(value=1)
else:
self.remem = IntVar(value=0)
self.remember_me = Checkbutton(text="Remember Me",font=('Impact',15),variable=self.remem,onvalue=1,offvalue=0,command=self.save_login)
self.remember_me.place(relx=0.15,rely=0.6)
self.login_button = Button(text="Sign in",padx=85,font=('Impact',15),bg="GREEN",command=self.login)
self.login_button.place(relx=0.15,rely=0.7)
self.register_button = Button(text="Register",padx=78,font=('Impact',15),bg="GREEN",command=self.forget_login_widgets)
self.register_button.place(relx=0.15,rely=0.8)
self.forgot_pass = Button(text="Forgot Password",padx=45,font=('Impact',15),bg="GREEN",command=self.load_forgotpass_widgets)
self.forgot_pass.place(relx=0.15,rely=0.9)
def load_register_widgets(self):
self.label3 = Label(self.window, text="Register", font=("Arial Bold", 20),fg="BLACK")
self.label3.place(relx=0.33,rely=0.18)
self.Email = Entry(self.window,width=21,font=('Impact',15),fg="BLACK",bd=2)
self.Email.insert(0,"Email")
self.Email.place(relx=0.15,rely=0.3)
self.Email.bind("<Button-1>",self.email_click)
self.reg_username = Entry(self.window,width=21,font=('Impact',15),fg="BLACK",bd=2)
self.reg_username.insert(0,"Username")
self.reg_username.place(relx=0.15,rely=0.4)
self.reg_username.bind("<Button-1>",self.reg_uname_click)
self.reg_password = Entry(self.window,width=21,font=('Impact',15),fg="BLACK",bd=2)
self.reg_password.insert(0,"Password")
self.reg_password.place(relx=0.15,rely=0.5)
self.reg_password.bind("<Button-1>",self.reg_pass_click)
self.confirm_reg_password = Entry(self.window,width=21,font=('Impact',15),fg="BLACK",bd=2)
self.confirm_reg_password.insert(0,"Confirm password")
self.confirm_reg_password.place(relx=0.15,rely=0.6)
self.confirm_reg_password.bind("<Button-1>",self.confirm_reg_pass_click)
self.reg_button = Button(text="Register",padx=78,font=('Impact',15),bg="GREEN",command=self.reg)
self.reg_button.place(relx=0.15,rely=0.7)
self.go_back_button = Button(text="Go Back",padx=78,font=('Impact',15),bg="GREEN",command=self.forget_register_widgets)
self.go_back_button.place(relx=0.15,rely=0.8)
def load_otp_widgets(self):
self.label3.place_forget()
self.Email.place_forget()
self.reg_username.place_forget()
self.reg_password.place_forget()
self.confirm_reg_password.place_forget()
self.reg_button.place_forget()
self.go_back_button.place_forget()
try:
self.mandatory.place_forget()
except:
pass
self.label4 = Label(self.window,text="Enter OTP sent on your email",font=("Arial Bold", 15),fg="BLACK")
self.otp = Entry(self.window,width=20,font=('Impact',15),fg="BLACK",bd=2)
self.label4.place(relx=0.1,rely=0.2)
self.otp.place(relx=0.15,rely=0.3)
self.submit_button = Button(text="Submit",padx=78,font=('Impact',15),bg="GREEN",command=self.validate_otp_code)
self.submit_button.place(relx=0.15,rely=0.4)
def load_forgotpass_widgets(self):
self.label2.place_forget()
self.username.place_forget()
self.password.place_forget()
self.login_button.place_forget()
self.register_button.place_forget()
self.show_pass_check.place_forget()
self.remember_me.place_forget()
self.forgot_pass.place_forget()
self.username.place(relx=0.15,rely=0.4)
if not self.username.get():
self.username.insert(0,'GameID')
self.Reset_pass_text = Label(self.window,text="Reset Password",font=('Arial Bold',20),fg="GREEN")
self.Reset_pass_text.place(relx=0.2,rely=0.25)
self.forgot_password = Entry(self.window,width=21,font=('Impact',15),fg="BLACK",bd=2)
self.forgot_password.insert(0,"Password")
self.forgot_password.place(relx=0.15,rely=0.5)
self.forgot_password.bind("<Button-1>",self.forgot_pass_click)
self.confirm_forgot_password = Entry(self.window,width=21,font=('Impact',15),fg="BLACK",bd=2)
self.confirm_forgot_password.insert(0,"Confirm password")
self.confirm_forgot_password.place(relx=0.15,rely=0.6)
self.confirm_forgot_password.bind("<Button-1>",self.confirm_forgot_pass_click)
self.reset_pass_button = Button(text="Reset",padx=90,font=('Impact',15),bg="GREEN",command=self.reset_password)
self.reset_pass_button.place(relx=0.15,rely=0.7)
self.goback_from_reset = Button(text="Go Back",padx=80,font=('Impact',15),bg="GREEN",command=self.go_to_login)
self.goback_from_reset.place(relx=0.15,rely=0.8)
def forget_login_widgets(self):
self.label2.place_forget()
self.username.place_forget()
self.password.place_forget()
self.login_button.place_forget()
self.register_button.place_forget()
self.show_pass_check.place_forget()
self.remember_me.place_forget()
self.forgot_pass.place_forget()
try:
self.mandatory.place_forget()
except:
pass
try:
self.invalid_creds.place_forget()
except:
pass
self.load_register_widgets()
def forget_register_widgets(self):
self.label3.place_forget()
self.Email.place_forget()
self.reg_username.place_forget()
self.reg_password.place_forget()
self.confirm_reg_password.place_forget()
self.reg_button.place_forget()
self.go_back_button.place_forget()
try:
self.mandatory.place_forget()
except:
pass
self.load_login_widgets()
def forget_otp_widgets(self):
self.label4.place_forget()
self.otp.place_forget()
self.submit_button.place_forget()
self.load_login_widgets()
def go_to_login(self):
self.forgot_password.place_forget()
self.confirm_forgot_password.place_forget()
self.reset_pass_button.place_forget()
self.goback_from_reset.place_forget()
self.Reset_pass_text.place_forget()
self.load_login_widgets()
def validate_otp_code(self):
otp_msg = {'ID':2,'Code':self.otp.get()}
#self.sock = socket(AF_INET, SOCK_STREAM)
#self.sock.connect((self.ip, self.port))
self.sock2.send(pickle.dumps(otp_msg))
data = self.sock2.recv(1024)
data = pickle.loads(data)
#print(data)
if data['ID']==2:
try:
self.mandatory.place_forget()
except:
pass
try:
self.invalid_code.place_forget()
except:
pass
self.forget_otp_widgets()
self.load_login_widgets()
else:
self.invalid_code.place(relx=0.2,rely=0.5)
print(data)
def reset_password(self):
print(bool(self.username.get()))
if self.username.get() == "GameID" or not bool(self.username.get()):
try:
self.pass_mismatch.place_forget()
except:
pass
try:
self.length_error.place_forget()
except:
pass
try:
self.nouser.place_forget()
except:
pass
self.mandatory.place(relx=0.15,rely=0.3)
if self.forgot_password.get() == self.confirm_forgot_password.get() and self.username.get() != "GameID" and bool(self.username.get()):
if len(self.forgot_password.get()) >= 5:
message = {'ID':6,'UserID':self.username.get()}
reply = self.sock3.recv(1024)
reply = pickle.loads(reply)
if reply['ID'] == 6 and bool(reply['Status']):
self.sock3 = socket((AF_INET,SOCK_STREAM))
self.sock3.connect((self.ip,self.port))
self.sock3.send(pickle.dumps(message))
message = {'ID':2,'Password':self.forgot_password.get()}
self.sock3.send(pickle.dumps(message))
reply = self.sock3.recv(1024)
reply = pickle.loads(reply)
if reply['ID']==8:
print("Password reset successfully!")
try:
self.mandatory.place_forget()
except:
pass
try:
self.pass_mismatch.place_forget()
except:
pass
try:
self.length_error.place_forget()
except:
pass
try:
self.nouser.place_forget()
except:
pass
self.username.place_forget()
self.forgot_password.place_forget()
self.confirm_forgot_password.place_forget()
self.reset_pass_button.place_forget()
self.load_login_widgets()
else:
self.invalid_code.place(relx=0.15,rely=0.3)
else:
try:
self.mandatory.place_forget()
except:
pass
try:
self.pass_mismatch.place_forget()
except:
pass
try:
self.length_error.place_forget()
except:
pass
self.nouser.place(relx=0.15,rely=0.3)
else:
try:
self.mandatory.place_forget()
except:
pass
try:
self.pass_mismatch.place_forget()
except:
pass
try:
self.nouser.place_forget()
except:
pass
self.length_error.place(relx=0.15,rely=0.3)
else:
try:
self.mandatory.place_forget()
except:
pass
try:
self.length_error.place_forget()
except:
pass
try:
self.nouser.place_forget()
except:
pass
self.pass_mismatch.place(relx=0.15,rely=0.3)
def uname_click(self,*args):
self.username.delete(0,'end')
def email_click(self,*args):
self.Email.delete(0,'end')
def reg_uname_click(self,*args):
self.reg_username.delete(0,'end')
def pass_click(self,*args):
if self.password.get() == "Password":
self.password.delete(0,'end')
if self.show_pass.get() == 0:
self.password.config(show = "*")
def reg_pass_click(self,*args):
self.reg_password.delete(0,'end')
def confirm_reg_pass_click(self,*args):
self.confirm_reg_password.delete(0,'end')
def forgot_pass_click(self,*args):
if self.forgot_password.get() == "Password":
self.forgot_password.delete(0,'end')
def confirm_forgot_pass_click(self,*args):
if self.confirm_forgot_password.get() == "Confirm password":
self.confirm_forgot_password.delete(0,'end')
def login(self,*args):
print(self.username.get())
print(self.password.get())
if not bool(self.username.get()) or not bool(self.password.get()) or self.username.get()=="GameID" or self.password.get()=="Password":
self.mandatory.place(relx=0.1,rely=0.24)
else:
#self.update_configurations()
message = {'ID':5,'UserID':self.username.get(),'Password':self.password.get(),'Loggedin':0}
self.sock1 = socket(AF_INET, SOCK_STREAM)
self.sock1.connect((self.ip, self.port))
self.sock1.send(pickle.dumps(message))
reply = self.sock1.recv(1024)
print(pickle.loads(reply))
reply = pickle.loads(reply)
if reply['ID']==501:
try:
self.mandatory.place_forget()
except:
pass
try:
self.invalid_creds.place(relx=0.2,rely=0.24)
except:
pass
self.sock1.close()
else:
try:
self.invalid_creds.place_forget()
except:
pass
try:
self.mandatory.place_forget()
except:
pass
self.logged_in.place(relx=0.1,rely=0.24)
#timer = threading.Timer(3.0, self.close())
#timer.start()
temp = open("Temp","w")
temp.write(self.password.get())
temp.close()
self.update_configurations()
self.window.destroy()
def register(self,*args):
print("Registeration")
def reg(self,*args):
print("Registeration online")
if not bool(self.Email.get()) or not bool(self.reg_username.get()) or not bool(self.reg_password.get()) or not bool(self.confirm_reg_password.get()) or self.Email.get()=="Email" or self.reg_username.get()=="Username" or self.reg_password.get()=="Password" or self.confirm_reg_password.get() == "Confirm password":
self.mandatory.place(relx=0.1,rely=0.24)
else:
self.sock2 = socket(AF_INET, SOCK_STREAM)
self.sock2.connect((self.ip, self.port))
email = self.Email.get()
uname = self.reg_username.get()
password = self.reg_password.get()
reconfirm_pass = self.confirm_reg_password.get()
message = {'ID':700}
self.sock2.send(pickle.dumps(message))
if password == reconfirm_pass:
message = {'ID':1,'UserID':uname,'Email':email,'Password':password}
self.sock2.send(pickle.dumps(message))
reply = self.sock2.recv(1024)
print(pickle.loads(reply))
try:
self.pass_mismatch.place_forget()
except:
pass
try:
self.mandatory.place_forget()
except:
pass
#add already existing email condition
self.load_otp_widgets()
else:
try:
self.mandatory.place_forget()
except:
pass
self.pass_mismatch.place(relx=0.1,rely=0.24)
def save_login(self,*args):
print(self.remem.get())
def login_show_pass(self,*args):
if self.show_pass.get() == 1:
if self.password.get() == "Password":
self.password.delete(0,'end')
self.password.config(show="")
else:
self.password.config(show="*")
def close(self):
# ID = 600 --> logging out from login page
#message = {'ID':600}
try:
self.sock1.send(pickle.dumps(message))
self.sock1.close()
except:
pass
try:
self.sock2.send(pickle.dumps(message))
#self.sock2.close()
except:
pass
self.window.destroy()
def update_configurations(self):
if self.remem.get():
update_settings(UserID=self.username.get(),Password=self.password.get())
else:
update_settings()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,760
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/database.py
|
import mysql.connector
from mysql.connector import errorcode
try:
mydb = mysql.connector.connect(
host = "localhost",
user = "superuser",
password = "Akash@2918",
database = 'chessdb',
)
except mysql.connector.Error as err:
if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
print("Something is wrong with username or password")
elif err.errno == errorcode.ER_BAD_DB_ERROR:
print("Database does not exist")
else:
print(err)
cursor = mydb.cursor()
class Database(object):
def __init__(self):
self.cursor = cursor
self._username = None
self._password = None
self._email = None
self._uname = None
self._uid = None
####### Database Queries
self._validate_user_query = ("select * from Clients where UserID = %s and PASSWD = %s")
self._add_new_user_query = ("insert into Clients (UserID, Email, PASSWD, STATUS) values (%s, %s, %s, %s)")
self._verify_user_query = ("update Clients set STATUS = %s where UserID = %s")
self._unique_email_query = ("select * from Clients where Email = %s")
self._get_friends_list_query = ("select FriendID from Friends where UserID = %s and STATUS = 'Accepted'")
self._get_friends_list2_query = ("select UserID from Friends where FriendID = %s and STATUS = 'Accepted'")
self._add_new_friend_request_query = ("insert into Friends (UserID, FriendID, STATUS) values (%s, %s, %s)")
self._get_user_profile_query = ("select * from Profile where UserID = %s")
self._get_friends_rejected_list_query = ("select FriendID from Friends where UserID = %s and STATUS = 'Rejected'")
self._get_friends_request_list_query = ("select UserID from Friends where FriendID = %s and STATUS = 'Pending'")
self._update_profile_query = ("update Profile set Profile_Image = %s where UserID = %s")
self._update_password_query = ("update Clients set PASSWD = %s where UserID = %s")
self._existance_email_query = ("select * from Clients where Email = %s")
self._existance_roomid_query = ("select RoomID from Games where RoomID = %s")
self._insert_roomid_todb_query = ("insert into Games (RoomID, Player1, Player2) values (%s, %s, %s)")
self._insert_to_history_query = ("insert into History (RoomID, currentDate, Move_Logs) values (%s, NOW(), %s)")
self._update_win_status_query = ("update Profile set Matches_Played = Matches_Played + 1, Matches_Won = Matches_Won + 1, Points = Points + 100 where UserID = %s")
self._update_lost_status_query = ("update Profile set Matches_Played = Matches_Played + 1, Points = Points - 20, where UserID = %s")
self._update_friends_accept_query = ("update Friends set STATUS = %s where UserID = %s and FriendID = %s")
self._existance_friend_query = ("select UserID from Clients where UserID = %s")
self._existance_of_friend_query = ("select * from Friends where UserID = %s and FriendID = %s")
self._delete_friend_query = ("delete from Friends where UserID = %s and FriendID = %s")
self._get_email_of_client = ("select Email from Clients where UserID = %s")
self._create_user_profile_query = ("insert into Profile (UserID, Matches_Played, Matches_Won, Points) values (%s, 0, 0, 0)")
self._insert_into_games_query = ("insert into Games (RoomID, Player1, Player2) values (%s, %s, %s)")
self._update_left_user_query = ("update Profile set Matches_Played = Matches_Played + 1, Points = Points - 50 where UserID = %s")
self._update_forfeit_user_query = ("update Profile set Matches_Played = Matches_Played + 1, Points = Points - 30 where UserID = %s")
self._update_lost_user_query = ("update Profile set Matches_Played = Matches_Played + 1, Points = %s where UserID = %s")
self._get_points_query = ("select Points from Profile where UserID = %s")
def update_user_profile(self, uid, data):
try:
self.cursor.execute(self._update_profile_query, (data['Image'], uid, ))
mydb.commit()
return True
except:
return False
def get_emailid(self, uid):
try:
self.cursor.execute(self._get_email_of_client, (uid, ))
data = []
for d in self.cursor:
data.append(d[0])
return data
except:
return []
def insert_new_game_info(self, roomid, user1, user2):
try:
self.cursor.execute(self._insert_into_games_query, (roomid, user1, user2, ))
mydb.commit()
print("Game updated")
return True
except:
return False
def remove_friend_from_friendlist(self, uid, fid):
data = []
self.cursor.execute(self._existance_of_friend_query, (uid, fid, ))
for row in self.cursor:
data.append(row)
if data :
self.cursor.execute(self._delete_friend_query, (uid, fid, ))
mydb.commit()
else:
self.cursor.execute(self._existance_of_friend_query, (fid, uid,))
for row in self.cursor:
data.append(row)
if data:
self.cursor.execute(self._delete_friend_query, (fid, uid, ))
print("friend with id = {} deleted".format(fid))
mydb.commit()
return True
return True
def update_win_status(self, uid):
try:
self.cursor.execute(self._update_win_status_query, (uid, ))
mydb.commit()
print("Database updated")
return True
except:
print("Error while updating win status")
return False
def update_lost_user_points(self, uid, message):
self.cursor.execute(self._get_points_query, (uid, ))
points = []
for p in self.cursor:
points.append(p)
points = points[0][0]
if message['Checkmate']:
points = points - 20
elif message['Stalemate']:
points = points - 40
elif message['Left']:
points = points - 50
elif message['Forfeit']:
points = points - 30
if points < 0:
points = 0
self.cursor.execute(self._update_lost_user_query, (points, uid, ))
mydb.commit()
#print(points)
def add_friends_request_status(self, data):
uid = data['UserID']
fid = data['FriendID']
status = data['Status']
try:
self.cursor.execute(self._update_friends_accept_query, (status, fid, uid))
mydb.commit()
return True
except:
return False
def update_lost_status(self, uid):
try:
self.cursor.execute(self._update_lost_status_query, (uid, ))
mydb.commit()
return True
except:
print("Error while updating lost status")
return False
def verify_user(self, uid):
try:
self.cursor.execute(self._verify_user_query, ("Verified", uid, ))
mydb.commit()
return True
except:
print("Error while varifing user")
return False
def update_user_password(self, uid, password):
try:
self.cursor.execute(self._update_password_query, (password, uid, ))
mydb.commit()
return True
except:
return False
def existance_of_user(self, uid, email):
try:
self.cursor.execute(self._existance_email_query, (email, ))
data = []
for d in self.cursor:
data.append(d)
print(data)
qemail = data[0][1]
if qemail == email:
return True
else:
return False
except:
print("Error while processing email query")
return False
def existance_of_roomid(self, roomid):
self.cursor.execute(self._existance_roomid_query, (roomid, ))
data = []
for room in self.cursor:
data.append(room)
return True if len(data) == 0 else False
def insert_game_details(self, roomid, player1, player2):
try:
self.cursor.execute(self._insert_roomid_todb_query, (roomid, player1, player2, ))
mydb.commit()
return True
except:
return False
def insert_History_details(self, roomid, move_log):
try:
self.cursor.execute(self._insert_to_history_query, (roomid, move_log, ))
mydb.commit()
return True
except:
print("Error while inserting molog to database")
return False
def validate_user(self, userid, password):
self._uid, self._password = userid, password
self.cursor.execute(self._validate_user_query, (self._uid, self._password,))
users = []
for data in self.cursor:
#print(data)
users.append(data)
return True if len(users) == 1 else False
def Add_new_User(self, UserID, Email, Password):
#self._uid, self._email, self._password = UserID, Email, Password
self.cursor.execute(self._unique_email_query, (Email, ))
data = []
for email in self.cursor:
data.append(email)
if len(data) == 0:
self.cursor.execute(self._add_new_user_query, (UserID, Email, Password, "NOT Verified", ))
self.cursor.execute(self._create_user_profile_query, (UserID, ))
mydb.commit()
return True
else:
return False
def get_friends_list(self, uid):
self._uid = uid
self.cursor.execute(self._get_friends_list_query, (self._uid, ))
data = []
for friend in self.cursor:
data.append(friend[0])
self.cursor.execute(self._get_friends_list2_query, (self._uid, ))
for friend in self.cursor:
data.append(friend[0])
return data
def get_friends_request_list(self, uid):
#try:
self.cursor.execute(self._get_friends_request_list_query, (uid, ))
friends = []
for friend in self.cursor:
friends.append(friend[0])
return friends
# except:
# print("Error occured while processing friend request query")
# return []
def get_profile(self, uid):
profile = []
self.cursor.execute(self._get_user_profile_query, (uid, ))
for p in self.cursor:
profile.append(p)
print("Profile of {} user is {}".format(uid, profile))
return profile
def get_friends_rejected_list(self, uid):
self.cursor.execute(self._get_friends_rejected_list_query, (uid, ))
friends = []
for friend in self.cursor:
friends.append(friend[0])
# print("The friends list is {}".format(friends))
return friends
def add_new_friend_request(self, userid, friendid):
try:
self.cursor.execute(self._add_new_friend_request_query, (userid, friendid, 'Pending'))
mydb.commit()
return True
except:
print("Error while inserting data into database")
return False
def check_existance_of_user(self, fid):
self.cursor.execute(self._existance_friend_query, (fid, ))
data = []
for fid in self.cursor:
data.append(fid)
udata = []
if data:
for u in data[0]:
udata.append(u)
return udata
else:
return data
# query = ("select * from Clients")
# custquery = ("CREATE TABLE customers (name VARCHAR(255), address(255))")
# print(mydb)
# cursor.execute(query)
# print("The type of cursor is {}".format(type(cursor)))
# for data in cursor:
# print(data)
# # print("Creating new table")
# cursor.close()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,761
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/settings.py
|
import pygame
from pygame.locals import *
from pygame import mixer
from configure import *
pygame.init()
mixer.init()
FONT1 = pygame.font.SysFont('calibri',40,True)
FONT2 = pygame.font.SysFont('calibri',20,True)
FONT3 = pygame.font.SysFont('calibri',30,True)
class Settings:
def __init__(self,screen,clock):
self.screen = screen
self.clock = clock
self.get_typechoice_images()
self.get_texts()
self.checkbox_positions = {'ptype':[(690,150),(690,321),(690,492)],'ctype':[(955,265),(1300,265),(955,530),(1300,530)]}
self.goback = FONT1.render("Go Back",True,(0,255,0))
self.settings = read_settings()
if not self.settings:
update_settings()
self.settings = read_settings()
self.ptype = int(self.settings['Piece Appearance'])
self.ctype = int(self.settings['Board Theme'])
self.music = 1 if self.settings['Music'] == "ON" else 0
self.volume_value = int(self.settings['Volume'])
if self.music:
self.play_music()
def get_typechoice_images(self):
self.piece_type1 = pygame.transform.scale(pygame.image.load('Media/setting_ptype_1.png'),(600,151))
self.piece_type2 = pygame.transform.scale(pygame.image.load('Media/setting_ptype_2.png'),(600,151))
self.piece_type3 = pygame.transform.scale(pygame.image.load('Media/setting_ptype_3.png'),(600,151))
self.color_type1 = pygame.transform.scale(pygame.image.load('Media/setting_ctype_1.png'),(310,151))
self.color_type2 = pygame.transform.scale(pygame.image.load('Media/setting_ctype_2.png'),(310,151))
self.color_type3 = pygame.transform.scale(pygame.image.load('Media/setting_ctype_3.png'),(310,151))
self.color_type4 = pygame.transform.scale(pygame.image.load('Media/setting_ctype_4.png'),(310,151))
self.select = pygame.image.load('Media/select.png')
def get_texts(self):
self.pappearance = FONT1.render("Pieces Appearance",True,(255,255,255))
self.pappearance_rect = self.pappearance.get_rect()
self.pappearance_rect.center = (400,70)
self.boardtheme = FONT1.render("Board Theme",True,(255,255,255))
self.boardtheme_rect = self.boardtheme.get_rect()
self.boardtheme_rect.center = (1150,70)
self.on = FONT2.render("ON",True,(0,0,0))
self.on_rect = self.on.get_rect()
self.on_rect.center = (378,717)
self.off = FONT2.render("OFF",True,(0,0,0))
self.off_rect = self.off.get_rect()
self.off_rect.center = (322,717)
self.m = FONT3.render("Music",True,(255,255,255))
self.m_rect = self.m.get_rect()
self.m_rect.center = (230,717)
self.v = FONT3.render("Volume",True,(255,255,255))
self.v_rect = self.v.get_rect()
self.v_rect.center = (700,717)
self.increase = FONT3.render("+",True,(0,255,0))
self.increase_rect = self.increase.get_rect()
self.increase_rect.center = (1264,715)
self.decrease = FONT3.render("-",True,(255,0,0))
self.decrease_rect = self.decrease.get_rect()
self.decrease_rect.center = (1314,715)
def stop_music(self):
mixer.music.stop()
def play_music(self):
mixer.music.load("Media/music1.mp3")
mixer.music.set_volume(self.volume_value/100)
mixer.music.play(loops=-1)
def update(self):
while True:
self.screen.fill("#17252A")
#self.screen.fill((0,0,0))
pos = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.music = "ON" if self.music == 1 else "OFF"
update_settings(music=self.music,ptype=self.ptype,ctype=self.ctype,volume=self.volume_value)
print(read_settings())
return
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
#music turn on or off
if pos[0]<=400 and pos[0]>=300 and pos[1]<=730 and pos[1]>=700:
self.music = not self.music
if not self.music:
self.stop_music()
else:
self.play_music()
#volume change
elif pos[0]<=1280 and pos[0]>=1250 and pos[1]<=730 and pos[1]>=700:
if self.volume_value < 100:
self.volume_value += 10
#print(self.volume_value)
if self.music:
mixer.music.set_volume(self.volume_value/100)
elif pos[0]<=1330 and pos[0]>=1300 and pos[1]<=730 and pos[1]>=700:
if self.volume_value > 0:
self.volume_value -= 10
#print(self.volume_value)
if self.music:
mixer.music.set_volume(self.volume_value/100)
#piece appearance
elif pos[0]<=725 and pos[0]>=695 and pos[1]<=195 and pos[1]>=165:
self.ptype = 1
elif pos[0]<=725 and pos[0]>=695 and pos[1]<=366 and pos[1]>=336:
self.ptype = 2
elif pos[0]<=725 and pos[0]>=695 and pos[1]<=537 and pos[1]>=507:
self.ptype = 3
#color theme
elif pos[0]<=990 and pos[0]>=960 and pos[1]<=310 and pos[1]>=280:
self.ctype = 1
elif pos[0]<=1335 and pos[0]>=1305 and pos[1]<=310 and pos[1]>=280:
self.ctype = 2
elif pos[0]<=990 and pos[0]>=960 and pos[1]<=575 and pos[1]>=545:
self.ctype = 3
elif pos[0]<=1335 and pos[0]>=1305 and pos[1]<=575 and pos[1]>=545:
self.ctype = 4
elif pos[0]<=1530 and pos[0]>=1410 and pos[1]<=56 and pos[1]>=6:
self.music = "ON" if self.music == 1 else "OFF"
update_settings(music=self.music,ptype=self.ptype,ctype=self.ctype,volume=self.volume_value)
return
#piece appearnce border
pygame.draw.rect(self.screen,(255,255,255),[25,37.5,750,583],2)
#board theme border
pygame.draw.rect(self.screen,(255,255,255),[800,37.5,700,583],2)
#go back button
pygame.draw.rect(self.screen,(255,255,255),[1410,6,120,50],2)
if pos[0]<=1530 and pos[0]>=1410 and pos[1]<=56 and pos[1]>=6:
pygame.draw.rect(self.screen,(51, 148, 163),[1412,8,118,48])
self.screen.blit(self.goback,(1415,15))
#options
self.screen.blit(self.piece_type1,(45,107.5))
self.screen.blit(self.piece_type2,(45,278.5))
self.screen.blit(self.piece_type3,(45,449.5))
self.screen.blit(self.color_type1,(820,107.5))
self.screen.blit(self.color_type2,(820,370.5))
self.screen.blit(self.color_type3,(1165,107.5))
self.screen.blit(self.color_type4,(1165,370.5))
self.screen.blit(self.pappearance,self.pappearance_rect)
self.screen.blit(self.boardtheme,self.boardtheme_rect)
#checkboxes
pygame.draw.rect(self.screen,(255,255,255),[695,165,30,30],3)
pygame.draw.rect(self.screen,(255,255,255),[695,336,30,30],3)
pygame.draw.rect(self.screen,(255,255,255),[695,507,30,30],3)
pygame.draw.rect(self.screen,(255,255,255),[960,280,30,30],3)
pygame.draw.rect(self.screen,(255,255,255),[1305,280,30,30],3)
pygame.draw.rect(self.screen,(255,255,255),[960,545,30,30],3)
pygame.draw.rect(self.screen,(255,255,255),[1305,545,30,30],3)
self.screen.blit(self.select,self.checkbox_positions['ptype'][self.ptype-1])
self.screen.blit(self.select,self.checkbox_positions['ctype'][self.ctype-1])
pygame.draw.rect(self.screen,(255,255,255),[300,700,100,30],2)
if self.music:
pygame.draw.rect(self.screen,(54,179,87),[302,702,57,27])
pygame.draw.rect(self.screen,("#9147ff"),[359,702,40,27])
self.screen.blit(self.on,self.on_rect)
else:
pygame.draw.rect(self.screen,(54,179,87),[302,702,40,27])
pygame.draw.rect(self.screen,("#464649"),[342,702,57,27])
self.screen.blit(self.off,self.off_rect)
self.screen.blit(self.m,self.m_rect)
self.screen.blit(self.v,self.v_rect)
if pos[0]<=1280 and pos[0]>=1250 and pos[1]<=730 and pos[1]>=700:
pygame.draw.rect(self.screen,(186,103,35),[1250,700,30,30])
if pos[0]<=1330 and pos[0]>=1300 and pos[1]<=730 and pos[1]>=700:
pygame.draw.rect(self.screen,(186,103,35),[1300,700,30,30])
pygame.draw.line(self.screen,(255,255,255),(800,715),(1200,715),3)
# 985 ~ 1000 --> scale position of pointer to 0-400 from 0-100
pygame.draw.rect(self.screen,(54,179,87),[785+(4*self.volume_value),700,30,30])
#increase volume
pygame.draw.rect(self.screen,(255,255,255),[1250,700,30,30],3)
self.screen.blit(self.increase,self.increase_rect)
#decrease volume
pygame.draw.rect(self.screen,(255,255,255),[1300,700,30,30],3)
self.screen.blit(self.decrease,self.decrease_rect)
pygame.display.flip()
self.clock.tick(60)
#width,height = 1536,801
#clock = pygame.time.Clock()
#screen = pygame.display.set_mode((width,height))
#pygame.display.set_caption("Settings")
#settings = Settings(screen,clock)
#settings.update()
#pygame.quit()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,762
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/server code/server.py
|
import socket
import threading
from database import Database
import pickle
from User import Client
import sys
import random
import smtplib
from email.message import EmailMessage
THREADS = []
CLOSE = False
PORT = 12000
IP = ''
DB = Database()
Users = []
Rooms = []
QUICK_PLAY = []
Message_Queue = []
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((IP, PORT))
sock.listen(20)
def random_number():
num = random.randint(100000, 999999)
return str(num)
def Send_VerificationCode(to, uid, code):
msg = EmailMessage()
msg['Subject'] = 'Verification Code From Chess Project'
msg['From'] = 'Chess Project SE 2021'
msg['To'] = to
msg.set_content('Hello {},\n\n \t Your verification code is {}'.format(uid, code))
try:
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login('chessprojectse2021@gmail.com', '')
server.send_message(msg)
print("Mail sent1")
return True
except:
return False
def Send_Welcome_Email(to, uid):
msg = EmailMessage()
msg['Subject'] = 'Welcome To Chess Project'
msg['From'] = 'Chess Project SE 2021'
msg['To'] = to
msg.set_content('Hello {},\n \t Your account has successfully activated. Lets start the game'.format(uid))
try:
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login('chessprojectse2021@gmail.com', '')
server.send_message(msg)
print("Mail sent2")
return True
except:
return False
def handle_client(conn, data):
Exit = False
print(data)
while not Exit:
#rec = conn.recv(1024)
#data = pickle.loads(rec)
id = data['ID']
userid, password = data['UserID'], data['Password']
if id == 5:
if DB.validate_user(userid, password):
rdata = {
'ID': 500,
'Message' : 'Login successfull'
}
rdata = pickle.dumps(rdata)
conn.send(rdata)
#Starting client
#print("1: {}".format(len(Users)))
loggedin = data['Loggedin']
if loggedin:
c = Client(UserID=userid, conn=conn, database=DB, users=Users, rooms=Rooms, quickplay = QUICK_PLAY, message_queue=Message_Queue)
for usr in Users:
if usr['UserID'] == userid:
Users.remove(usr)
print("User removed from the existing list")
break
Users.append({'UserID':userid, 'conn': conn, 'Client': c})
#print("2: {}".format(len(Users)))
c.start()
print("{} User logout".format(userid))
else:
Exit = True
Exit = True
else:
data = {
'ID' : 501,
'Message' : 'Invalid credentials'
}
data = pickle.dumps(data)
conn.send(data)
Exit = True
sys.exit()
return
elif id == 6: ##Forgot password
#email = data['Email']
uid = data['UserID']
email = DB.get_emailid(uid=uid)
if email:
print(email)
ncode = random_number()
Send_VerificationCode(to=email, uid=uid, code=ncode)
data = {
'ID':6,
'Message':"User Exist",
'Status':True
}
else:
data = {
'ID':6,
'Status':False,
'Message':"User does not exist"
}
conn.send(pickle.dumps(data))
elif id == 2:
revcode = data['Code']
if revcode == code:
newpass = data['Password']
if DB.update_user_password(uid, newpass) :
data = {
'ID' : 8,
'Message': "Password update successful"
}
else:
data = {
'ID' : 7,
'Message' : 'Password update unsuccessful'
}
Exit = True
else:
#ncode = random_number()
#Send_VerificationCode(to=email, code=ncode)
data = {
'ID' : 9,
'Message':'Invalide Code,'
}
data = pickle.dumps(data)
conn.send(data)
elif id == 600:
Exit = True
return
else:
data = {
'ID': 7,
'Message': 'Invalid ID Used for sending message'
}
data = pickle.dumps(data)
conn.send(data)
print("Returning from handle client")
return
# def forgot_password(conn):
# EXIT = False
# while not exit:
# rev = conn.recv(1024)
# data = pickle.loads(rev)
# if id == 1100:
# email = data['Email']
# userid = data['UserID']
# #send these details to database to recover password
# continue
# else:
# data = {
# 'ID': 7,
# 'Message': 'Invalid ID Used for sending message'
# }
# data = pickle.dumps(data)
# conn.send(data)
def Register_Client(conn, rdata):
Exit = False
Variefy = False
while not Variefy:
print("Inside the loop register")
rev = conn.recv(1024)
rdata = pickle.loads(rev)
id = rdata['ID']
if id == 1:
uid = rdata['UserID']
# uname = data['Username']
email = rdata['Email']
passwd = rdata['Password']
####Add these fields to Clients table
#try:
if (DB.Add_new_User(uid, email, Password= passwd)):
code = random_number()
data = {
'ID': 1000,
'Message': 'Successful but not varified',
#'Code' : code,
}
# continue
# Send email to the client for verification with code
Send_VerificationCode(email, uid, code)
else:
data = {
'ID' : 1500,
'Message': 'User with given email address is already exist'
}
# except:
# print("Error while Creating new user with username {}".format(uid))
# data = {
# 'ID' : 2000,
# 'Message' : 'Registration Unsuccessfull'
# }
# # data = pickle.dumps(data)
# conn.send(data)
#continue
####After success send the message of confermation
data = pickle.dumps(data)
conn.send(data)
#rev = sock.recv(2048)
#rdata = pickle.dumps(rev)
Exit = True
elif id == 2:
revcode = rdata['Code']
print("Recieved code is {}".format(revcode))
if revcode == code:
Variefy = True
DB.verify_user(uid=uid)
data = {
'ID': 2,
'Message': 'Successful and varified',
}
else:
#ncode = random_number()
#Send_VerificationCode(to=email, code=ncode)
data = {
'ID' : 9,
'Message':'Invalide Code, new verification code sent'
}
data = pickle.dumps(data)
conn.send(data)
else:
continue
print("Completed")
return
print("Server is running on port {}".format(PORT))
while not CLOSE:
try:
conn, addr = sock.accept()
#rec = conn.recv(1024).decode()
rec = conn.recv(2048)
data = pickle.loads(rec)
if data['ID'] == 5 or data['ID'] == 6:
#conn.send("Connected".encode())
thread = threading.Thread(target=handle_client, args=(conn,data,))
THREADS.append({'conn': conn,'Thread':thread})
thread.start()
elif data['ID'] == 700:
#conn.send("Connected".encode())
thread1 = threading.Thread(target=Register_Client, args=(conn, rdata))
THREADS.append({'Thread':thread1, 'conn':conn})
thread1.start()
# elif rec == 'ForgotPassword':
# conn.send("Connected".encode())
# thread2 = threading.Thread(target=forgot_password, args=(conn,))
# THREADS.append(thread2)
# thread2.start()
else:
continue
except KeyboardInterrupt:
CLOSE = True
print('')
print("Server is closed")
except ConnectionRefusedError:
continue
except:
continue
# while len(THREADS) > 0:
for t in THREADS:
t['Thread'].join()
print("Closing the server..........")
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,763
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/move_functions.py
|
from functions import *
class CastleRights:
def __init__(self, wks, wqs, bks, bqs):
self.wks = wks
self.wqs = wqs
self.bks = bks
self.bqs = bqs
class Moves_manager:
def __init__(self, game):
self.game = game
self.pieces = {}
self.enemy_pieces = {}
self.legal_moves = list()
self.selected_piece = None
self.adjustment_dictionary_name = None
self.currentCastleRights = self.game.update_castle()
self.my_piece_color = self.game.my_piece_color
self.my_turn = self.game.my_turn
#self.direction = -1 if self.my_piece_color == ''
self.whiteToMove = self.game.whiteToMove
self.possibleMoves = list()
self.in_check = False
self.pins = [] #squares pinned and the direction it's pinned from (list of lists)
self.checks = [] #squares where enemy is applying a check
self.rook_moves = list()
self.knight_moves = list()
self.bishop_moves = list()
self.queen_moves = list()
self.white_pawn_moves = list()
#self.black_pawn_moves = list()
self.king_moves = list()
self.castle_moves = list()
self.checkmate = False
self.stalemate = False
self.moves_count = 1
self.promotion = False
self.enpassant = False
self.enpassant_sq = []
self.enpassant_captured_piece = None
self.PromotedPiece = None
'''
if black plays pawn 2 squares and white pawn is present adjacent to it,
set self.wenpassant = True and append to wenpassant as [[attack1, capture, direction]]
after white plays, pop the entire wenpassant and set self.wenpassant = False
#attacking pawn is white
#attacking pawn is black
#enpassant_sq[0] = coordinates of attacking pawn
#enpassant_sq[1] = coordinates of captured pawn
#enpassant_sq[2] = direction # to be modified
'''
def squareUnderAttack(self, coords, my_color, board):
#self.whiteToMove = not self.whiteToMove
if my_color == 'white':
enemy_color = 'black'
else:
enemy_color = 'white'
#print(board[1][1].piece.name)
for i in range(8):
for j in range(8):
if board[i][j].is_empty == False:
#print(i, j)
Piece = board[i][j].piece
if Piece.color == enemy_color:
if Piece.name == "pawn" and len(self.enemy_pieces['pawn']) > 0:
#in case of pawn, no use calling get_pawn_moves. instead, collect pawn.position from moves_manager.pieces
#and putcondition of diagonal attack of pawn
for pawn in self.enemy_pieces['pawn']:
self.possibleMoves.append(
[pawn.position, [pawn.position[0] + 1, pawn.position[1] + 1], pawn, None])
self.possibleMoves.append(
[pawn.position, [pawn.position[0] + 1, pawn.position[1] - 1], pawn, None])
elif Piece.name == "rook":
#self.possibleMoves = list()
self.get_rook_moves(Piece, board)
elif Piece.name == "bishop":
#self.possibleMoves = list()
self.get_bishop_moves(Piece, board)
elif Piece.name == "knight":
#self.possibleMoves = list()
self.get_knight_moves(Piece, board)
elif Piece.name == "queen":
#self.possibleMoves = list()
self.get_queen_moves(Piece, board)
moves = self.possibleMoves
if len(moves) > 0:
for k in range(len(moves)):
if moves[k][1] == coords:
return True
return False
def get_castling_moves(self, board):
#self.selected_piece = piece
#self.adjustment_dictionary_name = self.selected_piece.color[0].upper() + self.selected_piece.name[0].upper() + self.selected_piece.name[1:]
#self.castle_moves = list()
piece = self.pieces['king'][0]
#change this later
if self.my_piece_color == 'White':
if self.currentCastleRights.wks == True:
# print("1")
#print(piece.position, piece.color)
if board[piece.position[0]][piece.position[1] + 1].is_empty == True and board[piece.position[0]][
piece.position[1] + 2].is_empty == True and (not self.squareUnderAttack([
piece.position[0], piece.position[1] + 1], 'white', board)) and (not self.squareUnderAttack([
piece.position[0], piece.position[1] + 2], 'white', board)):
self.castle_moves.append(board[piece.position[0]][piece.position[1] + 2])
self.possibleMoves.append(
[piece.position, [piece.position[0], piece.position[1] + 2], piece,
None])
if self.currentCastleRights.wqs == True:
#print(piece.position, piece.color)
if board[piece.position[0]][piece.position[1] - 1].is_empty == True and board[piece.position[0]][
piece.position[1] - 2].is_empty == True and board[piece.position[0]][
piece.position[1] - 3].is_empty == True and (not self.squareUnderAttack([
piece.position[0], piece.position[1] - 1], 'white', board)) and (not self.squareUnderAttack([
piece.position[0], piece.position[1] - 2], 'white', board)):
self.castle_moves.append(board[piece.position[0]][piece.position[1] - 2])
self.possibleMoves.append(
[piece.position, [piece.position[0], piece.position[1] - 2], piece,
None])
elif self.my_piece_color == 'Black':
if self.currentCastleRights.bks == True:
# print("1")
if board[piece.position[0]][piece.position[1] - 1].is_empty == True and board[piece.position[0]][
piece.position[1] - 2].is_empty == True and (not self.squareUnderAttack([
piece.position[0], piece.position[1] - 1], 'black', board)) and (not self.squareUnderAttack([
piece.position[0], piece.position[1] - 2], 'black', board)):
self.castle_moves.append(board[piece.position[0]][piece.position[1] - 2])
self.possibleMoves.append(
[piece.position, [piece.position[0], piece.position[1] - 2], piece,
None])
if self.currentCastleRights.bqs == True:
if board[piece.position[0]][piece.position[1] + 1].is_empty == True and board[
piece.position[0]][piece.position[1] + 2].is_empty == True and board[
piece.position[0]][piece.position[1] + 3].is_empty == True and (not self.squareUnderAttack([
piece.position[0], piece.position[1] + 1], 'black', board)) and (not self.squareUnderAttack([
piece.position[0], piece.position[1] + 2], 'black', board)):
self.castle_moves.append(board[piece.position[0]][piece.position[1] + 2])
self.possibleMoves.append(
[piece.position, [piece.position[0], piece.position[1] + 2], piece,
None])
#return self.castle_moves
def check_pins_and_checks(self, board):
global my_color, enemy_color
start_row = []
start_col = []
if self.my_piece_color == 'White':
my_color = 'white'
enemy_color = 'black'
else:
my_color = 'black'
enemy_color = 'white'
king_coords = self.pieces['king'][0].position
#self.wking_loc = king_coords
# check outwards from king for pins and checks, keep track of pins
directions = [[-1, 0], [0, -1], [1, 0], [0, 1], [-1, -1], [-1, 1], [1, -1], [1, 1]]
for j in range(len(directions)):
direction = directions[j]
possible_pin = [] #reset possible pins
start_row = king_coords[0]
start_col = king_coords[1]
# print(start_row, start_col)
for i in range(1, 8):
end_row = start_row + direction[0] * i
end_col = start_col + direction[1] * i
if 0 <= end_row <= 7 and 0 <= end_col <= 7:
if board[end_row][end_col].is_empty == False:
end_piece = board[end_row][end_col].piece
if end_piece.color == my_color and end_piece.name != "king":
if possible_pin == []: #first my_piece which could be pinned
possible_pin = [[end_row, end_col], [direction[0], direction[1]]]
#print(possible_pin)
else: #Second my_piece is in the same direction.
break #So no check or pin from this direction
elif end_piece.color == enemy_color:
enemy_type = end_piece.name
if (0 <= j <= 3 and enemy_type == "rook") or (4 <= j <= 7 and enemy_type == "bishop") or (
i == 1 and enemy_type == "pawn" and ((enemy_color == "white" and 6 <= j <= 7) or (
enemy_color == 'black' and 4 <= j <= 5))) or (enemy_type == "queen") or (
i == 1 and enemy_type == "king"):
if possible_pin == []: #Check because no piece is blocking
self.in_check = True
if [[end_row, end_col], [direction[0], direction[1]]] not in self.checks:
self.checks.append([[end_row, end_col], [direction[0], direction[1]]])
break
else: #Pin because piece is blocking
if possible_pin not in self.pins:
self.pins.append(possible_pin)
break
else: #enemy_piece not applying checks
break
else:
break #off board
#check for knight checks
knight_moves = [[-2, -1], [-2, 1], [-1, 2], [1, 2], [2, -1], [2, 1], [-1, -2], [1, -2]]
for move in knight_moves:
end_row = start_row + move[0]
end_col = start_col + move[1]
if 0 <= end_row <= 7 and 0 <= end_col <= 7:
if not board[end_row][end_col].is_empty:
end_piece = board[end_row][end_col].piece
if end_piece.color == enemy_color and end_piece.name == "knight": #enemy knight attaking king
self.in_check = True
self.checks.append([[end_row, end_col], [move[0], move[1]]])
def get_king_moves(self, piece, board):
#self.selected_piece = piece
self.adjustment_dictionary_name = self.selected_piece.color[0].upper() + self.selected_piece.name[
0].upper() + self.selected_piece.name[1:]
self.check_pins_and_checks(board)
possible_moves = [[-1, 0], [-1, 1], [0, 1], [1, 1],
[1, 0], [1, -1], [0, -1], [-1, -1]]
opponent_king = self.enemy_pieces['king'][0]
opponent_king_color = self.enemy_pieces['king'][0].color
opp_king_pos = self.enemy_pieces['king'][0].position
prohibited_positions = list()
for move in possible_moves:
if 0 <= opp_king_pos[0] + move[0] <= 7 and 0 <= opp_king_pos[1] + move[1] <= 7:
prohibited_positions.append([opp_king_pos[0] + move[0], opp_king_pos[1] + move[1]])
for pos in possible_moves:
if (0 <= piece.position[0] + pos[0] <= 7) and (0 <= piece.position[1] + pos[1] <= 7):
if board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].is_empty == True:
if not self.squareUnderAttack([piece.position[0] + pos[0], piece.position[1] + pos[1]], piece.color, board) and [
piece.position[0] + pos[0], piece.position[1] + pos[1]] not in prohibited_positions:
self.king_moves.append(board[piece.position[0] + pos[0]][piece.position[1] + pos[1]])
self.possibleMoves.append(
[piece.position, [piece.position[0] + pos[0], piece.position[1] + pos[1]], piece,
None])
# captures
else:
captured_piece = board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece
if self.selected_piece.color == 'white': #white king captures black piece
if not self.squareUnderAttack([piece.position[0] + pos[0], piece.position[1] + pos[1]], piece.color, board) and [
piece.position[0] + pos[0], piece.position[1] + pos[1]] not in prohibited_positions:
if (board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece.color == 'black') and (
board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece.name != 'king'):
self.king_moves.append(board[piece.position[0] + pos[0]][piece.position[1] + pos[1]])
self.possibleMoves.append(
[piece.position, [piece.position[0] + pos[0], piece.position[1] + pos[1]], piece, captured_piece])
#self.get_castling_moves(self.king_moves, board, piece)
else: #black king captures white piece
if not self.squareUnderAttack([piece.position[0] + pos[0], piece.position[1] + pos[1]], piece.color, board) and [
piece.position[0] + pos[0], piece.position[1] + pos[1]] not in prohibited_positions:
if (board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece.color == 'white') and (
board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece.name != 'king'):
self.king_moves.append(board[piece.position[0] + pos[0]][piece.position[1] + pos[1]])
self.possibleMoves.append(
[piece.position, [piece.position[0] + pos[0], piece.position[1] + pos[1]], piece,
captured_piece])
#self.get_castling_moves(board)
def get_knight_moves(self, piece, board):
#self.selected_piece = piece
self.adjustment_dictionary_name = self.selected_piece.color[0].upper() + self.selected_piece.name[
0].upper() + self.selected_piece.name[1:]
self.check_pins_and_checks(board)
for i in range(len(self.pins)):
if piece.position == self.pins[i][0]:
return []
possible_moves = [[-1, 2], [-1, -2], [1, 2], [1, -2], [2, 1], [2, -1], [-2, 1], [-2, -1]]
for pos in possible_moves:
if (piece.position[0] + pos[0] >= 0) and (piece.position[1] + pos[1] >= 0) and (
piece.position[0] + pos[0] <= 7) and (piece.position[1] + pos[1] <= 7):
if board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].is_empty:
self.knight_moves.append(board[piece.position[0] + pos[0]][piece.position[1] + pos[1]])
self.possibleMoves.append(
[piece.position, [piece.position[0] + pos[0], piece.position[1] + pos[1]], piece,
None])
# captures
else:
captured_piece = board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece
if self.selected_piece.color == 'white':
if (board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece.color == 'black'):# and (
#board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece.name != 'king'):
self.knight_moves.append(board[piece.position[0] + pos[0]][piece.position[1] + pos[1]])
self.possibleMoves.append(
[piece.position, [piece.position[0] + pos[0], piece.position[1] + pos[1]], piece,
captured_piece])
else:
if (board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece.color == 'white'):# and (
#board[piece.position[0] + pos[0]][piece.position[1] + pos[1]].piece.name != 'king'):
self.knight_moves.append(board[piece.position[0] + pos[0]][piece.position[1] + pos[1]])
self.possibleMoves.append(
[piece.position, [piece.position[0] + pos[0], piece.position[1] + pos[1]], piece,
captured_piece])
def get_rook_moves(self, piece, board):
#self.selected_piece = piece
self.adjustment_dictionary_name = self.selected_piece.color[0].upper() + self.selected_piece.name[
0].upper() + self.selected_piece.name[1:]
piece_pinned = False
pin_direction = []
self.check_pins_and_checks(board)
for i in range(len(self.pins) - 1, -1, -1):
if piece.position == self.pins[i][0]:
piece_pinned = True
pin_direction = self.pins[i][1]
if board[piece.position[0]][piece.position[1]] != "queen":
self.pins.remove(self.pins[i])
break
directions = [[-1, 0], [1, 0], [0, -1], [0, 1]]
for direction in directions:
for i in range(1, 8):
end_row = piece.position[0] + direction[0] * i
end_col = piece.position[1] + direction[1] * i
if 0 <= end_row <= 7 and 0 <= end_col <= 7:
if not piece_pinned or pin_direction == direction or pin_direction == [-direction[0], -direction[1]]:
if board[end_row][end_col].is_empty == True:
self.rook_moves.append(board[end_row][end_col])
self.possibleMoves.append(
[piece.position, [end_row, end_col], piece,
None])
#captures
else:
if self.selected_piece.color == "white":
captured_piece = board[end_row][end_col].piece
if board[end_row][end_col].piece.color == "black":# and board[end_row][
#end_col].piece.name != "king":
self.rook_moves.append(board[end_row][end_col])
self.possibleMoves.append(
[piece.position, [end_row, end_col], piece,
captured_piece])
break
elif board[end_row][end_col].piece.color == "white":
break
else:
captured_piece = board[end_row][end_col].piece
if board[end_row][end_col].piece.color == "white":# and board[end_row][
#end_col].piece.name != "king":
self.rook_moves.append(board[end_row][end_col])
self.possibleMoves.append(
[piece.position, [end_row, end_col], piece,
captured_piece])
break
elif board[end_row][end_col].piece.color == 'black':
break
def get_bishop_moves(self, piece, board):
#self.selected_piece = piece
self.adjustment_dictionary_name = self.selected_piece.color[0].upper() + self.selected_piece.name[
0].upper() + self.selected_piece.name[1:]
piece_pinned = False
pin_direction = []
self.check_pins_and_checks(board)
for i in range(len(self.pins) - 1, -1, -1):
if piece.position == self.pins[i][0]:
piece_pinned = True
pin_direction = self.pins[i][1]
self.pins.remove(self.pins[i])
break
directions = [[-1, -1], [-1, 1], [1, 1], [1, -1]]
for direction in directions:
for i in range(1, 8):
end_row = piece.position[0] + direction[0] * i
end_col = piece.position[1] + direction[1] * i
if 0 <= end_row <= 7 and 0 <= end_col <= 7:
if not piece_pinned or pin_direction == direction or pin_direction == [-direction[0],
-direction[1]]:
if board[end_row][end_col].is_empty == True:
self.bishop_moves.append(board[end_row][end_col])
self.possibleMoves.append(
[piece.position, [end_row, end_col], piece,
None])
else:
if self.selected_piece.color == "white":
captured_piece = board[end_row][end_col].piece
if board[end_row][end_col].piece.color == "black":# and board[end_row][
#end_col].piece.name != "king":
self.bishop_moves.append(board[end_row][end_col])
self.possibleMoves.append(
[piece.position, [end_row, end_col], piece,
captured_piece])
break
elif board[end_row][end_col].piece.color == "white":
break
else:
captured_piece = board[end_row][end_col].piece
if board[end_row][end_col].piece.color == "white":# and board[end_row][
#end_col].piece.name != "king":
self.bishop_moves.append(board[end_row][end_col])
self.possibleMoves.append(
[piece.position, [end_row, end_col], piece,
captured_piece])
break
elif board[end_row][end_col].piece.color == "black":
break
def get_queen_moves(self, piece, board):
#self.selected_piece = piece
self.adjustment_dictionary_name = self.selected_piece.color[0].upper() + self.selected_piece.name[
0].upper() + self.selected_piece.name[1:]
self.queen_moves = self.get_rook_moves(piece, board)
temp = self.get_bishop_moves(piece, board)
if temp is not None:
for i in temp:
self.queen_moves.append(i)
def get_white_pawn_moves(self, piece, board):
direction = -1
#self.selected_piece = piece
self.adjustment_dictionary_name = self.selected_piece.color[0].upper() + self.selected_piece.name[
0].upper() + self.selected_piece.name[1:]
piece_pinned = False
pin_direction = []
self.check_pins_and_checks(board)
for i in range(len(self.pins) - 1, -1, -1):
if piece.position == self.pins[i][0]:
piece_pinned = True
pin_direction = self.pins[i][1]
self.pins.remove(self.pins[i])
break
if piece.position[0] == 6:
if not piece_pinned or pin_direction == [direction, 0]:
if (board[piece.position[0] + direction][piece.position[1]].is_empty == True):
self.white_pawn_moves.append(board[piece.position[0] + direction][piece.position[1]])
self.possibleMoves.append(
[piece.position, [piece.position[0] + direction, piece.position[1]], piece,
None])
if (board[piece.position[0] + 2 * direction][piece.position[1]].is_empty == True) and (
board[piece.position[0] + direction][piece.position[1]].is_empty == True):
self.white_pawn_moves.append(board[piece.position[0] + 2 * direction][piece.position[1]])
self.possibleMoves.append(
[piece.position, [piece.position[0] + 2 * direction, piece.position[1]], piece,
None])
# captures
if 0 <= piece.position[0] + direction <= 7 and piece.position[1] + 1 <= 7: # captures towards right
if not piece_pinned or pin_direction == [direction, 1]:
if board[piece.position[0] + direction][piece.position[1] + 1].is_empty == False:
#print("Right")
captured_piece = board[piece.position[0] + direction][piece.position[1] + 1].piece
if (board[piece.position[0] + direction][piece.position[1] + 1].piece.color != self.my_piece_color.lower()):# and (
#board[piece.position[0] - 1][piece.position[1] + 1].piece.name != 'king'):
self.white_pawn_moves.append(board[piece.position[0] + direction][piece.position[1] + 1])
self.possibleMoves.append(
[piece.position, [piece.position[0] + direction, piece.position[1] + 1], piece,
captured_piece])
if 0 <= piece.position[0] + direction <= 7 and piece.position[1] - 1 >= 0: # captures towards left
if not piece_pinned or pin_direction == [direction, -1]:
if board[piece.position[0] + direction][piece.position[1] - 1].is_empty == False:
#print("Left")
captured_piece = board[piece.position[0] + direction][piece.position[1] - 1].piece
if (board[piece.position[0] + direction][piece.position[1] - 1].piece.color != self.my_piece_color.lower()):# and (
#board[piece.position[0] - 1][piece.position[1] - 1].piece.name != 'king'):
self.white_pawn_moves.append(board[piece.position[0] + direction][piece.position[1] - 1])
self.possibleMoves.append(
[piece.position, [piece.position[0] + direction, piece.position[1] - 1], piece,
captured_piece])
elif piece.position[0] in [5, 4, 3, 2, 1]:
if not piece_pinned or pin_direction == [direction, 0]:
if (board[piece.position[0] +direction][piece.position[1]].is_empty == True):
self.white_pawn_moves.append(board[piece.position[0] +direction][piece.position[1]])
self.possibleMoves.append(
[piece.position, [piece.position[0] +direction, piece.position[1]], piece,
None])
# captures
if 0 <= piece.position[0] + direction <= 7 and piece.position[1] + 1 <= 7: # captures towards right
if not piece_pinned or pin_direction == [direction, 1]:
if board[piece.position[0] +direction][piece.position[1] + 1].is_empty == False:
captured_piece = board[piece.position[0] +direction][piece.position[1] + 1].piece
if (board[piece.position[0] +direction][piece.position[1] + 1].piece.color != self.my_piece_color.lower()):# and (
#board[piece.position[0] - 1][piece.position[1] + 1].piece.name != 'king'):
self.white_pawn_moves.append(board[piece.position[0] +direction][piece.position[1] + 1])
self.possibleMoves.append(
[piece.position, [piece.position[0] +direction, piece.position[1] + 1], piece,
captured_piece])
if 0 <= piece.position[0] + direction <= 7 and piece.position[1] - 1 >= 0:
if not piece_pinned or pin_direction == [direction, -1]:
if board[piece.position[0] +direction][piece.position[1] - 1].is_empty == False:
captured_piece = board[piece.position[0] +direction][piece.position[1] - 1].piece
if (board[piece.position[0] +direction][piece.position[1] - 1].piece.color != self.my_piece_color.lower()):# and (
#board[piece.position[0] - 1][piece.position[1] - 1].piece.name != 'king'):
self.white_pawn_moves.append(board[piece.position[0] + direction][piece.position[1] - 1])
self.possibleMoves.append(
[piece.position, [piece.position[0] +direction, piece.position[1] - 1], piece,
captured_piece])
#Enpassant
if self.enpassant:
for enpas in self.enpassant_sq:
#print(enpas[1][0], enpas[2][0])
if not piece_pinned or pin_direction == [enpas[1][0] +direction, enpas[1][1]]:
captured_piece = board[enpas[1][0]][enpas[1][1]].piece
self.white_pawn_moves.append(board[enpas[1][0] +direction][enpas[1][1]])
self.possibleMoves.append(
[enpas[0], [enpas[1][0] +direction, enpas[1][1]], piece,
captured_piece])
def get_possible_moves(self, board):
#no of lines can be minimized using eval or locals. do it later.
self.check_pins_and_checks(board)
#print(len(self.pieces['pawn']))
if len(self.pieces['king']) > 0:
for i in self.pieces['king']:
self.get_king_moves(i, board)
if len(self.pieces['pawn']) > 0:
for i in self.pieces['pawn']:
#print("hello")
self.get_white_pawn_moves(i, board)
if len(self.pieces['bishop']) > 0:
for i in self.pieces['bishop']:
self.get_bishop_moves(i, board)
if len(self.pieces['rook']) > 0:
for i in self.pieces['rook']:
self.get_rook_moves(i, board)
if len(self.pieces['queen']) > 0:
for i in self.pieces['queen']:
self.get_queen_moves(i, board)
if len(self.pieces['knight']) > 0:
for i in self.pieces['knight']:
#print(i, i.name, i.position, i.color)
self.get_knight_moves(i, board)
#self.get_castling_moves(self.enemy_pieces['king'][0], board)
def get_legal_moves(self, piece, board):
self.selected_piece = piece
#reseting the variables mentioned below
self.possibleMoves = list()
self.legal_moves = list()
self.rook_moves = list()
self.knight_moves = list()
self.bishop_moves = list()
self.queen_moves = list()
self.white_pawn_moves = list()
#self.black_pawn_moves = list()
self.castle_moves = list()
self.king_moves = list()
self.in_check = False
self.pins = list()
self.checks = list()
#print("HELLO")
# self.adjustment_dictionary_name = self.selected_piece.color[0].upper()+self.selected_piece.name[0].upper()+self.selected_piece.name[1:]
#print(self.is_king_in_check(board))
self.check_pins_and_checks(board)
kingsq = self.pieces['king'][0].position
# board[kingsq[0]][kingsq[1]].piece
king = self.pieces['king'][0]
#print(self.in_check)
if self.in_check:
#print("HELLO")
if len(self.checks) == 1: #single check, hence it can be blocked or king can be moved
self.get_possible_moves(board)
moves = self.possibleMoves
#print(self.checks)
check_row = self.checks[0][0][0]
check_col = self.checks[0][0][1]
#print(check_row, check_col)
piece_checking = board[check_row][check_col].piece
valid_squares = [] #squares that pieces can move to (apart from king moves)
if piece_checking.name == 'knight':
valid_squares = [[check_row, check_col]]
else:
for i in range(8):
valid_square = [kingsq[0] + self.checks[0][1][0] * i,
kingsq[1] + self.checks[0][1][1] * i]
valid_squares.append(valid_square) #if piece_checking = bishop, valid_squares will contain all coordinates
#between king and bishop(excluding bishop and including king)
if valid_square[0] == check_row and valid_square[1] == check_col:
break
for i in range(len(moves) - 1, -1, -1):
if moves[i][2].name != 'king':
if not moves[i][1] in valid_squares: #remove those moves whose destination is not in valid squares
moves.remove(moves[i])
elif moves[i][2].color != king.color: #even piece_checking's color moves were included in moves, so need to remove them.
moves.remove(moves[i])
#for move in moves:
# print(move[0], move[1], move[2].name, move[2].color, move[3] , end = " ")
#print("\n")
if len(moves) > 0:
for i in range(len(moves)):
if moves[i][2] == piece:
self.legal_moves.append(board[moves[i][1][0]][moves[i][1][1]])
elif len(moves) == 0:
self.checkmate = True
print("CheckMate!!!!!")
else: #double check
self.get_king_moves(board[kingsq[0]][kingsq[1]].piece, board)
moves = self.possibleMoves
if len(moves) > 0:
for i in range(len(moves)):
if moves[i][2] == piece:
self.legal_moves.append(board[moves[i][1][0]][moves[i][1][1]])
elif len(moves) == 0:
self.checkmate = True
print("CheckMate!!!!!")
else:
#print("HELLO")
self.get_possible_moves(board)
moves = self.possibleMoves
#print(self.enpassant)
#for i in moves:
# print(i)
if len(moves) > 0:
for i in range(len(moves)):
if moves[i][2] == piece:
self.legal_moves.append(board[moves[i][1][0]][moves[i][1][1]]) #appending board[destination[0]][destination[1]]
self.possibleMoves = list()
self.get_castling_moves(board)
castling_moves = self.possibleMoves
if len(castling_moves) > 0:
for i in range(len(castling_moves)):
if castling_moves[i][2] == piece:
self.legal_moves.append(board[castling_moves[i][1][0]][castling_moves[i][1][1]])
if len(moves) == 0:
self.stalemate = True
print("Stalemate!!!!")
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,764
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/main_menu.py
|
import pygame
import sys
from pygame.locals import *
from qplay import *
from pwfriend import *
from player_profile import *
from settings import *
from client_network import *
import pickle
from configure import *
import threading
pygame.init()
FONT1 = pygame.font.SysFont('calibri',33,True)
FONT2 = pygame.font.SysFont('calibri',22,True)
FONT3 = pygame.font.SysFont('calibri',40,True)
FONT4 = pygame.font.SysFont('calibri',25,True)
FONT5 = pygame.font.SysFont('consolas',25,True)
class Button:
def __init__(self,name,x,y):
self.name = name
self.xstart = x
self.ystart = y
self.color = (0,255,0)
self.text = FONT1.render(self.name,True,self.color)
self.rect = self.text.get_rect()
self.rect.center = (x+100,y+50)
self.xlim = (self.xstart+50,self.xstart+150)
self.ylim = (self.ystart+25,self.ystart+75)
def draw(self,screen,pos):
if (pos[0]>=self.xlim[0] and pos[0]<=self.xlim[1]) and (pos[1]>=self.ylim[0] and pos[1]<= self.ylim[1]):
pygame.draw.rect(screen,(186,103,35),[self.xstart+51,self.ystart+27,98,48],border_radius=10)
screen.blit(self.text,self.rect)
pygame.draw.rect(screen,(255,255,255),[self.xstart+50,self.ystart+25,100,50],2,10)
class Option:
def __init__(self,name,x,y):
self.name = name
self.xstart = x
self.ystart = y
self.width = 1536*(19.53/100)
self.height = 801*(62.42/100)
self.title = FONT1.render(self.name,True,(255,255,255))
self.rect = self.title.get_rect()
self.description = ""
self.d_rect = None
class Main_menu:
def __init__(self,screen,clock,password):
self.screen = screen
self.clock = clock
self.background_color = (114,6,6)
self.options_color = (140,44,44)
self.icon_background_color = (82,0,2)
self.password = password
#self.bg = pygame.image.load('Media/bg2.jpg')
self.quickplay = Option("Quickplay",138,150.5)
self.quickplay.rect.center = (self.quickplay.xstart+30+(self.quickplay.rect.width/2),self.quickplay.ystart+250)
self.quickplay.description = [FONT2.render("Automatically match with",True,(255,255,255)),FONT2.render("a random player.",True,(255,255,255))]
self.quickplay.d_rect = [self.quickplay.description[0].get_rect(),self.quickplay.description[1].get_rect()]
self.quickplay.d_rect[0].center = (self.quickplay.xstart+30+(self.quickplay.d_rect[0].width/2),self.quickplay.ystart+300)
self.quickplay.d_rect[1].center = (self.quickplay.xstart+30+(self.quickplay.d_rect[1].width/2),self.quickplay.ystart+325)
self.play_with_friend = Option("Play With Friend",self.quickplay.xstart+320,150.5)
self.play_with_friend.rect.center = (self.play_with_friend.xstart+30+(self.play_with_friend.rect.width/2),self.play_with_friend.ystart+250)
self.play_with_friend.description = [FONT2.render("Invite a friend with",True,(255,255,255)),FONT2.render("game-id/username.",True,(255,255,255))]
self.play_with_friend.d_rect = [self.play_with_friend.description[0].get_rect(),self.play_with_friend.description[1].get_rect()]
self.play_with_friend.d_rect[0].center = (self.play_with_friend.xstart+30+(self.play_with_friend.d_rect[0].width/2),self.play_with_friend.ystart+300)
self.play_with_friend.d_rect[1].center = (self.play_with_friend.xstart+30+(self.play_with_friend.d_rect[1].width/2),self.play_with_friend.ystart+325)
self.profile = Option("Profile",self.play_with_friend.xstart+320,150.5)
self.profile.rect.center = (self.profile.xstart+30+(self.profile.rect.width/2),self.profile.ystart+250)
self.profile.description = [FONT2.render("Edit profile,See statistics,",True,(255,255,255)),FONT2.render("Manage friends.",True,(255,255,255))]
self.profile.d_rect = [self.profile.description[0].get_rect(),self.profile.description[1].get_rect()]
self.profile.d_rect[0].center = (self.profile.xstart+30+(self.profile.d_rect[0].width/2),self.profile.ystart+300)
self.profile.d_rect[1].center = (self.profile.xstart+30+(self.profile.d_rect[1].width/2),self.profile.ystart+325)
self.settings = Option("Settings",self.profile.xstart+320,150.5)
self.settings.rect.center = (self.settings.xstart+30+(self.settings.rect.width/2),self.settings.ystart+250)
self.settings.description = [FONT2.render("Board/Pieces appearance,",True,(255,255,255)),FONT2.render("Adjust volume,theme,",True,(255,255,255)),FONT2.render("Enable/Disable music.",True,(255,255,255))]
self.settings.d_rect = [self.settings.description[0].get_rect(),self.settings.description[1].get_rect(),self.settings.description[2].get_rect()]
self.settings.d_rect[0].center = (self.settings.xstart+30+(self.settings.d_rect[0].width/2),self.settings.ystart+300)
self.settings.d_rect[1].center = (self.settings.xstart+30+(self.settings.d_rect[1].width/2),self.settings.ystart+325)
self.settings.d_rect[2].center = (self.settings.xstart+30+(self.settings.d_rect[2].width/2),self.settings.ystart+350)
self.quickplay_image = pygame.image.load('Media/quickplay.png')
self.quickplay_image = pygame.transform.scale(self.quickplay_image,(250,250))
self.play_with_friend_image = pygame.image.load('Media/play_with_friend.png')
self.play_with_friend_image = pygame.transform.scale(self.play_with_friend_image,(160,160))
self.profile_image = pygame.image.load('Media/profile.png')
self.profile_image = pygame.transform.scale(self.profile_image,(120,140))
self.settings_image = pygame.image.load('Media/settings.png')
self.settings_image = pygame.transform.scale(self.settings_image,(130,130))
# Option original position position after adjustment
self.text_adjust = {'quickplay':[self.quickplay.rect.center,(self.quickplay.rect.center[0]-7.5,self.quickplay.rect.center[1])],
'quickplay info':[self.quickplay.d_rect[0].center,(self.quickplay.d_rect[0].center[0]-7.5,self.quickplay.d_rect[0].center[1])
,self.quickplay.d_rect[1].center,(self.quickplay.d_rect[1].center[0]-7.5,self.quickplay.d_rect[1].center[1])],
'play with friend':[self.play_with_friend.rect.center,(self.play_with_friend.rect.center[0]+7.5,self.play_with_friend.rect.center[1])
,(self.play_with_friend.rect.center[0]-7.5,self.play_with_friend.rect.center[1])],
'play with friend info':[self.play_with_friend.d_rect[0].center,(self.play_with_friend.d_rect[0].center[0]+7.5,self.play_with_friend.d_rect[0].center[1])
,self.play_with_friend.d_rect[1].center,(self.play_with_friend.d_rect[1].center[0]+7.5,self.play_with_friend.d_rect[1].center[1])
,(self.play_with_friend.d_rect[0].center[0]-7.5,self.play_with_friend.d_rect[0].center[1])
,(self.play_with_friend.d_rect[1].center[0]-7.5,self.play_with_friend.d_rect[1].center[1])],
'profile':[self.profile.rect.center,(self.profile.rect.center[0]+7.5,self.profile.rect.center[1])
,(self.profile.rect.center[0]-7.5,self.profile.rect.center[1])],
'profile info':[self.profile.d_rect[0].center,(self.profile.d_rect[0].center[0]+7.5,self.profile.d_rect[0].center[1])
,self.profile.d_rect[1].center,(self.profile.d_rect[1].center[0]+7.5,self.profile.d_rect[1].center[1])
,(self.profile.d_rect[0].center[0]-7.5,self.profile.d_rect[0].center[1])
,(self.profile.d_rect[1].center[0]-7.5,self.profile.d_rect[1].center[1])],
'settings':[self.settings.rect.center,(self.settings.rect.center[0]+7.5,self.settings.rect.center[1])],
'settings info':[self.settings.d_rect[0].center,(self.settings.d_rect[0].center[0]+7.5,self.settings.d_rect[0].center[1])
,self.settings.d_rect[1].center,(self.settings.d_rect[1].center[0]+7.5,self.settings.d_rect[1].center[1])
,self.settings.d_rect[2].center,(self.settings.d_rect[2].center[0]+7.5,self.settings.d_rect[2].center[1])]
}
self.quit_button = Button('Logout',1350,0)
self.stgs = read_settings()
self.uID = self.stgs['UserID']
self.client = User(self.uID,self.password)
self.qp_object = Quickplay(self.screen,self.clock,self.client)
self.pwf_object = PlayWithFriend(self.screen,self.clock,self.client)
self.prof_object = Profile(self.screen,self.clock,self.client)
self.settings_object = Settings(self.screen,self.clock)
self.accept = pygame.image.load('Media/select.png')
self.decline = pygame.image.load('Media/cross.png')
self.notification = None
self.notification_text = None
self.count_down = 1
self.in_room = False
self.accepted = False
self.declined = False
def set_timer(self):
self.count_down = 0
def get_main_page_messages(self,pos,events):
if self.client.main_page_messages:
self.notification = self.client.main_page_messages.pop()
if self.notification['ID'] == 50:
self.notification_text = "{} sent a request to play".format(self.notification['Sender'])
self.notification_text = FONT5.render(self.notification_text,True,(0,200,0))
self.count_down = 1
timer = threading.Timer(10.0, self.set_timer)
timer.start()
elif self.notification['ID']==2200:
self.client.pwf_section_messages = []
self.client.quickplay_section_messages = []
self.client.room_id = self.notification['RoomID']
self.client.color = self.notification['Turn']
self.in_room = True
if self.notification_text and self.count_down:
pygame.draw.rect(self.screen,(255,255,255),[40,35,183+self.notification_text.get_rect().width,72])
self.screen.blit(self.accept,(50,50))
self.screen.blit(self.decline,(120,50))
self.screen.blit(self.notification_text,(180,60))
pygame.draw.rect(self.screen,(0,0,0),[50,50,50,50],3)
pygame.draw.rect(self.screen,(0,0,0),[120,50,50,50],3)
for event in events:
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
if pos[0]<=100 and pos[0]>=50 and pos[1]<=100 and pos[1]>=50 and not self.accepted:
message = {'ID':55,'Status':'Accepted','UserID':self.uID,'FriendID':self.notification['Sender']}
self.client.sock.send(pickle.dumps(message))
self.accepted = True
self.client.enemy_name = self.notification['Sender']
print("Enemy is:",self.client.enemy_name)
#print("Accepted")
elif pos[0]<=170 and pos[0]>=120 and pos[1]<=100 and pos[1]>=50 and not self.declined:
message = {'ID':55,'Status':'Declined','UserID':self.uID,'FriendID':self.notification['Sender']}
self.client.sock.send(pickle.dumps(message))
self.declined = True
#print("Declined")
#pygame.draw.rect(self.screen,(255,255,255),[40,35,180+self.notification_text.get_rect().width,80],3)
def update(self):
while True:
pos = pygame.mouse.get_pos()
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
message = {'ID':65,'UserID':self.uID}
self.client.sock.send(pickle.dumps(message))
self.client.sock.close()
return "exit to desktop"
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
if (pos[0]>=self.quit_button.xlim[0] and pos[0]<=self.quit_button.xlim[1]) and (pos[1]>=self.quit_button.ylim[0] and pos[1]<= self.quit_button.ylim[1]):
message = {'ID':65,'UserID':self.uID}
self.client.sock.send(pickle.dumps(message))
self.client.sock.close()
#sys.exit()
return "exit to desktop"
#quickplay
elif pos[0]>=138 and pos[0]<=438 and pos[1]>=150.5 and pos[1]<=650.5:
message = {'ID':56,'UserID':self.client.uID}
self.client.sock.send(pickle.dumps(message))
self.qp_object.update()
#pwf
elif pos[0]>=478 and pos[0]<=758 and pos[1]>=150.5 and pos[1]<=650.5:
self.pwf_object.update()
#return
#profile
elif pos[0]>=778 and pos[0]<=1078 and pos[1]>=150.5 and pos[1]<=650.5:
self.prof_object.update()
#settings
elif pos[0]>=1098 and pos[0]<=1398 and pos[1]>=150.5 and pos[1]<=650.5:
self.settings_object.update()
self.screen.fill(self.background_color)
#self.screen.blit(self.bg,(0,0))
#mouse pointer on quickplay
if pos[0]>=138 and pos[0]<=438 and pos[1]>=150.5 and pos[1]<=650.5:
pygame.draw.rect(self.screen,self.options_color,[self.quickplay.xstart-12.5,self.quickplay.ystart-40,self.quickplay.width+25,self.quickplay.height+80],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.play_with_friend.xstart+7.5,self.play_with_friend.ystart,self.play_with_friend.width,self.play_with_friend.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.profile.xstart+7.5,self.profile.ystart,self.profile.width,self.profile.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.settings.xstart+7.5,self.settings.ystart,self.settings.width,self.settings.height],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.quickplay.xstart+7.5,self.quickplay.ystart-20,self.quickplay.width-15,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.play_with_friend.xstart+27.5,self.play_with_friend.ystart+20,self.play_with_friend.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.profile.xstart+27.5,self.profile.ystart+20,self.profile.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.settings.xstart+27.5,self.settings.ystart+20,self.settings.width-40,200],border_radius=20)
self.screen.blit(self.quickplay_image,(self.quickplay.xstart+25,self.quickplay.ystart-40))
self.screen.blit(self.play_with_friend_image,(self.play_with_friend.xstart+82.5,self.play_with_friend.ystart+40))
self.screen.blit(self.profile_image,(self.profile.xstart+92.5,self.profile.ystart+50))
self.screen.blit(self.settings_image,(self.settings.xstart+92.5,self.settings.ystart+55))
self.quickplay.title = FONT3.render(self.quickplay.name,True,(255,255,255))
self.quickplay.rect = self.quickplay.title.get_rect()
self.quickplay.rect.center = (self.quickplay.xstart+20+(self.quickplay.rect.width/2),self.quickplay.ystart+250)
self.quickplay.description = [FONT4.render("Automatically match with",True,(255,255,255)),FONT4.render("a random player.",True,(255,255,255))]
self.quickplay.d_rect = [self.quickplay.description[0].get_rect(),self.quickplay.description[1].get_rect()]
self.quickplay.d_rect[0].center = (self.quickplay.xstart+20+(self.quickplay.d_rect[0].width/2),self.quickplay.ystart+300)
self.quickplay.d_rect[1].center = (self.quickplay.xstart+20+(self.quickplay.d_rect[1].width/2),self.quickplay.ystart+325)
self.play_with_friend.rect.center = self.text_adjust['play with friend'][1]
self.play_with_friend.d_rect[0].center = self.text_adjust['play with friend info'][1]
self.play_with_friend.d_rect[1].center = self.text_adjust['play with friend info'][3]
self.profile.rect.center = self.text_adjust['profile'][1]
self.profile.d_rect[0].center = self.text_adjust['profile info'][1]
self.profile.d_rect[1].center = self.text_adjust['profile info'][3]
self.settings.rect.center = self.text_adjust['settings'][1]
self.settings.d_rect[0].center = self.text_adjust['settings info'][1]
self.settings.d_rect[1].center = self.text_adjust['settings info'][3]
self.settings.d_rect[2].center = self.text_adjust['settings info'][5]
#mouse pointer on play_with_friend
elif pos[0]>=478 and pos[0]<=758 and pos[1]>=150.5 and pos[1]<=650.5:
pygame.draw.rect(self.screen,self.options_color,[self.quickplay.xstart-7.5,self.quickplay.ystart,self.quickplay.width,self.quickplay.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.play_with_friend.xstart-12.5,self.play_with_friend.ystart-40,self.play_with_friend.width+25,self.play_with_friend.height+80],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.profile.xstart+7.5,self.profile.ystart,self.profile.width,self.profile.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.settings.xstart+7.5,self.settings.ystart,self.settings.width,self.settings.height],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.quickplay.xstart+12.5,self.quickplay.ystart+20,self.quickplay.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.play_with_friend.xstart+7.5,self.play_with_friend.ystart-20,self.play_with_friend.width-15,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.profile.xstart+27.5,self.profile.ystart+20,self.profile.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.settings.xstart+27.5,self.settings.ystart+20,self.settings.width-40,200],border_radius=20)
self.screen.blit(self.quickplay_image,(self.quickplay.xstart+17.5,self.quickplay.ystart))
self.screen.blit(self.play_with_friend_image,(self.play_with_friend.xstart+75,self.play_with_friend.ystart))
self.screen.blit(self.profile_image,(self.profile.xstart+92.5,self.profile.ystart+50))
self.screen.blit(self.settings_image,(self.settings.xstart+92.5,self.settings.ystart+55))
self.play_with_friend.title = FONT3.render(self.play_with_friend.name,True,(255,255,255))
self.play_with_friend.rect = self.play_with_friend.title.get_rect()
self.play_with_friend.rect.center = (self.play_with_friend.xstart+20+(self.play_with_friend.rect.width/2),self.play_with_friend.ystart+250)
self.play_with_friend.description = [FONT4.render("Invite a friend with",True,(255,255,255)),FONT4.render("game-id/username.",True,(255,255,255))]
self.play_with_friend.d_rect = [self.play_with_friend.description[0].get_rect(),self.play_with_friend.description[1].get_rect()]
self.play_with_friend.d_rect[0].center = (self.play_with_friend.xstart+20+(self.play_with_friend.d_rect[0].width/2),self.play_with_friend.ystart+300)
self.play_with_friend.d_rect[1].center = (self.play_with_friend.xstart+20+(self.play_with_friend.d_rect[1].width/2),self.play_with_friend.ystart+325)
self.quickplay.rect.center = self.text_adjust['quickplay'][1]
self.quickplay.d_rect[0].center = self.text_adjust['quickplay info'][1]
self.quickplay.d_rect[1].center = self.text_adjust['quickplay info'][3]
self.profile.rect.center = self.text_adjust['profile'][1]
self.profile.d_rect[0].center = self.text_adjust['profile info'][1]
self.profile.d_rect[1].center = self.text_adjust['profile info'][3]
self.settings.rect.center = self.text_adjust['settings'][1]
self.settings.d_rect[0].center = self.text_adjust['settings info'][1]
self.settings.d_rect[1].center = self.text_adjust['settings info'][3]
self.settings.d_rect[2].center = self.text_adjust['settings info'][5]
#mouse pointer on profile
elif pos[0]>=778 and pos[0]<=1078 and pos[1]>=150.5 and pos[1]<=650.5:
pygame.draw.rect(self.screen,self.options_color,[self.quickplay.xstart-7.5,self.quickplay.ystart,self.quickplay.width,self.quickplay.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.play_with_friend.xstart-7.5,self.play_with_friend.ystart,self.play_with_friend.width,self.play_with_friend.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.profile.xstart-12.5,self.profile.ystart-40,self.profile.width+25,self.profile.height+80],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.settings.xstart+7.5,self.settings.ystart,self.settings.width,self.settings.height],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.quickplay.xstart+12.5,self.quickplay.ystart+20,self.quickplay.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.play_with_friend.xstart+12.5,self.play_with_friend.ystart+20,self.play_with_friend.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.profile.xstart+7.5,self.profile.ystart-20,self.profile.width-15,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.settings.xstart+27.5,self.settings.ystart+20,self.settings.width-40,200],border_radius=20)
self.screen.blit(self.quickplay_image,(self.quickplay.xstart+17.5,self.quickplay.ystart))
self.screen.blit(self.play_with_friend_image,(self.play_with_friend.xstart+67.5,self.play_with_friend.ystart+40))
self.screen.blit(self.profile_image,(self.profile.xstart+90,self.profile.ystart+10))
self.screen.blit(self.settings_image,(self.settings.xstart+92.5,self.settings.ystart+55))
self.profile.title = FONT3.render(self.profile.name,True,(255,255,255))
self.profile.rect = self.profile.title.get_rect()
self.profile.rect.center = (self.profile.xstart+20+(self.profile.rect.width/2),self.profile.ystart+250)
self.profile.description = [FONT4.render("Edit profile,See statistics,",True,(255,255,255)),FONT4.render("Manage friends.",True,(255,255,255))]
self.profile.d_rect = [self.profile.description[0].get_rect(),self.profile.description[1].get_rect()]
self.profile.d_rect[0].center = (self.profile.xstart+20+(self.profile.d_rect[0].width/2),self.profile.ystart+300)
self.profile.d_rect[1].center = (self.profile.xstart+20+(self.profile.d_rect[1].width/2),self.profile.ystart+325)
self.quickplay.rect.center = self.text_adjust['quickplay'][1]
self.quickplay.d_rect[0].center = self.text_adjust['quickplay info'][1]
self.quickplay.d_rect[1].center = self.text_adjust['quickplay info'][3]
self.play_with_friend.rect.center = self.text_adjust['play with friend'][2]
self.play_with_friend.d_rect[0].center = self.text_adjust['play with friend info'][4]
self.play_with_friend.d_rect[1].center = self.text_adjust['play with friend info'][5]
self.settings.rect.center = self.text_adjust['settings'][1]
self.settings.d_rect[0].center = self.text_adjust['settings info'][1]
self.settings.d_rect[1].center = self.text_adjust['settings info'][3]
self.settings.d_rect[2].center = self.text_adjust['settings info'][5]
#mouse pointer on settings
elif pos[0]>=1098 and pos[0]<=1398 and pos[1]>=150.5 and pos[1]<=650.5:
pygame.draw.rect(self.screen,self.options_color,[self.quickplay.xstart-7.5,self.quickplay.ystart,self.quickplay.width,self.quickplay.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.play_with_friend.xstart-7.5,self.play_with_friend.ystart,self.play_with_friend.width,self.play_with_friend.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.profile.xstart-7.5,self.profile.ystart,self.profile.width,self.profile.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.settings.xstart-12.5,self.settings.ystart-40,self.settings.width+25,self.settings.height+80],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.quickplay.xstart+12.5,self.quickplay.ystart+20,self.quickplay.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.play_with_friend.xstart+12.5,self.play_with_friend.ystart+20,self.play_with_friend.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.profile.xstart+12.5,self.profile.ystart+20,self.profile.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.settings.xstart+7.5,self.settings.ystart-20,self.settings.width-15,200],border_radius=20)
self.screen.blit(self.quickplay_image,(self.quickplay.xstart+17.5,self.quickplay.ystart))
self.screen.blit(self.play_with_friend_image,(self.play_with_friend.xstart+67.5,self.play_with_friend.ystart+40))
self.screen.blit(self.profile_image,(self.profile.xstart+78.5,self.profile.ystart+50))
self.screen.blit(self.settings_image,(self.settings.xstart+85,self.settings.ystart+15))
self.settings.title = FONT3.render(self.settings.name,True,(255,255,255))
self.settings.rect = self.settings.title.get_rect()
self.settings.rect.center = (self.settings.xstart+20+(self.settings.rect.width/2),self.settings.ystart+250)
self.settings.description = [FONT4.render("Board/Pieces appearance,",True,(255,255,255)),FONT4.render("Adjust volume,theme,",True,(255,255,255)),FONT4.render("Enable/Disable music.",True,(255,255,255))]
self.settings.d_rect = [self.settings.description[0].get_rect(),self.settings.description[1].get_rect(),self.settings.description[2].get_rect()]
self.settings.d_rect[0].center = (self.settings.xstart+20+(self.settings.d_rect[0].width/2),self.settings.ystart+300)
self.settings.d_rect[1].center = (self.settings.xstart+20+(self.settings.d_rect[1].width/2),self.settings.ystart+325)
self.settings.d_rect[2].center = (self.settings.xstart+20+(self.settings.d_rect[2].width/2),self.settings.ystart+350)
self.quickplay.rect.center = self.text_adjust['quickplay'][1]
self.quickplay.d_rect[0].center = self.text_adjust['quickplay info'][1]
self.quickplay.d_rect[1].center = self.text_adjust['quickplay info'][3]
self.play_with_friend.rect.center = self.text_adjust['play with friend'][2]
self.play_with_friend.d_rect[0].center = self.text_adjust['play with friend info'][4]
self.play_with_friend.d_rect[1].center = self.text_adjust['play with friend info'][5]
self.profile.rect.center = self.text_adjust['profile'][2]
self.profile.d_rect[0].center = self.text_adjust['profile info'][4]
self.profile.d_rect[1].center = self.text_adjust['profile info'][5]
else:
pygame.draw.rect(self.screen,self.options_color,[self.quickplay.xstart,self.quickplay.ystart,self.quickplay.width,self.quickplay.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.play_with_friend.xstart,self.play_with_friend.ystart,self.play_with_friend.width,self.play_with_friend.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.profile.xstart,self.profile.ystart,self.profile.width,self.profile.height],border_radius=20)
pygame.draw.rect(self.screen,self.options_color,[self.settings.xstart,self.settings.ystart,self.settings.width,self.settings.height],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.quickplay.xstart+20,self.quickplay.ystart+20,self.quickplay.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.play_with_friend.xstart+20,self.play_with_friend.ystart+20,self.play_with_friend.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.profile.xstart+20,self.profile.ystart+20,self.profile.width-40,200],border_radius=20)
pygame.draw.rect(self.screen,self.icon_background_color,[self.settings.xstart+20,self.settings.ystart+20,self.settings.width-40,200],border_radius=20)
self.screen.blit(self.quickplay_image,(self.quickplay.xstart+25,self.quickplay.ystart))
self.screen.blit(self.play_with_friend_image,(self.play_with_friend.xstart+75,self.play_with_friend.ystart+40))
self.screen.blit(self.profile_image,(self.profile.xstart+85,self.profile.ystart+50))
self.screen.blit(self.settings_image,(self.settings.xstart+85,self.settings.ystart+55))
self.quickplay.title = FONT1.render(self.quickplay.name,True,(255,255,255))
self.quickplay.rect = self.quickplay.title.get_rect()
self.quickplay.description = [FONT2.render("Automatically match with",True,(255,255,255)),FONT2.render("a random player.",True,(255,255,255))]
self.quickplay.d_rect = [self.quickplay.description[0].get_rect(),self.quickplay.description[1].get_rect()]
self.play_with_friend.title = FONT1.render(self.play_with_friend.name,True,(255,255,255))
self.play_with_friend.rect = self.play_with_friend.title.get_rect()
self.play_with_friend.description = [FONT2.render("Invite a friend with",True,(255,255,255)),FONT2.render("game-id/username.",True,(255,255,255))]
self.play_with_friend.d_rect = [self.play_with_friend.description[0].get_rect(),self.play_with_friend.description[1].get_rect()]
self.profile.title = FONT1.render(self.profile.name,True,(255,255,255))
self.profile.rect = self.profile.title.get_rect()
self.profile.description = [FONT2.render("Edit profile,See statistics,",True,(255,255,255)),FONT2.render("Manage friends.",True,(255,255,255))]
self.profile.d_rect = [self.profile.description[0].get_rect(),self.profile.description[1].get_rect()]
self.settings.title = FONT1.render(self.settings.name,True,(255,255,255))
self.settings.rect = self.settings.title.get_rect()
self.settings.description = [FONT2.render("Board/Pieces appearance,",True,(255,255,255)),FONT2.render("Adjust volume,theme,",True,(255,255,255)),FONT2.render("Enable/Disable music.",True,(255,255,255))]
self.settings.d_rect = [self.settings.description[0].get_rect(),self.settings.description[1].get_rect(),self.settings.description[2].get_rect()]
self.quickplay.rect.center = self.text_adjust['quickplay'][0]
self.quickplay.d_rect[0].center = self.text_adjust['quickplay info'][0]
self.quickplay.d_rect[1].center = self.text_adjust['quickplay info'][2]
self.play_with_friend.rect.center = self.text_adjust['play with friend'][0]
self.play_with_friend.d_rect[0].center = self.text_adjust['play with friend info'][0]
self.play_with_friend.d_rect[1].center = self.text_adjust['play with friend info'][2]
self.profile.rect.center = self.text_adjust['profile'][0]
self.profile.d_rect[0].center = self.text_adjust['profile info'][0]
self.profile.d_rect[1].center = self.text_adjust['profile info'][2]
self.settings.rect.center = self.text_adjust['settings'][0]
self.settings.d_rect[0].center = self.text_adjust['settings info'][0]
self.settings.d_rect[1].center = self.text_adjust['settings info'][2]
self.settings.d_rect[2].center = self.text_adjust['settings info'][4]
self.screen.blit(self.quickplay.title,self.quickplay.rect)
self.screen.blit(self.play_with_friend.title,self.play_with_friend.rect)
self.screen.blit(self.profile.title,self.profile.rect)
self.screen.blit(self.settings.title,self.settings.rect)
self.screen.blit(self.quickplay.description[0],self.quickplay.d_rect[0])
self.screen.blit(self.quickplay.description[1],self.quickplay.d_rect[1])
self.screen.blit(self.play_with_friend.description[0],self.play_with_friend.d_rect[0])
self.screen.blit(self.play_with_friend.description[1],self.play_with_friend.d_rect[1])
self.screen.blit(self.profile.description[0],self.profile.d_rect[0])
self.screen.blit(self.profile.description[1],self.profile.d_rect[1])
self.screen.blit(self.settings.description[0],self.settings.d_rect[0])
self.screen.blit(self.settings.description[1],self.settings.d_rect[1])
self.screen.blit(self.settings.description[2],self.settings.d_rect[2])
self.quit_button.draw(self.screen,pygame.mouse.get_pos())
#if self.client.main_page_messsages:
self.get_main_page_messages(pos,events)
if self.client.room_id:
return "game started"
pygame.display.flip()
self.clock.tick(60)
#width,height = 1536,801
#clock = pygame.time.Clock()
#screen = pygame.display.set_mode((width,height))
#Main_menu = Main_menu(screen,clock)
#Main_menu.update()
#pygame.quit()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,670,765
|
Hrishikesh-Padale/SE-Project
|
refs/heads/main
|
/run.py
|
import pygame
from pygame.locals import *
from time import *
import sys
from threading import Thread,Timer
import time
import random
from functions import *
import warnings
from move_functions import Moves_manager, CastleRights
from login_register import Login_Register
from main_menu import *
from configure import *
import os
FONT = pygame.font.SysFont('Arial Bold',80,True)
FONT1 = pygame.font.SysFont('Arial Bold',40,True)
warnings.filterwarnings("ignore")
#1f1f23 - Dark Grey
#9147ff - Purple
#464649 - Grey
class run:
def __init__(self):
self.sign_in = Login_Register()
self.sign_in.window.mainloop()
try:
temp = open("Temp","r")
password = temp.read()
temp.close()
os.remove("Temp")
except:
pass
self.clock = pygame.time.Clock()
self.WSIZE = (0,0)
self.screen = pygame.display.set_mode(self.WSIZE)
self.width, self.height = 1536,801
#self.screen = pygame.display.set_mode((self.width, self.height))
self.running = True
self.icon = pygame.image.load('Media/icon_3.png')
pygame.display.set_icon(self.icon)
pygame.display.set_caption("Chess")
try:
self.main_menu = Main_menu(self.screen,self.clock,password)
except:
sys.exit()
# Parameters -> [game grid created earlier,screen,scale for piece images,piece type]
self.settings = read_settings()
if self.settings:
self.ptype = int(self.settings['Piece Appearance'])
self.ctype = int(self.settings['Board Theme'])
else:
update_settings()
self.settings = read_settings()
self.ptype = int(self.settings['Piece Appearance'])
self.ctype = int(self.settings['Board Theme'])
def init_game(self):
self.Interface = interface(self.width,self.height,self.main_menu.client,self.ctype)
self.Interface.screen = self.screen
self.Interface.generate_board_coordinates()
self.Interface.generate_settings_panel()
self.Interface.generate_killed_pieces_box()
self.Interface.generate_chatbox()
self.Interface.generate_message_input_box()
self.Interface.generate_other_functionalities()
#self.Promoted_Queen = piece('queen', [-1, -1], 'white')
self.Game = game(self.Interface,self.screen,100 if self.ptype == 1 else None,self.ptype,self.main_menu.client.color)
self.Game.load_pieces()
self.Game.moves_manager = Moves_manager(self.Game)
self.Game.init_my_pieces()
self.Game.init_opponent_pieces()
self.Game.get_axes()
self.Game.main_menu = self.main_menu
self.checkmate_text = FONT.render("You Lost",True,(255,0,0))
self.win_text = FONT.render("You won",True,(0,255,0))
self.game_end = False
self.I_won = False
if self.Game.my_piece_color == "White":
self.Game.myprofimg = pygame.image.load('Media/Whiteplayer.png')
self.Game.myprofimg = pygame.transform.scale(self.Game.myprofimg,(260,330))
self.Game.enemyprofimg = pygame.image.load('Media/Blackplayer.png')
self.Game.enemyprofimg = pygame.transform.scale(self.Game.enemyprofimg,(260,330))
else:
self.Game.myprofimg = pygame.image.load('Media/Blackplayer.png')
self.Game.enemyprofimg = pygame.image.load('Media/Whiteplayer.png')
self.Game.myprofimg = pygame.transform.scale(self.Game.myprofimg,(260,330))
self.Game.enemyprofimg = pygame.transform.scale(self.Game.enemyprofimg,(260,330))
self.Game.myname = FONT1.render(self.main_menu.client.uID,True,(0,0,0))
self.Game.enemyname = FONT1.render(self.main_menu.client.enemy_name,True,(0,0,0))
def timer(self):
self.game_end = True
def start(self):
# main loop of the game
while self.running:
self.Game.moves_manager.whiteToMove = self.Game.whiteToMove
self.screen.fill(WHITE)
events = pygame.event.get()
pos = pygame.mouse.get_pos()
for event in events:
if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == K_ESCAPE):
self.running = False
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
col = int((pos[0] - self.Interface.xstart) // (self.Interface.boardwidth // 8))
row = int((pos[1] - self.Interface.ystart) // (self.Interface.boardheight // 8))
print(row,col,pos)
if row <= 7 and col <= 7 and row >= 0 and col >= 0 and self.Game.my_turn:
self.Game.handle_click_event([row, col])
if pos[0]<=1255 and pos[0]>=1115 and pos[1]<=73 and pos[1]>=20:
self.main_menu.settings_object.music = not self.main_menu.settings_object.music
if not self.main_menu.settings_object.music:
self.main_menu.settings_object.stop_music()
else:
self.main_menu.settings_object.play_music()
#print("Music")
elif pos[0]<=1375 and pos[0]>=1275 and pos[1]<=73 and pos[1]>=20:
print("Forfeit")
message = {'ID': 60, 'UserID':self.main_menu.client.uID, 'RoomID':None,'Start':None,'Stop':None, 'MoveNo':None,'Turn':None,'Checkmate':True,'Forfeit':True,'Stalemate':False,'Left':False}
self.main_menu.client.sock.send(pickle.dumps(message))
self.I_won = False
self.running = False
elif pos[0]<=1505 and pos[0]>=1395 and pos[1]<=73 and pos[1]>=20:
message = {'ID': 60, 'UserID':self.main_menu.client.uID, 'RoomID':None,'Start':None,'Stop':None, 'MoveNo':None,'Turn':None,'Checkmate':True,'Forfeit':True,'Stalemate':False,'Left':True}
self.main_menu.client.sock.send(pickle.dumps(message))
self.I_won = False
self.running = False
# update the screen based on events
self.Game.update(pygame.mouse.get_pos())
self.Game.highlight_selected_box()
self.Game.highlight_legal_moves()
self.Game.update_pieces()
self.Game.get_captured_pieces_numbers()
#if self.Interface.chat_panel.selected == "chat":
self.Interface.get_chat_input(events)
self.Interface.print_messages()
if self.Game.opponent_turn and self.Game.opponent_click and not self.Game.opponent_checkmate and not self.Game.opponent_forfeited and not self.Game.opponent_left and not self.Game.moves_manager.stalemate:
self.Game.handle_click_event(self.Game.opponent_click)
self.Game.handle_click_event(self.Game.opponent_coords)
self.Game.opponent_click = []
self.Game.opponent_coords = []
self.Game.opponentclick = []
# If I get checkmated
if self.Game.moves_manager.checkmate:
message = {'ID': 60, 'UserID':self.main_menu.client.uID, 'RoomID':None,'Start':None,'Stop':None, 'MoveNo':None,'Turn':None,'Checkmate':True,'Forfeit':None,'Stalemate':False,'Left':False}
self.main_menu.client.sock.send(pickle.dumps(message))
self.I_won = False
self.running = False
# If opponent forfeits
if self.Game.opponent_forfeited:
self.I_won = True
self.running = False
# If opponent leaves
if self.Game.opponent_left:
self.I_won = True
self.running = False
# If opponent gets checkmated
if self.Game.opponent_checkmate:
self.I_won = True
self.running = False
self.clock.tick(60)
pygame.display.flip()
win_thread = Timer(5.0,self.timer)
win_thread.start()
while not self.game_end:
self.Game.update(pygame.mouse.get_pos())
self.Game.update_pieces()
self.Interface.print_messages()
if self.main_menu.settings_object.music:
self.screen.blit(self.Game.music_on_button, (1125, 35))
else:
self.screen.blit(self.Game.music_off_button,(1120,35))
self.screen.blit(self.Game.forfeit_button, (1285, 35))
self.screen.blit(self.Game.leave_button, (1415, 35))
if self.I_won:
self.screen.blit(self.win_text,(530,350))
else:
self.screen.blit(self.checkmate_text,(530,350))
pygame.display.flip()
self.clock.tick(60)
def run_game(self):
while True:
return_val = self.main_menu.update()
if return_val == "game started":
self.running = True
self.init_game()
self.start()
self.main_menu.client.room_id = None
self.main_menu.client.color = None
#self.Interface.receive_thread.join()
#self.Game.receive_messages.join()
#del self.Interface
#del self.Game
elif return_val == "exit to desktop":
break
return
Run = run()
Run.run_game()
pygame.quit()
|
{"/functions.py": ["/chat_panel.py", "/move_functions.py"], "/run.py": ["/functions.py", "/move_functions.py", "/login_register.py", "/main_menu.py", "/configure.py"], "/login_register.py": ["/configure.py"], "/settings.py": ["/configure.py"], "/move_functions.py": ["/functions.py"], "/main_menu.py": ["/qplay.py", "/pwfriend.py", "/player_profile.py", "/settings.py", "/client_network.py", "/configure.py"]}
|
31,715,332
|
manmadeharp/youtube-django
|
refs/heads/master
|
/setup.py
|
from setuptools import setup
setup(
name='Youtube',
version='',
packages=['youtube', 'youtube.migrations', 'youtube_python'],
url='',
license='',
author='Finbar Cowan',
author_email='',
description=''
)
|
{"/youtube/urls.py": ["/youtube/youtube_python/views.py"]}
|
31,717,834
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/notice/models.py
|
from django.db import models
from django.contrib.auth.models import User
from group.models import Group
notice_choices = (('urgent', 'urgent'),
('not urgent', 'not urgent'))
class Notice(models.Model):
title = models.CharField(max_length=250)
description = models.TextField()
created_date = models.DateTimeField()
expiry_date = models.DateTimeField()
notice_type = models.CharField(max_length=10, choices=notice_choices)
group = models.ForeignKey(Group, on_delete=models.CASCADE)
admin = models.ForeignKey(User, on_delete=models.CASCADE)
def __str__(self):
return self.title
class FavouriteNotice(models.Model):
notice = models.ForeignKey(Notice, on_delete=models.CASCADE)
user_ids = models.ManyToManyField(User)
def __str__(self):
return self.notice.title
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,835
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/core/views.py
|
from django.shortcuts import render
from rest_framework import generics,viewsets
from django.contrib.auth.models import User
from .serializers import UserSerializer
class UserListView(viewsets.ModelViewSet):
queryset = User.objects.all()
serializer_class = UserSerializer
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,836
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/notice/admin.py
|
from django.contrib import admin
from .models import Notice, FavouriteNotice
admin.site.register(Notice)
admin.site.register(FavouriteNotice)
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,837
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/group/admin.py
|
from django.contrib import admin
from .models import Group, LinkUserGroup
admin.site.register(Group)
admin.site.register(LinkUserGroup)
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,838
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/notice/urls.py
|
from django.urls import path,include
from .models import Notice
from .views import NoticeListView, FavNoticeView
from rest_framework import routers
router = routers.DefaultRouter()
router.register('', NoticeListView)
urlpatterns = [
path('',include(router.urls)),
# path('api/details/<int:pk>/', NoticeDetailView.as_view()),
path('core/fav-notices/', FavNoticeView.as_view())
]
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,839
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/group/migrations/0003_auto_20210421_1918.py
|
# Generated by Django 2.2.6 on 2021-04-21 13:33
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('group', '0002_auto_20210412_1656'),
]
operations = [
migrations.RenameField(
model_name='linkusergroup',
old_name='group_id',
new_name='group',
),
migrations.RenameField(
model_name='linkusergroup',
old_name='user_id',
new_name='user',
),
migrations.AlterField(
model_name='group',
name='id',
field=models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID'),
),
migrations.AlterField(
model_name='linkusergroup',
name='id',
field=models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID'),
),
]
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,840
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/notice/migrations/0003_auto_20210421_1918.py
|
# Generated by Django 2.2.6 on 2021-04-21 13:33
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('notice', '0002_alter_notice_id'),
]
operations = [
migrations.AlterField(
model_name='notice',
name='id',
field=models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID'),
),
]
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,841
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/core/urls.py
|
from django.urls import path, include
from rest_framework.authtoken.views import obtain_auth_token
from .views import UserListView
from rest_framework import routers
from rest_framework.documentation import include_docs_urls
# from rest_framework.schemas import get_schema_view
from rest_framework_swagger.views import get_swagger_view
API_TITLE = 'Suchana API'
API_DESCRIPTION = 'A Web API for creating and editing Suchanas.'
schema_view = get_swagger_view(title=API_TITLE)
router = routers.DefaultRouter()
router.register('users', UserListView)
urlpatterns = [
path('',include(router.urls)),
path('api-auth/', include('rest_framework.urls')),
path('api/rest-auth/', include('rest_auth.urls')),
path('docs/', include_docs_urls(title='Suchana API')),
path('swagger-docs/', schema_view),
path('api-token-auth/', obtain_auth_token, name='api_token_auth'),
]
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,842
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/group/urls.py
|
from django.urls import path,include
from .views import GroupListView, join_group
from rest_framework import routers
router = routers.DefaultRouter()
router.register('', GroupListView)
urlpatterns = [
path('',include(router.urls)),
# path('api/details/<int:pk>/', NoticeDetailView.as_view()),
# path('core/join-group/', JoinGroup.as_view())
path('core/join-group/', join_group)
]
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,843
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/classmate/urls.py
|
from django.contrib import admin
from django.urls import path, include
from rest_framework.authtoken.views import obtain_auth_token
urlpatterns = [
path('', include('core.urls')),
path('admin/', admin.site.urls),
path('api/notices/', include('notice.urls')),
path('api/groups/', include('group.urls')),
path('api/rest-auth/registration/', include('rest_auth.registration.urls')),
]
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,844
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/group/models.py
|
from django.db import models
from django.contrib.auth.models import User
class Group(models.Model):
name = models.CharField(max_length=50)
description = models.TextField()
key = models.CharField(max_length=20)
created_date = models.DateTimeField()
admin = models.ForeignKey(User, on_delete=models.CASCADE)
def __str__(self):
return self.name
class LinkUserGroup(models.Model):
group = models.ForeignKey(Group, on_delete=models.CASCADE)
user = models.ForeignKey(User, on_delete=models.CASCADE)
def __str__(self):
return f'{self.group} - {self.user}'
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,845
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/group/serializers.py
|
from django.http import JsonResponse
from rest_framework import serializers
from .models import Group, LinkUserGroup
from django.contrib.auth.models import User
class JoinGroupObj:
def __init__(self, group_key, user_id):
self.group_key = group_key
self.user_id = user_id
class GroupSerializer(serializers.ModelSerializer):
class Meta:
model = Group
fields = '__all__'
# class GroupJoinSerializer(serializers.Serializer):
# Group_key = serializers.CharField(max_length=20)
# user_id = serializers.CharField(max_length=20)
# def create(self,*args, **kwargs):
# pass
# def create(self, validated_data):
# print(validated_data.Group_key, validated_data['user_id'])
# groupKey = validated_data['Group_key']
# groups = Group.objects.all()
# group_keys = [group.key for group in groups]
# user = User.objects.get(id=validated_data['user_id'])
# if groupKey in group_keys:
# group = Group.objects.get(key=groupKey)
# inst = LinkUserGroup.objects.create(group=group, user=user)
# inst.save()
# # return JsonResponse({'status':'success','message':f'{user} is added to {group}'})
# print('user is joined')
# return JoinGroupObj(groupKey, validated_data['user_id'])
# else:
# # return JsonResponse({'status':'error', 'message':'The group do not exist'})
# print(validated_data)
# return JoinGroupObj(groupKey, validated_data['user_id'])
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,846
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/notice/views.py
|
from rest_framework import generics,viewsets
from .models import Notice
from .serializers import NoticeSerializer, FavNoticeSerializer
class NoticeListView(viewsets.ModelViewSet):
queryset = Notice.objects.all()
serializer_class = NoticeSerializer
# class NoticeDetailView(generics.RetrieveAPIView):
# queryset = Notice.objects.all()
# serializer_class = NoticeSerializer
class FavNoticeView(generics.CreateAPIView):
serializer_class = FavNoticeSerializer
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,847
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/notice/serializers.py
|
from rest_framework import serializers
from .models import Notice
class NoticeSerializer(serializers.ModelSerializer):
class Meta:
model = Notice
fields = '__all__'
class FavNoticeSerializer(serializers.Serializer):
user_id = serializers.CharField(max_length=20)
notice_id = serializers.CharField(max_length=20)
def create(self, validated_data):
'''
if user is not in list add user to list
else remove user from list
'''
pass
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,848
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/group/views.py
|
from rest_framework import generics,viewsets, status
from rest_framework.response import Response
from .models import Group
from .serializers import GroupSerializer
class GroupListView(viewsets.ModelViewSet):
queryset = Group.objects.all()
serializer_class = GroupSerializer
# class GroupDetailView(generics.RetrieveAPIView):
# queryset = Group.objects.all()
# serializer_class = GroupSerializer
# class JoinGroup(generics.CreateAPIView):
# serializer_class = GroupJoinSerializer
# def create(self, request, *args, **kwargs):
# response = super().create(request, *args, **kwargs)
# if request.method == 'POST':
# groupKey = form.cleaned_data['group_key']
# groups = Group.objects.all()
# group_keys = [group.key for group in groups]
# if groupKey in group_keys:
# group = Group.objects.get(key=groupKey)
# inst = LinkUserGroup.objects.create(group=group, user=request.user)
# inst.save()
# return Response({
# 'status': 200,
# 'message': 'Testimonials fetched',
# 'data': response.data
# })
# else:
# return Response({
# 'status': 200,
# 'message': 'Testimonials fetched',
# 'data': response.data
# })
# def join_group(request, group_key):
# if request.method == 'POST':
# groupKey = form.cleaned_data['group_key']
# groups = Group.objects.all()
# group_keys = [group.key for group in groups]
# if groupKey in group_keys:
# group = Group.objects.get(key=groupKey)
# inst = LinkUserGroup.objects.create(group=group, user=request.user)
# inst.save()
# serializer = GroupJoinSerializer()
# return Response(serializer.data)
# else:
# return Response(status=status.HTTP_404_NOT_FOUND)
# def join_group(request):
# # if request.method == 'POST':
# # groupKey = form.cleaned_data['group_key']
# # groups = Group.objects.all()
# # group_keys = [group.key for group in groups]
# # if groupKey in group_keys:
# # group = Group.objects.get(key=groupKey)
# # inst = LinkUserGroup.objects.create(group=group, user=request.user)
# # inst.save()
# # return redirect('/')
# # else:
# # print('groupKey do not match with any availabel key')
# # else:
# # form = UserGroupForm()
# # return render(request, 'group/enroll-group.html', {'form': form})
# print(request.body)
def join_group(request):
print(request.body)
if request.method == 'POST':
# groupKey = request.body['group_key']
# find the group key here
groups = Group.objects.all()
group_keys = [group.key for group in groups]
if groupKey in group_keys:
group = Group.objects.get(key=groupKey)
inst = LinkUserGroup.objects.create(group=group, user=request.user)
inst.save()
return Response({
'status': 200,
'message': 'Testimonials fetched',
'data': response.data
})
else:
return Response({
'status': 200,
'message': 'Testimonials fetched',
'data': response.data
})
return None
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,717,849
|
a2subedi/classmate
|
refs/heads/master
|
/classmate/notice/migrations/0004_favouritenotice.py
|
# Generated by Django 2.2.6 on 2021-04-21 14:31
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('notice', '0003_auto_20210421_1918'),
]
operations = [
migrations.CreateModel(
name='FavouriteNotice',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('notice', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='notice.Notice')),
('user_ids', models.ManyToManyField(to=settings.AUTH_USER_MODEL)),
],
),
]
|
{"/classmate/notice/urls.py": ["/classmate/notice/models.py", "/classmate/notice/views.py"], "/classmate/group/urls.py": ["/classmate/group/views.py"], "/classmate/notice/admin.py": ["/classmate/notice/models.py"], "/classmate/group/views.py": ["/classmate/group/models.py", "/classmate/group/serializers.py"], "/classmate/notice/views.py": ["/classmate/notice/models.py", "/classmate/notice/serializers.py"], "/classmate/group/admin.py": ["/classmate/group/models.py"], "/classmate/core/urls.py": ["/classmate/core/views.py"], "/classmate/group/serializers.py": ["/classmate/group/models.py"], "/classmate/notice/serializers.py": ["/classmate/notice/models.py"]}
|
31,810,685
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/migrations/0003_userinfo_depart.py
|
# Generated by Django 3.2 on 2021-06-04 12:50
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('sales', '0002_campuses_classlist_customer_department'),
]
operations = [
migrations.AddField(
model_name='userinfo',
name='depart',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='sales.department'),
),
]
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,686
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/urls.py
|
from django.urls import re_path
from sales.views import customer_views,login_views
app_name = 'sales'
urlpatterns = [
# 登录
re_path('^login/', login_views.login, name='login'),
# 注销
re_path('^logout/', login_views.logout, name='logout'),
# 注册
re_path('^register/', login_views.register, name='register'),
# 首页
re_path('^home/$', customer_views.home, name='home'),
# 用于测试
re_path('^test/$', customer_views.test, name='test'),
# 公户信息展示
re_path('^customers/$', customer_views.Customers.as_view(),name='customers'),
# 私户信息展示
re_path('^mycustomers/$',customer_views.Customers.as_view(),name='mycustomers'),
# 添加客户
re_path('^addcustomer/$',customer_views.addEditCustomer,name='addcustomer'),
# 编辑客户
re_path('^editcustomer/(\d+)/', customer_views.addEditCustomer,name='editcustomer'),
# 跟进记录展示
re_path('^consultrecords/$', customer_views.ConsultRecord.as_view(),name='consultrecords'),
# 添加跟进记录
re_path('^addconsult_record/$',customer_views.addEditConsultRecord,name='addconsult_record'),
# 编辑跟进记录
re_path('^editconsult_record/(\d+)/', customer_views.addEditConsultRecord,name='editconsult_record'),
# 展示报名信息
re_path('^enrollment/', customer_views.Enrollment.as_view(),name='enrollment'),
# 添加报名信息
re_path('^addenrollment/$', customer_views.addEditEnrollment,name='addenrollment'),
# 编辑报名信息
re_path('^editenrollment/(\d+)', customer_views.addEditEnrollment,name='editenrollment'),
# 展示课程记录
re_path('^courserecord/', customer_views.CourseRecord.as_view(),name='courserecord'),
# 添加课程记录
re_path('^addcourse_record/$', customer_views.addEditCourseRecord,name='addcourse_record'),
# 编辑课程记录
re_path('^editcourse_record/(\d+)', customer_views.addEditCourseRecord,name='editcourse_record'),
# 学习记录展示
re_path('^studyrecord/(\d+)', customer_views.StudyRecord.as_view(),name='studyrecord'),
]
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,687
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/views/customer_views.py
|
import copy
from django.shortcuts import render,redirect,HttpResponse
from sales import models
from django.urls import reverse
from sales import myforms
from utils.page_func import Paging
from django.conf import settings
from django.db.models import Q
from django.views import View
# Create your views here.
def home(request):
return render(request,'customer/home.html')
#CBV
class Customers(View):
def get(self,request):
path = request.path
current_page_number = request.GET.get('page') # 当前页码
search_field = request.GET.get('search_field') # 搜索条件
keyword = request.GET.get('keyword') # 搜索数据
recv_data = copy.copy(request.GET) # 处理 This QueryDict instance is immutable错误
# 查询逻辑
if keyword:
q = Q() # 实例化对象
# q.connector = 'or' # 默认是and
q.children.append([search_field + '__contains', keyword]) # Q('name__contains'='陈')
# q.children.append(['name','xx']) #filter(qq='11',name='xx')
all_customer = models.Customer.objects.filter(q)
else:
all_customer = models.Customer.objects.all()
# if path == '/customers/':
if path == reverse('sales:customers'):
tag = 1
# 筛选所有的公户信息
all_customer = all_customer.filter(consultant__isnull=True)
else:
tag = 0
all_customer = all_customer.filter(consultant__username=request.session.get('account'))
total_count = all_customer.count() # 客户数据总数
per_page_num = settings.PER_PAGE_NUM
page_number_show = settings.PAGE_NUMBER_SHOW
page_obj = Paging(current_page_number, total_count, per_page_num, page_number_show, recv_data)
all_customer = all_customer[page_obj.start_data_number:page_obj.end_data_number]
page_html = page_obj.page_html_func
return render(request, 'customer/customers.html',
{'all_customer': all_customer, 'page_html': page_html, 'keyword': keyword,
'search_field': search_field, 'tag': tag})
def post(self,request):
action = request.POST.get('action')
cids = request.POST.getlist('cids')
print(action, cids)
if hasattr(self,action):
ret = getattr(self,action)(request,cids)
print('----',ret,'---',getattr(self,action))
if ret:
return ret
else:
return redirect(request.path)
else:
return HttpResponse('你的方法不对！！')
def bulk_delete(self,request,cids):
customer_list = models.Customer.objects.filter(id__in=cids, consultant__isnull=True)
customer_list.delete()
return redirect(request.path)
def convert_gs(self,request,cids):
from django.db import transaction
with transaction.atomic():
customer_list = models.Customer.objects.select_for_update().filter(id__in=cids, consultant__isnull=True)
if customer_list.count() != len(cids):
return HttpResponse('宝,ni手速太慢了')
user_obj = models.UserInfo.objects.get(username=request.session.get('account'))
customer_list.update(consultant_id=user_obj.id)
def convert_sg(self,request,cids):
customer_list = models.Customer.objects.filter(id__in=cids)
customer_list.update(consultant=None)
def blank(*args,**kwargs):
pass
#合并添加删除客户信息页面
def addEditCustomer(request,n=None): # n 编辑的是那条用用户
old_obj = models.Customer.objects.filter(pk=n).first()
label ='编辑页面' if n else '添加页面'
if request.method == 'GET':
customerInfo_form_obj = myforms.CustomerModelForm(instance=old_obj) # 关键字instance
return render(request, 'customer/editcustomer.html', {'customerInfo_form_obj': customerInfo_form_obj,'label':label})
else:
next_path = request.GET.get('next') # 查询参数都会放入request.GET里面 -- 会反解url编码的地址
# print(next_path,'2222222') # /sales/customers/ 2222222
customerInfo_form_obj = myforms.CustomerModelForm(request.POST,instance=old_obj) # instance=old_obj
if customerInfo_form_obj.is_valid():
customerInfo_form_obj.save()
return redirect(next_path) # /customers/?page=3
# return redirect('customers') # customers/page=3
else:
return render(request, 'customer/editcustomer.html', {'customerInfo_form_obj': customerInfo_form_obj,'label':label})
def test(request):
return render(request,'test.html')
class ConsultRecord(View):
def get(self, request):
current_page_number = request.GET.get('page') # 当前页码
search_field = request.GET.get('search_field') # 搜索条件
keyword = request.GET.get('keyword') # 搜索数据
recv_data = copy.copy(request.GET) # 处理 This QueryDict instance is immutable错误
# 单个客户的id值
customer_id = request.GET.get('customer_id')
# 查询逻辑
if keyword:
q = Q() # 实例化对象
q.children.append([search_field, keyword]) # Q('name__contains'='陈')
# all_records = models.ConsultRecord.objects.filter(customer__name__contains='xxx')
all_records = models.ConsultRecord.objects.filter(q)
else:
all_records = models.ConsultRecord.objects.all()
# delete_status=False 让跟进者看不到，实际上没有删除
# 筛选登陆证自己的记录
all_records = all_records.filter(consultant__username=request.session.get('account'),delete_status=False)
if customer_id:
all_records=all_records.filter(customer_id=customer_id)
total_count = all_records.count() # 客户数据总数
per_page_num = settings.PER_PAGE_NUM
page_number_show = settings.PAGE_NUMBER_SHOW
page_obj = Paging(current_page_number, total_count, per_page_num, page_number_show, recv_data)
all_records = all_records[page_obj.start_data_number:page_obj.end_data_number]
page_html = page_obj.page_html_func
return render(request, 'consult_record/consult_record.html',
{'all_records': all_records, 'page_html': page_html, 'keyword': keyword,
'search_field': search_field})
def post(self, request):
action = request.POST.get('action')
cids = request.POST.getlist('cids')
# print(action, cids)
consult_record_list = models.ConsultRecord.objects.filter(id__in=cids)
if hasattr(self, action):
ret = getattr(self, action)(request, consult_record_list)
if ret:
return ret
else:
return redirect(request.path)
else:
return HttpResponse('你的方法不对！！')
def bulk_delete(self, request, consult_record_list):
consult_record_list.update(delete_status =True)
return redirect(request.path)
def blank(*args, **kwargs):
pass
# 添加和编辑根据记录
def addEditConsultRecord(request,n=None):
old_obj = models.ConsultRecord.objects.filter(pk=n).first()
label ='编辑页面' if n else '添加页面'
if request.method == 'GET':
# next_path = request.get_full_path()
# print(next_path, '----------------') # /sales/consultrecords/
record_from_obj = myforms.ConsultRecordModelForm(request,instance=old_obj) # 关键字instance
return render(request, 'consult_record/addconsult_record.html', {'record_from_obj': record_from_obj, 'label':label})
else:
next_path = request.GET.get('next') # 查询参数都会放入request.GET里面 -- 会反解url编码的地址
# print(next_path,'----------------') # http://127.0.0.1:8000/editconsult_record/?next=/sales/consultrecords/
record_from_obj = myforms.ConsultRecordModelForm(request,request.POST,instance=old_obj) # instance=old_obj
if record_from_obj.is_valid():
record_from_obj.save()
return redirect(next_path)
else:
return render(request, 'consult_record/editconsult_record.html', {'record_from_obj': record_from_obj, 'label':label})
# 报名信息
# def enrollment(request):
#
# if request.method == 'GET':
# enrollments_obj = models.Enrollment.objects.all()
# return render(request,'enrollment_info/enrollment.html',{'enrollments_obj':enrollments_obj})
# if request.method == 'POST':
#CBV 报名信息
class Enrollment(View):
def get(self,request):
current_page_number = request.GET.get('page') # 当前页码
recv_data = copy.copy(request.GET)
enrollments_obj = models.Enrollment.objects.all() # 报名表中的所有信息
search_field = request.GET.get('search_field') # 获取前端传来的查询方法
print(search_field)
keyword = request.GET.get('keyword') # 获取前端传来的查询条件
# print(search_field,keyword)
if search_field == 'stu_name':
enrollments_obj = models.Enrollment.objects.filter(customer__name__contains=keyword)
if search_field == 'stu_class':
enrollments_obj = models.Enrollment.objects.filter(enrolment_class__course__contains=keyword)
total_count = models.Enrollment.objects.all().count()
per_page_num = settings.PER_PAGE_NUM
page_number_show = settings.PAGE_NUMBER_SHOW
page_obj = Paging(current_page_number, total_count, per_page_num, page_number_show, recv_data)
enrollments_obj = enrollments_obj[page_obj.start_data_number:page_obj.end_data_number]
page_html = page_obj.page_html_func
return render(request, 'enrollment_info/enrollment.html',
{'enrollments_obj': enrollments_obj,'page_html':page_html,'search_field':search_field,'keyword':keyword})
# return render(request, 'consult_record/consult_record.html',
# {'all_records': all_records, 'page_html': page_html, 'keyword': keyword,
# 'search_field': search_field})
def post(self, request):
action = request.POST.get('action')
cids = request.POST.getlist('cids')
print(action, cids)
if hasattr(self, action):
ret = getattr(self, action)(cids)
print('----', ret, '---', getattr(self, action))
if ret:
return ret
else:
return redirect(request.path)
else:
return HttpResponse('你的方法不对！！')
def bulk_delete(self,cids):
enrollments_obj = models.Enrollment.objects.filter(id__in=cids)
enrollments_obj.delete()
def blank(*args,**kwargs):
pass
# 添加和编辑根据记录
def addEditEnrollment(request,n=None):
old_obj = models.Enrollment.objects.filter(pk=n).first()
# label = '编辑页面' if n else '添加页面'
if request.method == 'GET':
erollment_from_obj = myforms.EnrollmentModelForm(request,instance=old_obj) # 关键字instance
return render(request, 'enrollment_info/editerollment.html', {'erollment_from_obj': erollment_from_obj})
else:
erollment_from_obj = myforms.EnrollmentModelForm(request,request.POST,instance=old_obj)
if erollment_from_obj.is_valid():
erollment_from_obj.save()
return redirect('sales:enrollment')
else:
return render(request, 'enrollment_info/editerollment.html', {'erollment_from_obj': erollment_from_obj})
# 课程记录
class CourseRecord(View):
def get(self, request):
current_page_number = request.GET.get('page') # 当前页码
search_field = request.GET.get('search_field') # 搜索条件
keyword = request.GET.get('keyword') # 搜索数据
recv_data = copy.copy(request.GET) # 处理 This QueryDict instance is immutable错误
# print(recv_data,'--------') <QueryDict: {'search_field': ['course_title'], 'keyword': ['django'], 'page': ['1']}> --------
# all_course_record = models.CourseRecord.objects.all()
# 查询逻辑
if keyword:
q = Q() # 实例化对象
q.children.append([search_field + '__contains', keyword]) # Q('name__contains'='陈')
# q.children.append(['name','xx']) #filter(qq='11',name='xx')
all_course_record = models.CourseRecord.objects.filter(q)
else:
all_course_record = models.CourseRecord.objects.all()
total_count = all_course_record.count() # 客户数据总数
per_page_num = settings.PER_PAGE_NUM
page_number_show = settings.PAGE_NUMBER_SHOW
page_obj = Paging(current_page_number, total_count, per_page_num, page_number_show, recv_data)
all_course_record = all_course_record[page_obj.start_data_number:page_obj.end_data_number]
page_html = page_obj.page_html_func
return render(request, 'course_record/course_record.html',
{'all_course_record': all_course_record, 'page_html': page_html, 'keyword': keyword,
'search_field': search_field})
def post(self,request):
action = request.POST.get('action')
cids = request.POST.getlist('cids')
# print(action, cids)
if hasattr(self, action):
getattr(self, action)(request, cids)
return redirect('sales:courserecord')
else:
return HttpResponse('你的方法不对！！')
def bulk_delete(self, request, cids):
customer_list = models.CourseRecord.objects.filter(id__in=cids)
customer_list.delete()
# return redirect(request.path)
def bulk_create_studyrecords(self, request, cids):
course_record_list = models.CourseRecord.objects.filter(pk__in=cids)
for course_record in course_record_list:
student_objs = course_record.re_class.customer_set.all().exclude(status='unregistered')
# for student in student_objs:
# models.StudyRecord.objects.create(
# course_record = course_record,
# student = student,
# )
student_list = []
for student in student_objs:
obj = models.StudyRecord(
course_record = course_record,
student = student,
)
student_list.append(obj)
models.StudyRecord.objects.bulk_create(student_list)
def blank(*args, **kwargs):
pass
def addEditCourseRecord(request,n=None):
label = '编辑页面' if n else '添加页面'
# obj = models.CourseRecord.objects.filter(pk=n) # 'QuerySet' object has no attribute '_meta'
obj = models.CourseRecord.objects.filter(pk=n).first()
if request.method == 'GET':
course_form_obj = myforms.CourseRecordModelForm(instance=obj)
return render(request,'course_record/addcourse_record.html',{'course_form_obj':course_form_obj,'label':label})
if request.method == 'POST':
next_path = request.GET.get('next')
course_form_obj = myforms.CourseRecordModelForm(request.POST,instance=obj)
if course_form_obj.is_valid():
course_form_obj.save()
return redirect(next_path)
else:
return render(request, 'course_record/addcourse_record.html', {'course_form_obj': course_form_obj})
from django.forms.models import modelformset_factory
from django import forms
class StudyRecordModelForm(forms.ModelForm):
class Meta:
models = models.StudyRecord
fields = '__all__'
# 学习记录展示
class StudyRecord(View):
def get(self,request,course_id):
formset_obj = modelformset_factory(model=models.StudyRecord,form=StudyRecordModelForm,extra=0)
# formset = formset_obj()
formset = formset_obj(queryset=models.StudyRecord.objects.filter(course_record_id=course_id))
all_study_records = models.StudyRecord.objects.filter(course_record_id=course_id)
return render(request,'course_record/study_record.html',
{'formset':formset})
def post(self,request,course_id):
formset_obj = modelformset_factory(model=models.StudyRecord, form=StudyRecordModelForm, extra=0)
formset = formset_obj(request.POST)
if formset.is_valid():
formset.save()
return redirect(request.path)
else:
return render(request,'course_record/study_record.html',
{'formset': formset})
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,688
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/xx.py
|
# django外部文件使用django环境
# import os
# if __name__ == '__main__': # 配置django环境变量
# os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'Login.settings')
# import django
# django.setup() # 运行django环境变量
#
# from sales import models
# import random
#
# sex_type = (('male', '男性'), ('female', '女性'))
# source_type = (('qq', "qq群"),
# ('referral', "内部转介绍"),
# ('website', "官方网站"),
# ('baidu_ads', "百度推广"),
# ('office_direct', "直接上门"),
# ('WoM', "口碑"),
# ('public_class', "公开课"),
# ('website_luffy', "路飞官网"),
# ('others', "其它"),)
# course_choices = (('LinuxL', 'Linux中高级'),
# ('PythonFullStack', 'Python高级全栈开发'),)
#
# obj_list=[]
# for i in range(250):
# obj = models.Customer(
# qq=f'{i+1}236789',
# name=f'liye{i}',
# sex=random.choice(sex_type)[0],
# source=random.choice(source_type)[1],
# course=random.choice(course_choices)[1],
# )
# obj_list.append(obj)
#
# models.Customer.objects.bulk_create(obj_list)
# page_number_range = range(1,255)
# print(page_number_range,type(page_number_range))
list = [0,1,2,3,4,5,6,7,8,9]
print(list[0:3])
print(list[0:13])
print(list[10:14])
page_html = '<a></a>'
st = 'afa%ssdf' %page_html
print(st)
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,689
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/admin.py
|
from django.contrib import admin
# Register your models here.
from sales import models
class UserInfoAdmin(admin.ModelAdmin):
list_display = ['id','username','telephone']
class CourseRecordAdmin(admin.ModelAdmin):
list_display = ['id','day_num','course_title','re_class','teacher']
list_editable = ['day_num','course_title','re_class','teacher']
class StudentRecordAdmin(admin.ModelAdmin):
list_display = ['id','attendance','score','student',]
list_editable = ['attendance','score','student',]
admin.site.register(models.UserInfo,UserInfoAdmin)
admin.site.register(models.Department)
admin.site.register(models.ClassList)
admin.site.register(models.Campuses)
admin.site.register(models.Customer)
admin.site.register(models.ConsultRecord)
admin.site.register(models.Enrollment) # 报名表
admin.site.register(models.CourseRecord,CourseRecordAdmin)
admin.site.register(models.StudyRecord,StudentRecordAdmin)
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,690
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/tests.py
|
from django.test import TestCase
# Create your tests here.
import os
from pathlib import Path
BASE_DIR = Path(__file__).resolve().parent.parent
print(BASE_DIR)
print(os.path.join(__file__, 'templates'))
dic = {(1,2,3):2}
# dic1 = {[1,2,3]:2}
print(dic[(1,2,3)])
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,691
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/templatetags/mytag.py
|
from django import template
from django.urls import reverse
from django.utils.safestring import mark_safe
register = template.Library()
# 自定义标签，实现不同页面显示不同选项
@register.simple_tag #---------******----------
def show_info(request):
if request.path == reverse('sales:customers'):
return mark_safe('<option value="convert_gs">公户转私户</option>')
else:
return mark_safe('<option value="convert_sg">私户转公户</option>')
'''
{% if request.path == '/customers/' %}
<option value="1">公户转私户</option>
{% else %}
<option value="2">私户转公户</option>
{% endif %}
'''
@register.simple_tag
def reverse_url(url_name,pk,request):
from django.http.request import QueryDict
# /customers/?search_field=qq&keyword=123&page=3
next_path = request.get_full_path()
# print(next_path,'xxxxxx')
query_dict_obj = QueryDict(mutable=QueryDict)
query_dict_obj['next'] = next_path
# print(query_dict_obj) # < QueryDict: {'next': ['/customers/?search_field=qq&keyword=123']} >
encode_url = query_dict_obj.urlencode() # next=%2Fcustomers%2F%3Fsearch_field%3Dqq%26keyword%3D123%26page%3D3
# url编码 / ？ = & 等不安全字符会被替换成%➕对应的assic码
per_path = reverse(url_name,args=(pk,)) # /editcustomer/92/
# full_path = per_path + '?next=' + next_path
full_path = per_path + '?' + encode_url
return full_path
# print(type(request.GET)) # <class 'django.http.request.QueryDict'> request.GET.urlencode()
# # http://127.0.0.1:8000/editcustomer/208/?next=/customers/?search_field=qq&keyword=123&page=3
@register.simple_tag
def reverse_url_add(url_name,request):
from django.http.request import QueryDict
# /sales/consultrecords/
next_path = request.get_full_path()
query_dict_obj = QueryDict(mutable=QueryDict)
query_dict_obj['next'] = next_path
# print(query_dict_obj) # < QueryDict: {'next': ['/sales/consultrecords/']} >
encode_url = query_dict_obj.urlencode() # next=%2Fcustomers%2F%3Fsearch_field%3Dqq%26keyword%3D123%26page%3D3
per_path = reverse(url_name) # /editconsult_record/
# full_path = per_path + '?next=' + next_path
full_path = per_path + '?' + encode_url
return full_path
# http://127.0.0.1:8000/editconsult_record/?next=/sales/consultrecords/
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,692
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/views.py
|
import copy
from django.shortcuts import render,redirect,HttpResponse
from django import forms
from sales import models
from django.http import JsonResponse
from utils.md5_func import md5_function
from django.urls import reverse
from sales import myforms # 添加实现编辑页面
from utils.page_func import Paging
from django.conf import settings
from django.db.models import Q
from django.views import View
# Create your views here.
class RegisterForm(forms.Form):
username = forms.CharField(
max_length=16,
min_length=3,
error_messages={
'max_length':'太长了',
'min_length':'太短了',
'required':'不能为空',
},
widget=forms.TextInput(attrs={'class':'username','placeholder':'用户名',
'autocomplete':'off'})
)
password = forms.CharField(
max_length=32,
min_length=4,
error_messages={
'max_length': '太长了',
'min_length': '太短了',
'required': '不能为空',
},
widget=forms.PasswordInput(attrs={'class':'password','placeholder':'输入密码',
'oncontextmenu':'return false','onpaste':'return false'}),
)
r_password = forms.CharField(
max_length=32,
min_length=4,
error_messages={
'max_length': '太长了',
'min_length': '太短了',
'required': '不能为空',
},
widget=forms.PasswordInput(attrs={'class':'r_password','placeholder':'确认密码',
'oncontextmenu':'return false','onpaste':'return false'}),
)
telephone = forms.CharField(
max_length=11,
min_length=11,
error_messages={
'max_length': '太长了',
'min_length': '太短了',
'required': '不能为空',
},
widget = forms.TextInput(attrs={'class':'phone_number','placeholder':'输入手机号码',
'autocomplete':'off','id':'number'})
)
email = forms.EmailField(
error_messages={
'invalid':'必须是邮箱格式',
'required': '不能为空',
},
widget=forms.EmailInput(attrs={'class':'email','placeholder':'输入邮箱地址','oncontextmenu':'return false',
'onpaste':'return false'})
) # xx@xx
def clean(self):
password = self.cleaned_data.get('password')
r_password = self.cleaned_data.get('r_password')
if password == r_password:
return self.cleaned_data
else:
self.add_error('r_password','两次密码不一致！')
# 注销登录
def logout(request):
request.session.flush() # 清除cookie,删除session
return redirect('/login/')
def login(request):
res_dict = {'status':None,'home':None,'msg':None}
if request.method == 'GET':
return render(request, 'login/login.html')
else:
username = request.POST.get('username')
password = request.POST.get('pwd')
print(username,password)
user_objs = models.UserInfo.objects.filter(username=username,password=md5_function(password))
print(user_objs,password)
print(reverse('home'))
if user_objs:
# 保存当前用户名
request.session['account'] = username
res_dict['status'] = 1
res_dict['home'] = reverse('home') # '/home/'
return JsonResponse(res_dict)
else:
res_dict['status'] = 0
res_dict['msg'] = '用户名或密码错误'
return JsonResponse(res_dict)
def register(request):
if request.method=='GET':
register_obj = RegisterForm()
return render(request, 'login/register.html', {'register_obj':register_obj})
else:
register_obj = RegisterForm(request.POST)
print(request.POST)
if register_obj.is_valid():
print(register_obj.cleaned_data)
register_obj.cleaned_data.pop('r_password')
md5_password = md5_function(register_obj.cleaned_data.get('password'))
register_obj.cleaned_data.update({'password':md5_password}) # ***********
models.UserInfo.objects.create(
**register_obj.cleaned_data
)
return redirect('login')
else:
return render(request, 'login/register.html', {'register_obj':register_obj})
def home(request):
return render(request,'customer/home.html')
#CBV
class Customers(View):
def get(self,request):
# print(request.path) # /customers/
# print(request.get_full_path()) # /customers/?page=3
# print(request.session.get('account')) # alex
path = request.path
current_page_number = request.GET.get('page') # 当前页码
search_field = request.GET.get('search_field') # 搜索条件
keyword = request.GET.get('keyword') # 搜索数据
recv_data = copy.copy(request.GET) # 处理 This QueryDict instance is immutable错误
if keyword:
q = Q() # 实例化对象
# q.connector = 'or' # 默认是and
q.children.append([search_field + '__contains', keyword]) # Q('name__contains'='陈')
# q.children.append(['name','xx']) #filter(qq='11',name='xx')
all_customer = models.Customer.objects.filter(q)
else:
all_customer = models.Customer.objects.all()
if path == '/customers/':
tag = 1
# 筛选所有的公户信息
all_customer = all_customer.filter(consultant__isnull=True)
else:
tag = 0
all_customer = all_customer.filter(consultant__username=request.session.get('account'))
total_count = all_customer.count() # 客户数据总数
per_page_num = settings.PER_PAGE_NUM
page_number_show = settings.PAGE_NUMBER_SHOW
page_obj = Paging(current_page_number, total_count, per_page_num, page_number_show, recv_data)
all_customer = all_customer[page_obj.start_data_number:page_obj.end_data_number]
page_html = page_obj.page_html_func
return render(request, 'customer/customers.html',
{'all_customer': all_customer, 'page_html': page_html, 'keyword': keyword,
'search_field': search_field, 'tag': tag})
def post(self,request):
action = request.POST.get('action')
cids = request.POST.getlist('cids')
customer_list = models.Customer.objects.filter(id__in=cids)
if hasattr(self,action):
ret = getattr(self,action)(request,customer_list)
if ret:
return ret
else:
return redirect(request.path)
else:
return HttpResponse('你的方法不对！！')
def bulk_delete(self,request,customer_list):
customer_list.delete()
return redirect(request.path)
def convert_gs(self,request,customer_list):
user_obj = models.UserInfo.objects.get(username=request.session.get('account'))
print(user_obj)
# user_obj = models.UserInfo.objects.filter(pk=1) # 'QuerySet' object has no attribute 'id' ***
# print(user_obj.filter(pk=1).id)
customer_list.update(consultant_id=user_obj.id) # -------
def convert_sg(self,request,customer_list):
customer_list.update(consultant=None)
def customers(request):
if request.method == 'GET':
path = request.path
current_page_number = request.GET.get('page') #当前页码
search_field = request.GET.get('search_field') #搜索条件
keyword = request.GET.get('keyword') #搜索数据
recv_data = copy.copy(request.GET) # 处理 This QueryDict instance is immutable错误
# print(type(recv_data)) #
# from django.http.request import QueryDict
# models.Customer.objects.filter(Q(name__contains='陈')|Q(qq_contains='11'))
if keyword:
# models.Customer.objects.filter(**{search_field+'__contains':keyword} #name='陈')
q = Q() # 实例化对象
# q.connector = 'or' # 默认是and
q.children.append([search_field+'__contains',keyword]) #Q('name__contains'='陈')
# q.children.append(['name','xx']) #filter(qq='11',name='xx')
all_customer = models.Customer.objects.filter(q)
else:
all_customer = models.Customer.objects.all()
if path == '/customers/':
tag = 1
# 筛选所有的公户信息
all_customer = all_customer.filter(consultant__isnull=True)
else:
tag = 0
# 前登录对象在user_info表里面记录的用户名
# all_customer = all_customer.filter(consultant__username=当前登录对象在user_info表里面记录的用户名)
all_customer = all_customer.filter(consultant__username=request.session.get('account'))
total_count = all_customer.count() # 客户数据总数
per_page_num = settings.PER_PAGE_NUM
page_number_show = settings.PAGE_NUMBER_SHOW
page_obj = Paging(current_page_number,total_count,per_page_num,page_number_show,recv_data)
# all_customer=all_customer[page_obj.start_data_number:page_obj.end_data_number]
all_customer=all_customer[page_obj.start_data_number:page_obj.end_data_number]
page_html = page_obj.page_html_func
return render(request,'customer/customers.html',
{'all_customer':all_customer,'page_html':page_html,'keyword':keyword,'search_field':search_field,'tag':tag})
# else:
# action = request.POST.get('action')
# cids = request.POST.getlist('cids') # 选择的客户 --多选框要使用getlist()
# print(action,cids)
# if action == 'bulk_delete':
# models.Customer.objects.filter(id__in=cids).delete()
#
# elif action == 'convert_gs':
# user_obj = models.UserInfo.objects.filter(username=request.session.get('account'))
# models.Customer.objects.filter(id__in=cids).update(consultant_id=user_obj.id)
#合并添加删除页面
def addEditCustomer(request,n=None): # n 编辑的是那条用用户
old_obj = models.Customer.objects.filter(pk=n).first()
label ='编辑页面' if n else '添加页面'
if request.method == 'GET':
book_form_obj = myforms.CustomerModelForm(instance=old_obj) # 关键字instance
return render(request, 'customer/editcustomer.html', {'book_form_obj': book_form_obj,'label':label})
else:
next_path = request.GET.get('next') # 查询参数都会放入request.GET里面 -- 会反解url编码的地址
print(next_path) # /customers/?search_field=qq
# http://127.0.0.1:8000/editcustomer/208/?next=/customers/?search_field=qq&keyword=123&page=3
book_form_obj = myforms.CustomerModelForm(request.POST,instance=old_obj) # instance=old_obj
if book_form_obj.is_valid():
book_form_obj.save()
return redirect(next_path) # /customers/?page=3
# return redirect('customers') # customers/page=3
else:
return render(request, 'customer/editcustomer.html', {'book_form_obj': book_form_obj,'label':label})
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,693
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/migrations/0004_auto_20210612_2303.py
|
# Generated by Django 3.2 on 2021-06-12 15:03
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('sales', '0003_userinfo_depart'),
]
operations = [
migrations.AlterModelOptions(
name='campuses',
options={'verbose_name': '校区表', 'verbose_name_plural': '校区表'},
),
migrations.AlterField(
model_name='customer',
name='deal_date',
field=models.DateField(blank=True, null=True),
),
]
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,694
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/utils/md5_func.py
|
import hashlib
def md5_function(value):
secret_key = 'username'.encode('utf-8')
ret = hashlib.md5(secret_key)
ret.update(value.encode('utf-8'))
return ret.hexdigest()
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,695
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/myforms.py
|
from sales import models
from django import forms
# Create your component here.
class RegisterForm(forms.Form):
username = forms.CharField(
max_length=16,
min_length=3,
error_messages={
'max_length':'太长了',
'min_length':'太短了',
'required':'不能为空',
},
widget=forms.TextInput(attrs={'class':'username','placeholder':'用户名',
'autocomplete':'off'})
)
password = forms.CharField(
max_length=32,
min_length=4,
error_messages={
'max_length': '太长了',
'min_length': '太短了',
'required': '不能为空',
},
widget=forms.PasswordInput(attrs={'class':'password','placeholder':'输入密码',
'oncontextmenu':'return false','onpaste':'return false'}),
)
r_password = forms.CharField(
max_length=32,
min_length=4,
error_messages={
'max_length': '太长了',
'min_length': '太短了',
'required': '不能为空',
},
widget=forms.PasswordInput(attrs={'class':'r_password','placeholder':'确认密码',
'oncontextmenu':'return false','onpaste':'return false'}),
)
telephone = forms.CharField(
max_length=11,
min_length=11,
error_messages={
'max_length': '太长了',
'min_length': '太短了',
'required': '不能为空',
},
widget = forms.TextInput(attrs={'class':'phone_number','placeholder':'输入手机号码',
'autocomplete':'off','id':'number'})
)
email = forms.EmailField(
error_messages={
'invalid':'必须是邮箱格式',
'required': '不能为空',
},
widget=forms.EmailInput(attrs={'class':'email','placeholder':'输入邮箱地址','oncontextmenu':'return false',
'onpaste':'return false'})
) # xx@xx
def clean(self):
password = self.cleaned_data.get('password')
r_password = self.cleaned_data.get('r_password')
if password == r_password:
return self.cleaned_data
else:
self.add_error('r_password','两次密码不一致！')
class CustomerModelForm(forms.ModelForm):
class Meta:
model = models.Customer
fields = '__all__'
def __init__(self,*args,**kwargs):
super().__init__(*args,**kwargs)
for field_name, field in self.fields.items():
# print(type(field))
from multiselectfield.forms.fields import MultiSelectFormField
#course = MultiSelectField("咨询课程", choices=course_choices)
if not isinstance(field,MultiSelectFormField):
field.widget.attrs.update({'class':'form-control'})
class ConsultRecordModelForm(forms.ModelForm):
# customer = forms.ModelChoiceField(
# queryset=models.Customer.objects.all(), #models foreignkey -- customer
# )
# consultant = forms.ChoiceField( # 覆盖原来的 --- 第一种方法
# choices = (('1','liye'),)
# )
class Meta:
model = models.ConsultRecord
fields = '__all__'
exclude = ['delete_status']
def __init__(self,request,*args,**kwargs):
super().__init__(*args,**kwargs)
for field_name, field in self.fields.items():
if field_name == 'customer':
field.queryset = models.Customer.objects.filter(consultant__username=request.session.get('account'))
if field_name == 'consultant':
# obj = models.UserInfo.objects.filter(username=request.session.get('account')).first()
# field.choices = ((obj.pk,obj.username),) # 第二种方法
field.queryset= models.UserInfo.objects.filter(username=request.session.get('account'))
field.widget.attrs.update({'class':'form-control'})
class EnrollmentModelForm(forms.ModelForm):
class Meta:
model = models.Enrollment
fields = '__all__'
# exclude = ['why_us','your_expectation','contract_approved','memo','delete_status']
def __init__(self,request,*args,**kwargs):
super().__init__(*args,**kwargs)
for field_name, field in self.fields.items():
if field_name == 'customer':
field.queryset = models.Customer.objects.filter(consultant__username=request.session.get('account'))
field.widget.attrs.update({'class':'form-control'})
class CourseRecordModelForm(forms.ModelForm):
class Meta:
model = models.CourseRecord
fields = '__all__'
# exclude = ['why_us','your_expectation','contract_approved','memo','delete_status']
def __init__(self,*args,**kwargs):
super().__init__(*args,**kwargs)
for field_name, field in self.fields.items():
# if field_name == 'customer':
# field.queryset = models.Customer.objects.filter(consultant__username=request.session.get('account'))
field.widget.attrs.update({'class':'form-control'})
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,810,696
|
wencong1724427771/Backend-management-system
|
refs/heads/main
|
/sales/views/login_views.py
|
from django.shortcuts import render,redirect
from sales import models
from django.http import JsonResponse
from utils.md5_func import md5_function
from django.urls import reverse
from sales.myforms import RegisterForm
# Create your views here.
# 注销登录
def logout(request):
request.session.flush() # 清除cookie,删除session
return redirect('sales:login')
def login(request):
res_dict = {'status':None,'home':None,'msg':None}
if request.method == 'GET':
return render(request, 'login/login.html')
else:
username = request.POST.get('username')
password = request.POST.get('pwd')
print(username,password)
user_objs = models.UserInfo.objects.filter(username=username,password=md5_function(password))
if user_objs:
# 保存当前用户名
request.session['account'] = username
res_dict['status'] = 1
res_dict['home'] = reverse('sales:home') # '/home/'
return JsonResponse(res_dict)
else:
res_dict['status'] = 0
res_dict['msg'] = '用户名或密码错误'
return JsonResponse(res_dict)
def register(request):
if request.method=='GET':
register_obj = RegisterForm()
return render(request, 'login/register.html', {'register_obj':register_obj})
else:
register_obj = RegisterForm(request.POST)
print(request.POST)
if register_obj.is_valid():
print(register_obj.cleaned_data)
register_obj.cleaned_data.pop('r_password')
md5_password = md5_function(register_obj.cleaned_data.get('password'))
register_obj.cleaned_data.update({'password':md5_password}) # ***********
models.UserInfo.objects.create(
**register_obj.cleaned_data
)
return redirect('sales:login')
else:
return render(request, 'login/register.html', {'register_obj':register_obj})
|
{"/sales/urls.py": ["/sales/views.py"], "/sales/views/customer_views.py": ["/utils/page_func.py", "/sales/myForms.py"], "/sales/views/login_views.py": ["/rbac/utils/permission_injection.py", "/sales/myForms.py", "/utils/md5_func.py", "/sales/myforms.py"], "/sales/views.py": ["/utils/md5_func.py", "/utils/page_func.py"]}
|
31,852,746
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_all_maximum_projections.py
|
import logging
import math
import re
import subprocess
import traceback
from datetime import datetime
from pathlib import Path
from time import sleep
import cli.log
from generate_maximum_projection import generate_maximum_projection_cli_str
from models.image_filename import *
from models.image_filename_glob import *
from models.paths import *
from models.swarm_job import SwarmJob, shard_job_params
FILES_PER_CALL_COUNT = 2000
MEMORY = 2
class GenerateAllMaximumProjectionsJob:
def __init__(self, source, destination, log):
self.source = source
self.destination = destination
self.logdir = log
self.logger = logging.getLogger()
def run(self):
SwarmJob(
self.source,
self.destination_path,
self.job_name,
self.jobs,
self.logdir,
MEMORY,
FILES_PER_CALL_COUNT
).run()
@property
def jobs(self):
if not hasattr(self, "_jobs"):
image_filename_constraints_shards = shard_job_params(
self.distinct_image_filename_globs,
FILES_PER_CALL_COUNT
)
self._jobs = [
generate_maximum_projection_cli_str(
self.source,
image_filename_constraints_shard,
self.destination
) for image_filename_constraints_shard in image_filename_constraints_shards
]
return self._jobs
@property
def job_name(self):
if not hasattr(self, "_job_name"):
self._job_name = "generate_all_maximum_projections_%s" % datetime.now().strftime("%Y%m%d%H%M%S")
return self._job_name
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.source)
return self._source_path
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
self._destination_path = destination_path(self.destination)
return self._destination_path
@property
def image_file_paths(self):
return self.source_path.rglob(str(ImageFilenameGlob(suffix="", extension="tif")))
@property
def image_filenames(self):
return (ImageFilename.parse(str(image_file_path.relative_to(self.source_path))) for image_file_path in self.image_file_paths)
@property
def distinct_image_filename_globs(self):
if not hasattr(self, "_distinct_image_filename_globs"):
self._distinct_image_filename_globs = set((
ImageFilenameGlob.from_image_filename(image_filename, excluding_keys=["z"])
for image_filename in self.image_filenames
))
return self._distinct_image_filename_globs
@cli.log.LoggingApp
def generate_all_maximum_projections_cli(app):
try:
GenerateAllMaximumProjectionsJob(
app.params.source,
app.params.destination
).run()
except Exception as exception:
traceback.print_exc()
generate_all_maximum_projections_cli.add_param("source")
generate_all_maximum_projections_cli.add_param("destination")
if __name__ == "__main__":
generate_all_maximum_projections_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,747
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_all_spot_positions.py
|
import traceback
from datetime import datetime
import cli.log
import logging
from generate_spot_positions import generate_spot_positions_cli_str
from models.paths import *
from models.swarm_job import SwarmJob, shard_job_params
from models.image_filename import ImageFilename
from models.image_filename_glob import ImageFilenameGlob
FILES_PER_CALL = 20000
MEMORY = 2
class GenerateAllSpotPositionsJob:
def __init__(self, source, destination, log, config=None):
self.source = source
self.destination = destination
self.config = config
self.logdir = log
self.logger = logging.getLogger()
def run(self):
SwarmJob(
self.source,
self.destination_path,
self.job_name,
self.jobs,
self.logdir,
MEMORY,
FILES_PER_CALL
).run()
@property
def jobs(self):
if not hasattr(self, "_jobs"):
nuclear_mask_paths_shards = shard_job_params(self.nuclear_mask_paths, FILES_PER_CALL)
self._jobs = [
generate_spot_positions_cli_str(nuclear_mask_paths_shard, self.destination, self.source, config=self.config)
for nuclear_mask_paths_shard in nuclear_mask_paths_shards
]
return self._jobs
@property
def job_name(self):
if not hasattr(self, "_job_name"):
self._job_name = "generate_all_spot_positions_%s" % datetime.now().strftime("%Y%m%d%H%M%S")
return self._job_name
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.source)
return self._source_path
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
self._destination_path = destination_path(self.destination)
return self._destination_path
@property
def nuclear_mask_paths(self):
return self.source_path.rglob(str(ImageFilenameGlob(suffix="_maximum_projection_nuclear_mask_???", extension="npy")))
@cli.log.LoggingApp
def generate_all_spot_positions_cli(app):
try:
GenerateAllSpotPositionsJob(
app.params.source,
app.params.destination,
app.params.source_dir,
config=app.params.config
).run()
except Exception as exception:
traceback.print_exc()
generate_all_spot_positions_cli.add_param("source")
generate_all_spot_positions_cli.add_param("destination")
generate_all_spot_positions_cli.add_param("source_dir")
generate_all_spot_positions_cli.add_param("--config")
if __name__ == "__main__":
generate_all_spot_positions_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,748
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/models/paths.py
|
from pathlib import Path
def source_path(source):
path = Path(source)
if not path.exists():
raise Exception("source does not exist")
return path
def destination_path(destination):
path = Path(destination)
if not path.exists():
Path.mkdir(path, parents=True)
elif not path.is_dir():
raise Exception("destination already exists, but is not a directory")
return path
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,749
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/models/labels.py
|
def distinct_labels(label_matrix):
distinct_labels_set = set()
for labels_row in label_matrix:
for label in labels_row:
distinct_labels_set.add(label)
distinct_labels_set.remove(0)
return [label for label in distinct_labels_set]
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,750
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_all_cropped_cell_images.py
|
import logging
import traceback
from datetime import datetime
import cli.log
from generate_cropped_cell_image import generate_cropped_cell_image_cli_str
from models.image_filename import ImageFilename
from models.image_filename_glob import ImageFilenameGlob
from models.paths import *
from models.swarm_job import shard_job_params, SwarmJob
FILES_PER_CALL_COUNT = 20000
MEMORY = 1.5
class GenerateAllCroppedCellImagesJob:
def __init__(self, source_images, source_masks, destination, log, DAPI_channel):
self.source_images = source_images
self.source_masks = source_masks
self.destination = destination
self.logdir = log
self.logger = logging.getLogger()
self.DAPI_channel = DAPI_channel
def run(self):
SwarmJob(
self.source_images,
self.destination_path,
self.job_name,
self.jobs,
self.logdir,
MEMORY,
FILES_PER_CALL_COUNT
).run()
@property
def jobs(self):
if not hasattr(self, "_jobs"):
masks = [
(source_image_path, source_mask_path)
for source_image_path in self.source_image_paths
for source_mask_path in self.source_mask_paths_for_source_image_path(source_image_path)
]
shards = shard_job_params(masks, FILES_PER_CALL_COUNT)
self._jobs = [generate_cropped_cell_image_cli_str(shard, self.destination_path, self.source_images, self.source_masks) for shard in shards]
return self._jobs
@property
def job_name(self):
if not hasattr(self, "_job_name"):
self._job_name = "generate_all_cropped_cell_images_%s" % datetime.now().strftime("%Y%m%d%H%M%S")
return self._job_name
@property
def source_images_path(self):
if not hasattr(self, "_source_images_path"):
self._source_images_path = source_path(self.source_images)
return self._source_images_path
@property
def source_masks_path(self):
if not hasattr(self, "_source_masks_path"):
self._source_masks_path = source_path(self.source_masks)
return self._source_masks_path
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
self._destination_path = destination_path(self.destination)
return self._destination_path
@property
def source_image_paths(self):
if not hasattr(self, "_source_image_paths"):
self._source_image_paths = [
image_file_path
for image_file_path
in self.source_images_path.rglob(str(ImageFilenameGlob(suffix="_maximum_projection", extension="tif")))
if ImageFilename.parse(str(image_file_path.relative_to(self.source_images_path))).c != self.DAPI_channel
] + [
z_center_file_path
for z_center_file_path
in self.source_images_path.rglob(str(ImageFilenameGlob(suffix="_z_center", extension="npy")))
if ImageFilename.parse(str(z_center_file_path.relative_to(self.source_images_path))).c != self.DAPI_channel
]
return self._source_image_paths
def source_mask_paths_for_source_image_path(self, source_image_path):
source_image_filename = ImageFilename.parse(str(source_image_path.relative_to(self.source_images_path)))
source_mask_filename_glob = ImageFilenameGlob.from_image_filename(source_image_filename, excluding_keys=["a", "c"])
source_mask_filename_glob.glob.suffix = "_nuclear_mask_???"
source_mask_filename_glob.glob.extension = "npy"
return self.source_masks_path.rglob(str(source_mask_filename_glob))
@cli.log.LoggingApp
def generate_all_cropped_cell_images_cli(app):
try:
GenerateAllCroppedCellImagesJob(
app.params.source_images,
app.params.source_masks,
app.params.destination,
).run()
except Exception as exception:
traceback.print_exc()
generate_all_cropped_cell_images_cli.add_param("source_images")
generate_all_cropped_cell_images_cli.add_param("source_masks")
generate_all_cropped_cell_images_cli.add_param("destination")
if __name__ == "__main__":
generate_all_cropped_cell_images_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,751
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/models/image_name_dictionaries/image_filename_CV.py
|
import re
import logging
LOGGER = logging.getLogger()
IMAGE_FILE_RE = re.compile(
"(?P<experiment>.+)" +
"_" +
"(?P<well>[A-Z]\\d{2})" +
"_" +
"T(?P<t>\\d{4}|XXXX)" +
"F(?P<f>\\d{3}|XXX)" +
"L(?P<l>\\d{2}|XX)" +
"A(?P<a>\\d{2}|XX)" +
"Z(?P<z>\\d{2}|XX)" +
"C(?P<c>\\d{2}|XX)" +
"(?P<suffix>.*)" +
"\\." +
"(?P<extension>.+)"
)
class CVImageFilename:
@classmethod
def parse(cls, image_filename_str):
match = IMAGE_FILE_RE.match(image_filename_str)
if not match:
raise Exception("invalid image filename: %s" % image_filename_str)
return cls(
experiment=match["experiment"],
well=match["well"],
t=(None if match["t"] == "XXXX" else int(match["t"])),
f=(None if match["f"] == "XXX" else int(match["f"])),
l=(None if match["l"] == "XX" else int(match["l"])),
a=(None if match["a"] == "XX" else int(match["a"])),
z=(None if match["z"] == "XX" else int(match["z"])),
c=(None if match["c"] == "XX" else int(match["c"])),
suffix=match["suffix"],
extension=match["extension"],
)
def __init__(self, experiment, well, t, f, l, a, z, c, suffix, extension):
self.experiment = experiment
self.well = well
self.t = t
self.f = f
self.l = l
self.a = a
self.z = z
self.c = c
self.suffix = suffix
self.extension = extension
def __str__(self):
return "%s_%s_T%sF%sL%sA%sZ%sC%s%s.%s" % (
self.experiment,
self.well,
self.t_str,
self.f_str,
self.l_str,
self.a_str,
self.z_str,
self.c_str,
self.suffix,
self.extension
)
def __copy__(self):
return CVImageFilename(
experiment=self.experiment,
well=self.well,
t=self.t,
f=self.f,
l=self.l,
a=self.a,
z=self.z,
c=self.c,
suffix=self.suffix,
extension=self.extension
)
@property
def t_str(self):
return "XXXX" if not self.t else ("%04i" % self.t)
@property
def f_str(self):
return "XXX" if not self.f else ("%03i" % self.f)
@property
def l_str(self):
return "XX" if not self.l else ("%02i" % self.l)
@property
def a_str(self):
return "XX" if not self.a else ("%02i" % self.a)
@property
def z_str(self):
return "XX" if not self.z else ("%02i" % self.z)
@property
def c_str(self):
return "XX" if not self.c else ("%02i" % self.c)
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,752
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_all_nuclear_masks.py
|
import logging
import traceback
from datetime import datetime
import cli.log
from generate_nuclear_masks import generate_nuclear_masks_cli_str
from models.paths import *
from models.swarm_job import SwarmJob, shard_job_params
FILES_PER_CALL_COUNT = 5000
MEMORY = 1.5
class GenerateAllNuclearMasksJob:
def __init__(self, source, destination, log):
self.source = source
self.destination = destination
self.logdir = log
self.logger = logging.getLogger()
def run(self):
SwarmJob(
self.source,
self.destination_path,
self.job_name,
self.jobs,
self.logdir,
MEMORY,
FILES_PER_CALL_COUNT
).run()
@property
def job_name(self):
if not hasattr(self, "_job_name"):
self._job_name = "generate_all_nuclear_masks_%s" % datetime.now().strftime("%Y%m%d%H%M%S")
return self._job_name
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.source)
if not self._source_path.is_dir():
raise Exception("image directory does not exist")
return self._source_path
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
self._destination_path = destination_path(self.destination)
return self._destination_path
@property
def jobs(self):
if not hasattr(self, "_jobs"):
source_filenames_shards = shard_job_params(self.source_filenames, FILES_PER_CALL_COUNT)
self._jobs = [
generate_nuclear_masks_cli_str(source_filenames_shard, self.destination, self.source)
for source_filenames_shard in source_filenames_shards
]
return self._jobs
@property
def source_filenames(self):
return self.source_path.rglob("*_nuclear_segmentation.npy")
@cli.log.LoggingApp
def generate_all_nuclear_masks(app):
try:
GenerateAllNuclearMasksJob(
app.params.source,
app.params.destination,
).run()
except Exception as exception:
traceback.print_exc()
generate_all_nuclear_masks.add_param("source")
generate_all_nuclear_masks.add_param("destination")
if __name__ == "__main__":
generate_all_nuclear_masks.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,753
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/models/swarm_job.py
|
import logging
import math
import os
import shlex
import subprocess
import enum
from time import sleep
LOGGER = logging.getLogger()
MAX_ARGS_PER_JOB = 10000
def shard_job_params(job_params, files_count):
job_params_list = list(job_params)
job_params_count = len(job_params_list)
params_per_job = min(files_count, MAX_ARGS_PER_JOB)
shards_count_sanitized = math.ceil(job_params_count/params_per_job)
small_shard_job_params_count = math.floor(job_params_count / shards_count_sanitized)
large_shard_job_params_count = small_shard_job_params_count + 1
large_shards_count = job_params_count % shards_count_sanitized
next_shard_start_index = 0
for i in range(min(shards_count_sanitized, job_params_count)):
shard_jobs_count = large_shard_job_params_count if i < large_shards_count else small_shard_job_params_count
shard_end_index = next_shard_start_index + shard_jobs_count
yield job_params_list[next_shard_start_index:shard_end_index]
next_shard_start_index = shard_end_index
class RunStrategy(enum.Enum):
LOCAL = enum.auto()
SWARM = enum.auto()
class SwarmJob:
run_strategy = RunStrategy.SWARM if os.environ.get('ENVIRONMENT') == 'production' else RunStrategy.LOCAL
file_type = "LSM" if os.environ.get('FILE_TYPE') == "LSM" else "CV"
def __init__(self, source, destination_path, name, jobs, logdir, mem, files_count):
self.source = source
self.destination_path = destination_path
self.name = name
self.jobs = jobs
self.mem = mem
self.logdir = logdir
self.bundling = math.ceil(files_count/MAX_ARGS_PER_JOB)
def run(self):
if self.run_strategy == RunStrategy.LOCAL:
LOGGER.warning("running %s in development mode", self.name)
for job in self.jobs:
LOGGER.warning("command: %s", job)
subprocess.run(shlex.split(job)).check_returncode()
return
self.generate_file()
self.start()
while not self.is_complete():
LOGGER.warning("job not complete yet")
sleep(20)
def start(self):
command = [
"swarm",
"--module", "python/3.8",
"-f", self.swarm_file_path,
"--job-name", self.name,
"-g", str(self.mem),
"--logdir", str(self.logdir),
"-b", str(self.bundling),
"--sbatch", self.export_string
]
LOGGER.warning(command)
subprocess.run(command).check_returncode()
def is_complete(self):
command = ["squeue", "-n", self.name, "-o", "%T", "-t", "all", "-h"]
LOGGER.warning(command)
sjobs_result = subprocess.run(command, capture_output=True, text=True)
sjobs_result.check_returncode()
result_lines = sjobs_result.stdout.splitlines()
LOGGER.warning("squeue result: %s", result_lines)
if(any((result_line == "FAILED" for result_line in result_lines))):
return True
else:
return all((result_line == "COMPLETED" for result_line in result_lines))
def generate_file(self):
with self.swarm_file_path.open("w") as swarm_file:
for job in self.jobs:
swarm_file.write("%s\n" % job)
@property
def swarm_file_path(self):
if not hasattr(self, "_swarm_file_path"):
self._swarm_file_path = self.destination_path / ("%s.swarm" % self.name)
return self._swarm_file_path
@property
def export_string(self):
if not hasattr(self, "_export_string"):
self._export_string = '"\"--export=MKL_NUM_THREADS=2,FILE_TYPE=\"%s\"\""' % self.file_type
return self._export_string
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,754
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_maximum_projection.py
|
import shlex
import logging
import re
import traceback
from pathlib import Path
import cli.log
import numpy
import skimage.exposure
import skimage.io
from models.paths import *
from models.z_sliced_image import ZSlicedImage
class GenerateMaximumProjectionJob:
def __init__(self, source_directory, filename_pattern, destination):
self.source_directory = source_directory
self.filename_pattern = filename_pattern
self.destination = destination
self.logger = logging.getLogger()
def run(self):
skimage.io.imsave(str(self.destination_path / self.maximum_projection_destination_filename), self.maximum_projection)
numpy.save(str(self.destination_path / self.z_center_destination_filename), self.z_center)
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
self._destination_path = destination_path(self.destination)
return self._destination_path
@property
def source_directory_path(self):
if not hasattr(self, "_source_directory_path"):
self._source_directory_path = source_path(self.source_directory)
if not self._source_directory_path.is_dir():
raise Exception("image directory does not exist")
return self._source_directory_path
@property
def source_file_paths(self):
print("looking for source files with pattern %s"%self.filename_pattern)
return self.source_directory_path.rglob(self.filename_pattern)
@property
def maximum_projection(self):
if not hasattr(self, "_maximum_projection"):
self.process_source_z_sliced_images()
return self._maximum_projection
@property
def z_center(self):
if not hasattr(self, "_z_center"):
self.process_source_z_sliced_images()
return self._z_center
def process_source_z_sliced_images(self):
if hasattr(self, "_z_center") or hasattr(self, "_maximum_projection"):
raise Exception("already computed")
shaped = False
maximum_projection = None
summed_z_values = None
weighted_summed_z_values = None
for source_z_sliced_image in self.source_z_sliced_images:
if not shaped:
shaped = True
maximum_projection = numpy.zeros_like(source_z_sliced_image.image)
summed_z_values = numpy.int32(numpy.zeros_like(source_z_sliced_image.image))
weighted_summed_z_values = numpy.int32(numpy.zeros_like(source_z_sliced_image.image))
maximum_projection = numpy.fmax(maximum_projection, source_z_sliced_image.image)
summed_z_values = summed_z_values + source_z_sliced_image.image
weighted_summed_z_values = weighted_summed_z_values + (source_z_sliced_image.image * source_z_sliced_image.z)
self._maximum_projection = maximum_projection
zero_adjusted_summed_z_values = summed_z_values + ((summed_z_values == 0) * numpy.ones_like(summed_z_values))
zero_adjusted_weighted_summed_z_values = weighted_summed_z_values + ((weighted_summed_z_values == 0) * numpy.ones_like(weighted_summed_z_values))
self._z_center = (zero_adjusted_weighted_summed_z_values / zero_adjusted_summed_z_values).astype(numpy.float16)
@property
def source_z_sliced_images(self):
return (ZSlicedImage(source_file_path, self.source_directory_path) for source_file_path in self.source_file_paths)
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
global_destination_path = Path(self.destination)
local_destination_path = Path(self.filename_pattern).parents[0]
self._destination_path = global_destination_path / local_destination_path
if not self._destination_path.exists():
Path.mkdir(self._destination_path, parents=True)
elif not self._destination_path.is_dir():
raise Exception("destination already exists, but is not a directory")
return self._destination_path
@property
def destination_filename_prefix(self):
return Path(self.filename_pattern.replace("?", "X").replace("*", "X")).stem
@property
def maximum_projection_destination_filename(self):
return "%s%s" % (self.destination_filename_prefix, "_maximum_projection.tif")
@property
def z_center_destination_filename(self):
return "%s%s" % (self.destination_filename_prefix, "_z_center")
def generate_maximum_projection_cli_str(source_directory, filename_patterns, destination):
return shlex.join([
"pipenv",
"run",
"python",
__file__,
"--destination=%s" % destination,
"--source_directory=%s" % source_directory,
*(str(filename_pattern) for filename_pattern in filename_patterns)
])
@cli.log.LoggingApp
def generate_maximum_projection_cli(app):
for filename_pattern in app.params.filename_patterns:
try:
GenerateMaximumProjectionJob(
app.params.source_directory,
filename_pattern,
app.params.destination
).run()
except Exception as exception:
traceback.print_exc()
generate_maximum_projection_cli.add_param("--source_directory", required=True)
generate_maximum_projection_cli.add_param("--destination", required=True)
generate_maximum_projection_cli.add_param("filename_patterns", nargs="*")
if __name__ == "__main__":
generate_maximum_projection_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,755
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_spot_positions.py
|
import json
import logging
import shlex
import traceback
from copy import copy
from pathlib import Path
from functools import lru_cache
import cli.log
import numpy
import scipy.ndimage
import skimage.feature
import skimage.measure
import skimage.filters
import skimage.io
import skimage.segmentation
from models.generate_spot_positions_config import GenerateSpotPositionsConfig
from models.image_filename import ImageFilename
from models.paths import *
@lru_cache(maxsize=1)
def load_generate_spot_positions_configs(config_path):
if config_path == None:
return {}
with open(config_path) as json_file:
json_params_list = json.load(json_file)
generate_spot_positions_configs = [
GenerateSpotPositionsConfig.from_json_params(json_params)
for json_params in json_params_list
]
return {
generate_spot_positions_config.channel:generate_spot_positions_config
for generate_spot_positions_config in generate_spot_positions_configs
}
class GenerateSpotPositionsJob:
def __init__(
self,
source,
destination,
source_dir,
user_determined_local_contrast_threshold=None,
user_determined_radius=None,
user_determined_global_threshold=None,
config=None
):
self.source = source
self.destination = destination
self.source_dir = Path(source_dir)
self.user_determined_local_contrast_threshold = user_determined_local_contrast_threshold
self.user_determined_radius = user_determined_radius
self.user_determined_global_threshold = user_determined_global_threshold
self.config = config
self.logger = logging.getLogger()
def run(self):
for spot_index, spot in enumerate(self.spots):
numpy.save(self.destination_filename_for_spot_index(spot_index), spot)
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
global_destination_path = Path(self.destination)
local_destination_path = Path(str(self.source_path.relative_to(self.source_dir))).parents[0]
path_to_make = global_destination_path / local_destination_path
self._destination_path = global_destination_path
if not path_to_make.exists():
Path.mkdir(path_to_make, parents=True)
elif not path_to_make.is_dir():
raise Exception("destination already exists, but is not a directory")
return self._destination_path
def destination_filename_for_spot_index(self, spot_index):
destination_image_filename = copy(self.source_image_filename)
nucleus_index = self.source_image_filename.suffix.split("_")[-1]
destination_image_filename.suffix = "_nucleus_%s_spot_%i" % (nucleus_index, spot_index)
return self.destination_path / str(destination_image_filename)
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.source)
return self._source_path
@property
def source_image_filename(self):
if not hasattr(self, "_source_image_filename"):
self._source_image_filename = ImageFilename.parse(str(self.source_path.relative_to(self.source_dir)))
return self._source_image_filename
@property
def threshold(self):
if not hasattr(self, "_threshold"):
self._threshold = self.image_background * self.local_contrast_threshold
return self._threshold
@property
def image(self):
if not hasattr(self, "_image"):
self._image = numpy.load(self.source_path, allow_pickle=True)
return self._image
@property
def filtered_image(self):
if not hasattr(self, "_filtered_image"):
self._filtered_image = skimage.filters.gaussian(self.image, sigma=self.peak_radius)
return self._filtered_image
@property
def raw_spots(self):
if not hasattr(self, "_raw_spots"):
self._raw_spots = skimage.feature.blob_log(self.filtered_image, min_sigma=0.3, max_sigma=0.3, threshold=self.threshold)
return self._raw_spots
@property
def global_filtered_spots(self):
if not hasattr(self, "_global_filtered_spots"):
self._global_filtered_spots = [
(int(x), int(y))
for x, y, _sigma
in self.raw_spots
if self.image[int(x), int(y)] > self.global_contrast_threshold
]
return self._global_filtered_spots
@property
def spots(self):
if not hasattr(self, "_spots"):
self._spots = [
self.find_spot_props(spot)
for spot
in self.global_filtered_spots
]
return self._spots
def find_spot_props(self, integer_spot):
local_box_x_min = max(0, integer_spot[0]-10)
local_box_y_min = max(0, integer_spot[1]-10)
local_box_x_max = min(integer_spot[0]+10, numpy.shape(self.image)[0])
local_box_y_max = min(integer_spot[1]+10, numpy.shape(self.image)[1])
local_background = numpy.percentile(self.image[local_box_x_min:local_box_x_max, local_box_y_min:local_box_y_max], 25)
marker = skimage.segmentation.flood(
self.image,
integer_spot,
tolerance=(self.image[integer_spot] - local_background) / 2
)
marker_int = marker.astype(numpy.uint8)
props = skimage.measure.regionprops(marker_int, self.image)
cog = scipy.ndimage.center_of_mass(self.image, marker)
props_list = (cog, props[0].area, props[0].eccentricity, props[0].solidity)
return props_list
#return scipy.ndimage.center_of_mass(self.image, marker)
@property
def image_background(self):
if not hasattr(self, "_image_background"):
self._image_background = numpy.percentile(self.image, 75)
return self._image_background
@property
def local_contrast_threshold(self):
if self.user_determined_local_contrast_threshold != None:
return self.user_determined_local_contrast_threshold
if self.channel_specific_config != None:
return self.channel_specific_config.local_contrast_threshold
if self.source_image_filename.c == 3:
return 4
return 2.75
@property
def peak_radius(self):
if self.user_determined_radius != None:
return self.user_determined_radius
if self.channel_specific_config != None:
return self.channel_specific_config.peak_radius
if self.source_image_filename.c == 3:
return 3
return 1
@property
def global_contrast_threshold(self):
if self.user_determined_global_threshold != None:
return self.user_determined_global_threshold
if self.channel_specific_config != None:
return self.channel_specific_config.global_contrast_threshold
return 0
@property
def channel_specific_config(self):
if self.config != None:
configs = load_generate_spot_positions_configs(self.config)
if self.source_image_filename.c in configs:
return configs[self.source_image_filename.c]
def generate_spot_positions_cli_str(sources, destination, source_dir, config=None):
config_arguments = ["--config=%s" % config] if config != None else []
return shlex.join([
"pipenv",
"run",
"python",
__file__,
"--destination=%s" % destination,
"--source_dir=%s" % source_dir,
*config_arguments,
*[str(source) for source in sources]
])
@cli.log.LoggingApp
def generate_spot_positions_cli(app):
for source in app.params.sources:
try:
GenerateSpotPositionsJob(
source,
app.params.destination,
app.params.source_dir,
config=app.params.config
).run()
except Exception as exception:
traceback.print_exc()
generate_spot_positions_cli.add_param("sources", nargs="*")
generate_spot_positions_cli.add_param("--destination", required=True)
generate_spot_positions_cli.add_param("--source_dir", required=True)
generate_spot_positions_cli.add_param("--config")
if __name__ == "__main__":
generate_spot_positions_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,756
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_cropped_cell_image.py
|
import re
import shlex
import traceback
from copy import copy
from functools import lru_cache
import cli.log
import matplotlib.pyplot as plt
import numpy
import skimage.io
import skimage.measure
import skimage.util
from models.image_filename import ImageFilename
from models.nuclear_mask import NuclearMask
from models.paths import *
@lru_cache(maxsize=1)
def load_source_image(source_image_path):
if source_image_path.suffix == ".tif":
return skimage.io.imread(source_image_path)
else:
return numpy.load(source_image_path, allow_pickle=True)
class GenerateCroppedCellImageJob:
def __init__(self, source_image, source_mask, destination, source_image_dir, source_mask_dir):
self.source_image = source_image
self.source_mask = source_mask
self.destination = destination
self.source_image_dir = Path(source_image_dir)
self.source_mask_dir = Path(source_mask_dir)
def run(self):
numpy.save(self.destination_filename, self.masked_cropped_image)
@property
def destination_filename(self):
return self.destination_path / str(self.destination_image_filename)
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
global_destination_path = Path(self.destination)
local_destination_path = Path(str(self.source_image_path.relative_to(self.source_image_dir))).parents[0]
path_to_make = global_destination_path / local_destination_path
self._destination_path = global_destination_path
if not path_to_make.exists():
Path.mkdir(path_to_make, parents=True)
elif not path_to_make.is_dir():
raise Exception("destination already exists, but is not a directory")
return self._destination_path
@property
def destination_image_filename(self):
if not hasattr(self, "_destination_image_filename"):
self._destination_image_filename = copy(self.source_image_filename)
self._destination_image_filename.suffix = self.destination_suffix
self._destination_image_filename.extension = "npy"
return self._destination_image_filename
@property
def source_image_path(self):
if not hasattr(self, "_source_image_path"):
self._source_image_path = source_path(self.source_image)
return self._source_image_path
@property
def source_mask_path(self):
if not hasattr(self, "_source_mask_path"):
self._source_mask_path = source_path(self.source_mask)
return self._source_mask_path
@property
def source_image_filename(self):
if not hasattr(self, "_source_image_filename"):
self._source_image_filename = ImageFilename.parse(str(self.source_image_path.relative_to(self.source_image_dir)))
return self._source_image_filename
@property
def source_image_suffix(self):
return self.source_image_filename.suffix
@property
def source_mask_suffix(self):
if not hasattr(self, "_source_mask_suffix"):
self._source_mask_suffix = ImageFilename.parse(str(self.source_mask_path.relative_to(self.source_mask_dir))).suffix
return self._source_mask_suffix
@property
def destination_suffix(self):
if not hasattr(self, "_destination_suffix"):
self._destination_suffix = self.source_image_suffix + self.source_mask_suffix
return self._destination_suffix
@property
def mask(self):
if not hasattr(self, "_mask"):
self._mask = numpy.load(self.source_mask_path, allow_pickle=True).item()
return self._mask
@property
def nuclear_mask(self):
return self.mask.mask
@property
def nuclear_offset(self):
return self.mask.offset
@property
def image(self):
if not hasattr(self, "_image"):
self._image = load_source_image(self.source_image_path)
return self._image
@property
def rect_cropped_image(self):
if not hasattr(self, "_rect_cropped_image"):
[min_row, min_column] = self.nuclear_offset
[rows_count, columns_count] = numpy.shape(self.nuclear_mask)
self._rect_cropped_image = self.image[min_row:(min_row + rows_count), min_column:(min_column + columns_count)]
return self._rect_cropped_image
@property
def min_in_nucleus(self):
if not hasattr(self, "_min_in_nucleus"):
self._min_in_nucleus = numpy.amin(self.rect_cropped_image, where=self.nuclear_mask, initial=100000)
return self._min_in_nucleus
@property
def max_in_nucleus(self):
if not hasattr(self, "_max_in_nucleus"):
self._max_in_nucleus = numpy.amax(self.rect_cropped_image, where=self.nuclear_mask, initial=0)
return self._max_in_nucleus
@property
def masked_cropped_image(self):
if not hasattr(self, "_masked_cropped_image"):
if self.source_image_filename.extension == "tif":
normed_image = skimage.exposure.rescale_intensity(self.rect_cropped_image, in_range=(self.min_in_nucleus, self.max_in_nucleus), out_range=(0,1))
self._masked_cropped_image = normed_image * self.nuclear_mask
else:
self._masked_cropped_image = self.rect_cropped_image * self.nuclear_mask
return self._masked_cropped_image
def generate_cropped_cell_image_cli_str(masks, destination, source_images_dir, source_masks_dir):
serialized_masks_params = (str(param) for image_or_mask_param in masks for param in image_or_mask_param)
return shlex.join([
"pipenv",
"run",
"python",
__file__,
"--destination=%s" % destination,
"--source_images_dir=%s" % source_images_dir,
"--source_masks_dir=%s" % source_masks_dir,
*serialized_masks_params
])
@cli.log.LoggingApp
def generate_cropped_cell_image_cli(app):
for mask_pair_start_index in (index * 2 for index in range(int(len(app.params.masks) / 2))):
source_image, source_mask = app.params.masks[mask_pair_start_index:mask_pair_start_index + 2]
try:
GenerateCroppedCellImageJob(
source_image,
source_mask,
app.params.destination,
app.params.source_images_dir,
app.params.source_masks_dir,
).run()
except Exception as exception:
traceback.print_exc()
generate_cropped_cell_image_cli.add_param("masks", nargs="*")
generate_cropped_cell_image_cli.add_param("--destination", required=True)
generate_cropped_cell_image_cli.add_param("--source_images_dir", required=True)
generate_cropped_cell_image_cli.add_param("--source_masks_dir", required=True)
if __name__ == "__main__":
generate_cropped_cell_image_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,757
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_all_distance_transforms.py
|
import traceback
from datetime import datetime
import cli.log
import logging
from generate_distance_transform import generate_distance_transform_cli_str
from models.paths import *
from models.swarm_job import SwarmJob, shard_job_params
FILES_PER_CALL_COUNT = 50000
MEMORY = 1.5
class GenerateAllDistanceTransformsJob:
def __init__(self, source, destination, log):
self.source = source
self.destination = destination
self.logdir = log
self.logger = logging.getLogger()
def run(self):
SwarmJob(
self.source,
self.destination_path,
self.job_name,
self.jobs,
self.logdir,
MEMORY,
FILES_PER_CALL_COUNT
).run()
@property
def jobs(self):
if not hasattr(self, "_jobs"):
shards = shard_job_params(self.nuclear_mask_paths, FILES_PER_CALL_COUNT)
self._jobs = [
generate_distance_transform_cli_str(shard, self.destination, self.source) for shard in shards
]
return self._jobs
@property
def job_name(self):
if not hasattr(self, "_job_name"):
self._job_name = "generate_all_distance_transforms_%s" % datetime.now().strftime("%Y%m%d%H%M%S")
return self._job_name
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.source)
return self._source_path
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
self._destination_path = destination_path(self.destination)
return self._destination_path
@property
def nuclear_mask_paths(self):
return self.source_path.rglob("*_nuclear_mask_???.npy")
@cli.log.LoggingApp
def generate_all_distance_transforms_cli(app):
try:
GenerateAllDistanceTransformsJob(
app.params.source,
app.params.destination,
).run()
except Exception as exception:
traceback.print_exc()
generate_all_distance_transforms_cli.add_param("source")
generate_all_distance_transforms_cli.add_param("destination")
if __name__ == "__main__":
generate_all_distance_transforms_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,758
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_distance_transform.py
|
import copy
import logging
import shlex
import traceback
import cli.log
import numpy
from scipy import ndimage
from models.paths import *
class GenerateDistanceTransformJob:
def __init__(self, source, destination, source_dir):
self.source = source
self.destination = destination
self.source_dir = Path(source_dir)
def run(self):
numpy.save(self.destination_filename, self.distance_transform)
@property
def destination_filename(self):
source_relative_path = str(self.source_path.relative_to(self.source_dir))
return self.destination_path / source_relative_path.replace("_nuclear_mask_", "_distance_transform_")
@property
def distance_transform(self):
if not hasattr(self, "_distance_transform"):
raw_transform = ndimage.distance_transform_edt(self.nuclear_mask)
normed_transform = raw_transform/numpy.amax(raw_transform)
self._distance_transform = 1 - normed_transform
return self._distance_transform
@property
def nuclear_mask(self):
if not hasattr(self, "_nuclear_mask"):
self._nuclear_mask = numpy.load(self.source_path, allow_pickle=True).item().mask
return self._nuclear_mask
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
global_destination_path = Path(self.destination)
local_destination_path = Path(str(self.source_path.relative_to(self.source_dir))).parents[0]
path_to_make = global_destination_path / local_destination_path
self._destination_path = global_destination_path
if not path_to_make.exists():
Path.mkdir(path_to_make, parents=True)
elif not path_to_make.is_dir():
raise Exception("destination already exists, but is not a directory")
return self._destination_path
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.source)
return self._source_path
def generate_distance_transform_cli_str(sources, destination, source_dir):
return shlex.join([
"pipenv",
"run",
"python",
__file__,
"--destination=%s" % destination,
"--source_dir=%s" % source_dir,
*[str(source) for source in sources]
])
@cli.log.LoggingApp
def generate_distance_transform_cli(app):
for source in app.params.sources:
try:
GenerateDistanceTransformJob(
source,
app.params.destination,
app.params.source_dir,
).run()
except Exception as exception:
traceback.print_exc()
generate_distance_transform_cli.add_param("sources", nargs="*")
generate_distance_transform_cli.add_param("--destination", required=True)
generate_distance_transform_cli.add_param("--source_dir", required=True)
if __name__ == "__main__":
generate_distance_transform_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,759
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_all_nuclear_segmentations.py
|
import cli.log
from datetime import datetime
import traceback
from pathlib import Path
import logging
from generate_nuclear_segmentation import generate_nuclear_segmentation_cli_str
from models.paths import *
from models.swarm_job import SwarmJob, shard_job_params
from models.image_filename_glob import ImageFilenameGlob
FILES_PER_CALL_COUNT = 10
MEMORY = 8
class GenerateAllNuclearSegmentationsJob:
def __init__(self, source, destination, log, diameter, DAPI_channel=1):
self.source = source
self.destination = destination
self.diameter = diameter
self.logdir = log
self.DAPI = DAPI_channel
self.logger = logging.getLogger()
def run(self):
SwarmJob(
self.source,
self.destination_path,
self.job_name,
self.jobs,
self.logdir,
MEMORY,
FILES_PER_CALL_COUNT
).run()
@property
def jobs(self):
if not hasattr(self, "_jobs"):
source_filenames_shards = shard_job_params(self.source_filenames, FILES_PER_CALL_COUNT)
self._jobs = [
generate_nuclear_segmentation_cli_str(source_filenames_shard, self.destination, self.source, self.diameter)
for source_filenames_shard in source_filenames_shards
]
return self._jobs
@property
def job_name(self):
if not hasattr(self, "_job_name"):
self._job_name = "generate_all_nuclear_segmentations_%s" % datetime.now().strftime("%Y%m%d%H%M%S")
return self._job_name
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.source)
if not self._source_path.is_dir():
raise Exception("image directory does not exist")
return self._source_path
@property
def source_filenames(self):
return self.source_path.rglob(str(ImageFilenameGlob(c=self.DAPI, suffix="_maximum_projection", extension="tif")))
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
self._destination_path = destination_path(self.destination)
return self._destination_path
@cli.log.LoggingApp
def generate_all_nuclear_segmentations(app):
try:
GenerateAllNuclearSegmentationsJob(
app.params.source,
app.params.destination,
app.params.diameter
).run()
except Exception as exception:
traceback.print_exc()
generate_all_nuclear_segmentations.add_param("source")
generate_all_nuclear_segmentations.add_param("destination")
generate_all_nuclear_segmentations.add_param("--diameter", type=int)
if __name__ == "__main__":
generate_all_nuclear_segmentations.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,760
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/models/z_sliced_image.py
|
import numpy
import skimage.io
from models.image_filename import ImageFilename
class ZSlicedImage:
def __init__(self, path, source):
self.path = path
self.source_dir = source
@property
def image(self):
if not hasattr(self, "_image"):
raw_image = skimage.io.imread(self.path)
if len(raw_image.shape) != 2:
self._image = raw_image[:, :, 0]
else:
self._image = raw_image
return self._image
@property
def z(self):
if not hasattr(self, "_z"):
image_filename = ImageFilename.parse(str(self.path.relative_to(self.source_dir)))
self._z = image_filename.z
return self._z
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,761
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/models/image_filename.py
|
import re
import logging
import os
from models.image_name_dictionaries.image_filename_CV import CVImageFilename
from models.image_name_dictionaries.image_filename_LSM import LSMImageFilename
LOGGER = logging.getLogger()
FILE_TYPE = os.environ.get('FILE_TYPE')
class ImageFilename:
@classmethod
def parse(cls, image_filename_str):
if FILE_TYPE == 'CV':
return CVImageFilename.parse(image_filename_str)
elif FILE_TYPE == 'LSM':
return LSMImageFilename.parse(image_filename_str)
def __init__(self):
if FILE_TYPE == 'CV':
self.glob = CVImageFilename(experiment, well, t, f, l, a, z, c, suffix, extension)
elif FILE_TYPE == 'LSM':
self.glob = LSMImageFilename(experiment, well, timestamp, z, c, suffix, extension)
def __str__(self):
if FILE_TYPE == 'CV':
return str(self.glob)
elif FILE_TYPE == 'LSM':
return str(self.glob)
def __copy__(self):
if FILE_TYPE == 'CV':
return CVImageFilename.__copy__(self.glob)
elif FILE_TYPE == 'LSM':
return LSMImageFilename.__copy__(self.glob)
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,762
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_spot_result_line.py
|
import shlex
import csv
import logging
import re
import traceback
from copy import copy
from pathlib import Path
import cli.log
import numpy
from models.image_filename import ImageFilename
from models.paths import *
SPOT_RESULT_FILE_SUFFIX_RE = re.compile("_nucleus_(?P<nucleus_index>\d{3})_spot_(?P<spot_index>\d+)")
class GenerateSpotResultLineJob:
def __init__(
self,
spot_source,
spot_source_directory,
z_centers_source_directory,
distance_transforms_source_directory,
nuclear_masks_source_directory,
destination
):
self.spot_source = spot_source
self.spot_source_directory = Path(spot_source_directory)
self.z_centers_source_directory = z_centers_source_directory
self.distance_transforms_source_directory = distance_transforms_source_directory
self.nuclear_masks_source_directory = nuclear_masks_source_directory
self.destination = destination
def run(self):
with open(self.destination_filename, 'w') as csv_file:
csv_writer = csv.DictWriter(csv_file, self.csv_values.keys())
csv_writer.writeheader()
csv_writer.writerow(self.csv_values)
@property
def csv_values(self):
return {
"filename": str(self.source_image_filename),
"experiment": self.source_image_filename.experiment,
"well": self.source_image_filename.well,
"field": self.source_image_filename.f,
"channel": self.source_image_filename.c,
"nucleus_index": self.nucleus_index,
"spot_index": self.spot_index,
"center_x": self.center_x,
"center_y": self.center_y,
"center_z": self.center_z,
"center_r": self.center_r,
"area": self.area,
"eccentricity": self.eccentricity,
"solidity": self.solidity,
"nuclear_mask_offset_x": self.nuclear_mask_offset_x,
"nuclear_mask_offset_y": self.nuclear_mask_offset_y
}
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
global_destination_path = Path(self.destination)
local_destination_path = Path(str(self.source_path.relative_to(self.spot_source_directory))).parents[0]
path_to_make = global_destination_path / local_destination_path
self._destination_path = global_destination_path
if not path_to_make.exists():
Path.mkdir(path_to_make, parents=True)
elif not path_to_make.is_dir():
raise Exception("destination already exists, but is not a directory")
return self._destination_path
@property
def destination_filename(self):
return self.destination_path / ("%s.csv" % self.source_path.relative_to(self.spot_source_directory))
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.spot_source)
return self._source_path
@property
def source_image_filename(self):
if not hasattr(self, "_source_image_filename"):
self._source_image_filename = ImageFilename.parse(str(self.source_path.relative_to(self.spot_source_directory)))
return self._source_image_filename
@property
def source_image_filename_suffix_match(self):
if not hasattr(self, "_source_image_filename_suffix_match"):
self._source_image_filename_suffix_match = SPOT_RESULT_FILE_SUFFIX_RE.match(self.source_image_filename.suffix)
return self._source_image_filename_suffix_match
@property
def nucleus_index(self):
return self.source_image_filename_suffix_match["nucleus_index"]
@property
def spot_index(self):
return self.source_image_filename_suffix_match["spot_index"]
@property
def spot(self):
if not hasattr(self, "_spot"):
self._spot = numpy.load(self.source_path, allow_pickle=True)
return self._spot
@property
def center_x(self):
return self.spot[0][1]
@property
def center_y(self):
return self.spot[0][0]
@property
def area(self):
return self.spot[1]
@property
def eccentricity(self):
return self.spot[2]
@property
def solidity(self):
return self.spot[3]
@property
def z_centers_source_directory_path(self):
if not hasattr(self, "_z_centers_source_directory_path"):
self._z_centers_source_directory_path = source_path(self.z_centers_source_directory)
if not self._z_centers_source_directory_path.is_dir():
raise Exception("z centers source directory does not exist")
return self._z_centers_source_directory_path
@property
def distance_transforms_source_directory_path(self):
if not hasattr(self, "_distance_transforms_source_directory_path"):
self._distance_transforms_source_directory_path = source_path(self.distance_transforms_source_directory)
if not self._distance_transforms_source_directory_path.is_dir():
raise Exception("distance transforms source directory does not exist")
return self._distance_transforms_source_directory_path
@property
def z_center_image_filename(self):
if not hasattr(self, "_z_center_image_filename"):
self._z_center_image_filename = copy(self.source_image_filename)
self._z_center_image_filename.suffix = "_z_center_nuclear_mask_%s" % self.nucleus_index
return self._z_center_image_filename
@property
def z_center_image_path(self):
if not hasattr(self, "_z_center_image_path"):
self._z_center_image_path = self.z_centers_source_directory_path / str(self.z_center_image_filename)
return self._z_center_image_path
@property
def z_center_image(self):
if not hasattr(self, "_z_center_image"):
self._z_center_image = numpy.load(self.z_center_image_path)
return self._z_center_image
@property
def pixel_center(self):
return (round(self.center_y), round(self.center_x))
@property
def center_z(self):
return self.z_center_image[self.pixel_center]
@property
def distance_transform_image_filename(self):
if not hasattr(self, "_distance_transform_image_filename"):
self._distance_transform_image_filename = copy(self.source_image_filename)
self._distance_transform_image_filename.suffix = "_distance_transform_%s" % self.nucleus_index
self._distance_transform_image_filename.a = None
self._distance_transform_image_filename.z = None
self._distance_transform_image_filename.c = None
return self._distance_transform_image_filename
@property
def distance_transform_image_path(self):
if not hasattr(self, "_distance_transform_image_path"):
self._distance_transform_image_path = self.distance_transforms_source_directory_path / str(self.distance_transform_image_filename)
return self._distance_transform_image_path
@property
def distance_transform_image(self):
if not hasattr(self, "_distance_transform_image"):
self._distance_transform_image = numpy.load(self.distance_transform_image_path)
return self._distance_transform_image
@property
def center_r(self):
return self.distance_transform_image[self.pixel_center]
@property
def nuclear_mask_offset_x(self):
return self.nuclear_mask.offset[0]
@property
def nuclear_mask_offset_y(self):
return self.nuclear_mask.offset[1]
@property
def nuclear_mask(self):
if not hasattr(self, "_nuclear_mask"):
self._nuclear_mask = numpy.load(self.nuclear_mask_path, allow_pickle=True).item()
return self._nuclear_mask
@property
def nuclear_masks_source_directory_path(self):
if not hasattr(self, "_nuclear_masks_source_directory_path"):
self._nuclear_masks_source_directory_path = source_path(self.nuclear_masks_source_directory)
if not self._nuclear_masks_source_directory_path.is_dir():
raise Exception("z centers source directory does not exist")
return self._nuclear_masks_source_directory_path
@property
def nuclear_mask_path(self):
if not hasattr(self, "_nuclear_mask_path"):
self._nuclear_mask_path = self.nuclear_masks_source_directory_path / str(self.nuclear_mask_image_filename)
return self._nuclear_mask_path
@property
def nuclear_mask_image_filename(self):
if not hasattr(self, "_nuclear_mask_image_filename"):
self._nuclear_mask_image_filename = copy(self.source_image_filename)
self._nuclear_mask_image_filename.suffix = "_nuclear_mask_%s" % self.nucleus_index
self._nuclear_mask_image_filename.a = None
self._nuclear_mask_image_filename.z = None
self._nuclear_mask_image_filename.c = None
return self._nuclear_mask_image_filename
def generate_spot_result_line_cli_str(
spot_sources,
z_centers_source_directory,
distance_transforms_source_directory,
nuclear_masks_source_directory,
spot_source_directory,
destination
):
return shlex.join([
"pipenv",
"run",
"python",
__file__,
"--z_centers_source_directory=%s" % z_centers_source_directory,
"--distance_transforms_source_directory=%s" % distance_transforms_source_directory,
"--nuclear_masks_source_directory=%s" % nuclear_masks_source_directory,
"--spot_source_directory=%s" % spot_source_directory,
"--destination=%s" % destination,
*[str(spot_source) for spot_source in spot_sources]
])
@cli.log.LoggingApp
def generate_spot_result_line_cli(app):
for spot_source in app.params.spot_sources:
try:
GenerateSpotResultLineJob(
spot_source,
app.params.z_centers_source_directory,
app.params.distance_transforms_source_directory,
app.params.nuclear_masks_source_directory,
app.params.spot_source_directory,
app.params.destination,
).run()
except Exception as exception:
traceback.print_exc()
generate_spot_result_line_cli.add_param("spot_sources", nargs="*")
generate_spot_result_line_cli.add_param("--z_centers_source_directory", required=True)
generate_spot_result_line_cli.add_param("--distance_transforms_source_directory", required=True)
generate_spot_result_line_cli.add_param("--nuclear_masks_source_directory", required=True)
generate_spot_result_line_cli.add_param("--spot_source_directory", required=True)
generate_spot_result_line_cli.add_param("--destination", required=True)
if __name__ == "__main__":
generate_spot_result_line_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,763
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/models/generate_spot_positions_config.py
|
import json
class GenerateSpotPositionsConfig:
@classmethod
def from_json_params(cls, json_params):
return cls(
channel=json_params["channel"],
local_contrast_threshold=json_params["local_contrast_threshold"],
peak_radius=json_params["peak_radius"],
global_contrast_threshold=json_params["global_contrast_threshold"]
)
def __init__(self, channel=None, local_contrast_threshold=None, peak_radius=None, global_contrast_threshold=None):
super().__init__()
self.channel = channel
self.local_contrast_threshold = local_contrast_threshold
self.peak_radius = peak_radius
self.global_contrast_threshold = global_contrast_threshold
def to_json_params(self):
return {
"channel": self.channel,
"local_contrast_threshold": self.local_contrast_threshold,
"peak_radius": self.peak_radius,
"global_contrast_threshold": self.global_contrast_threshold
}
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,764
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_nuclear_segmentation.py
|
import shlex
import logging
import re
import traceback
from copy import copy
from pathlib import Path
import cli.log
import matplotlib.pyplot as plt
import numpy
import scipy
import skimage.io
import skimage.segmentation
from cellpose import models, plot, transforms
from models.image_filename import ImageFilename
from models.paths import *
class GenerateNuclearSegmentationJob:
def __init__(self, source, destination, source_dir, diameter):
self.source_dir = Path(source_dir)
self.source = source
self.destination = destination
self.diameter = diameter
self.logger = logging.getLogger()
def run(self):
numpy.save(self.destination_filename, self.cellpose_filtered)
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
global_destination_path = Path(self.destination)
local_destination_path = Path(str(self.destination_image_filename)).parents[0]
path_to_make = global_destination_path / local_destination_path
self._destination_path = global_destination_path
if not path_to_make.exists():
Path.mkdir(path_to_make, parents=True)
elif not path_to_make.is_dir():
raise Exception("destination already exists, but is not a directory")
return self._destination_path
@property
def destination_filename(self):
if not hasattr(self, "_destination_filename"):
self._destination_filename = self.destination_path / str(self.destination_image_filename)
return self._destination_filename
@property
def destination_image_filename(self):
if not hasattr(self, "_destination_image_filename"):
self._destination_image_filename = copy(self.source_image_filename)
if hasattr(self.source_image_filename, "a"):
self._destination_image_filename.a = None
self._destination_image_filename.z = None
self._destination_image_filename.c = None
self._destination_image_filename.suffix = "_nuclear_segmentation"
self._destination_image_filename.extension = "npy"
return self._destination_image_filename
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.source)
return self._source_path
@property
def source_image_filename(self):
if not hasattr(self, "_source_image_filename"):
print("Source: %s" % self.source_path)
print("Directory: %s" % self.source_dir)
self._source_image_filename = ImageFilename.parse(str(self.source_path.relative_to(self.source_dir)))
return self._source_image_filename
@property
def image(self):
if not hasattr(self, "_image"):
self._image = skimage.io.imread(self.source_path, as_gray=True)
return self._image
@property
def cellpose_result(self):
if not hasattr(self, "_cellpose_result"):
model = models.Cellpose(model_type = "nuclei")
self._cellpose_result = model.eval(self.image, diameter=self.diameter, channels=[[0,0]], resample=True)
return self._cellpose_result
@property
def cellpose_filtered(self):
if not hasattr(self, "_cellpose_filtered"):
dilated = skimage.segmentation.expand_labels(self.cellpose_result[0], distance=3)
self._cellpose_filtered = skimage.segmentation.clear_border(dilated)
return self._cellpose_filtered
def generate_nuclear_segmentation_cli_str(sources, destination, source_dir, diameter):
diameter_arguments = ["--diameter=%i" % diameter] if diameter != None else []
return shlex.join([
"pipenv",
"run",
"python",
__file__,
"--destination=%s" % destination,
"--source_dir=%s" % source_dir,
*diameter_arguments,
*[str(source) for source in sources]
])
@cli.log.LoggingApp
def generate_nuclear_segmentation_cli(app):
for source in app.params.sources:
try:
GenerateNuclearSegmentationJob(
source,
app.params.destination,
app.params.source_dir,
app.params.diameter
).run()
except Exception as exception:
traceback.print_exc()
generate_nuclear_segmentation_cli.add_param("sources", nargs="*")
generate_nuclear_segmentation_cli.add_param("--destination", required=True)
generate_nuclear_segmentation_cli.add_param("--source_dir", required=True)
generate_nuclear_segmentation_cli.add_param("--diameter", type=int, default=100)
if __name__ == "__main__":
generate_nuclear_segmentation_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
31,852,765
|
kfinn/elizabeth-pipeline
|
refs/heads/main
|
/generate_nuclear_masks.py
|
import shlex
import traceback
import cli.log
import numpy
import skimage.measure
from models.nuclear_mask import NuclearMask
from models.paths import *
class GenerateNuclearMasksJob:
def __init__(self, source, destination, source_dir):
self.source = source
self.destination = destination
self.source_dir = Path(source_dir)
def run(self):
for index, nuclear_mask in enumerate(self.nuclear_masks):
numpy.save(self.indexed_destination_filename(index + 1), nuclear_mask)
def indexed_destination_filename(self, index):
source_relative_path = str(self.source_path.relative_to(self.source_dir))
return self.destination_path / source_relative_path.replace("_nuclear_segmentation", ("_nuclear_mask_%03i" % index))
@property
def destination_path(self):
if not hasattr(self, "_destination_path"):
global_destination_path = Path(self.destination)
local_destination_path = Path(str(self.source_path.relative_to(self.source_dir))).parents[0]
path_to_make = global_destination_path / local_destination_path
self._destination_path = global_destination_path
if not path_to_make.exists():
Path.mkdir(path_to_make, parents=True)
elif not path_to_make.is_dir():
raise Exception("destination already exists, but is not a directory")
return self._destination_path
@property
def source_path(self):
if not hasattr(self, "_source_path"):
self._source_path = source_path(self.source)
return self._source_path
@property
def segmentation(self):
if not hasattr(self, "_segmentation"):
self._segmentation = numpy.load(self.source_path, allow_pickle=True)
return self._segmentation
@property
def regionprops(self):
if not hasattr(self, "_regionprops"):
self._regionprops = skimage.measure.regionprops(self.segmentation)
return self._regionprops
@property
def nuclear_masks(self):
if not hasattr(self, "_nuclear_masks"):
self._nuclear_masks = [
NuclearMask.build(self.segmentation, rp) for rp in self.regionprops
]
return self._nuclear_masks
def generate_nuclear_masks_cli_str(sources, destination, source_dir):
return shlex.join([
"pipenv",
"run",
"python",
__file__,
"--destination=%s" % destination,
"--source_dir=%s" % source_dir,
*[str(source) for source in sources]
])
@cli.log.LoggingApp
def generate_nuclear_masks_cli(app):
for source in app.params.sources:
try:
GenerateNuclearMasksJob(
source,
app.params.destination,
app.params.source_dir,
).run()
except Exception as exception:
traceback.print_exc()
generate_nuclear_masks_cli.add_param("sources", nargs="*")
generate_nuclear_masks_cli.add_param("--destination", required=True)
generate_nuclear_masks_cli.add_param("--source_dir", required=True)
if __name__ == "__main__":
generate_nuclear_masks_cli.run()
|
{"/scripts/generate_all_maximum_projections.py": ["/generate_maximum_projection.py"], "/generate_all_maximum_projections.py": ["/generate_maximum_projection.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_spot_positions.py": ["/generate_spot_positions.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename.py", "/models/image_filename_glob.py"], "/generate_all_cropped_cell_images.py": ["/generate_cropped_cell_image.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_all_nuclear_masks.py": ["/generate_nuclear_masks.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_maximum_projection.py": ["/models/paths.py", "/models/z_sliced_image.py"], "/generate_spot_positions.py": ["/models/generate_spot_positions_config.py", "/models/image_filename.py", "/models/paths.py"], "/generate_cropped_cell_image.py": ["/models/image_filename.py", "/models/nuclear_mask.py", "/models/paths.py"], "/generate_all_distance_transforms.py": ["/generate_distance_transform.py", "/models/paths.py", "/models/swarm_job.py"], "/generate_distance_transform.py": ["/models/paths.py"], "/generate_all_nuclear_segmentations.py": ["/generate_nuclear_segmentation.py", "/models/paths.py", "/models/swarm_job.py", "/models/image_filename_glob.py"], "/models/z_sliced_image.py": ["/models/image_filename.py"], "/models/image_filename.py": ["/models/image_name_dictionaries/image_filename_CV.py", "/models/image_name_dictionaries/image_filename_LSM.py"], "/generate_spot_result_line.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_segmentation.py": ["/models/image_filename.py", "/models/paths.py"], "/generate_nuclear_masks.py": ["/models/nuclear_mask.py", "/models/paths.py"], "/models/image_filename_glob.py": ["/models/image_name_dictionaries/image_filename_glob_CV.py", "/models/image_name_dictionaries/image_filename_glob_LSM.py"], "/generate_all_spot_result_lines.py": ["/generate_spot_result_line.py", "/models/paths.py", "/models/image_filename.py", "/models/image_filename_glob.py", "/models/swarm_job.py"], "/generate_spot_results_file.py": ["/models/image_filename.py", "/models/image_filename_glob.py", "/models/paths.py"]}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.