index int64 | repo_name string | branch_name string | path string | content string | import_graph string |
|---|---|---|---|---|---|
72,390 | nickw444/NWPi | refs/heads/master | /UI/NWPi/__init__.py |
# This file imports all files for this module for easy inclusions around the game.
from viewController import *
from navigationController import *
from noticer import *
from Images import *
from fancyButton import *
from constants import *
from textObject import *
from UIButton import *
# from spriteFromRect import *
from UIView import *
from UIAlertView import * | {"/game.py": ["/UI/__init__.py", "/UI/NWPi/__init__.py"]} |
72,391 | nickw444/NWPi | refs/heads/master | /UI/NWPi/constants.py |
# Global constants class. Will hold ALL changable data for the game
# This file should be populated with game settings for reference later in ANY superclass.
# The rest of the class is pretty self explanatory IMO.
import os # Import OS functions for File Paths
import pygame # Import pygame for Fonts, etc
class constants():
def __init__(self):
self.fancyFont = os.path.join('data', "Savoye.ttf")
self.fancyButtonFont = pygame.font.Font(os.path.join('data', "Savoye.ttf"), 32)
self.defaultFontSize = 16
self.defaultFont = pygame.font.SysFont("Arial", self.defaultFontSize, False, False)
self.defaultButtonFont = pygame.font.SysFont("Arial", 14, False, False)
| {"/game.py": ["/UI/__init__.py", "/UI/NWPi/__init__.py"]} |
72,392 | nickw444/NWPi | refs/heads/master | /UI/NWPi/UIView.py |
# Main UIView Class. Made for subclassing for other Views and ANY other object
# This is probably the most heavily used class throughout the library, and still needs much work
# However, the nature of the class allows easy modification and cool new things to be added
import pygame
from noticer import *
from constants import *
import Images
class UIView():
def __init__(self, dimensions, parent, background=(255,255,255), borders=(0, 0, 0, 0), borderColor=(0, 0, 0)):
self.image = pygame.Surface(dimensions) # Make a image/canvas to draw things to.
self.image.fill(background) # Fill the image with the specified borderColor
self.rect = pygame.Rect((0, 0), dimensions) # Initialise a rectangle at x=0 and y=0, add coordinates
self.subViews = [] # Initialise subViews array (should be empty)
self.isVisible = True # Set the visible flag to true
self.parent = parent # Set the parent for later traversal use
self.backgroundcolor = background # Set the background color for later use/painting
self.borderColor = borderColor # Same with the border color for later painting
self.borders = borders # Annnnd, the border widths for each side (yes, i stole this from the CSS2 way of doing borders... (top, right, bottom, left))
self.customInitial() # Run the custom initialisation method (legacy tbh), I should have instead just allowed subClasses to run UIView.__init__. Will fix in the future
self.updateView() # Update the overall UIView and win.
def addSubView(self, subView):
# Add a subView to the view. Good to add more UIViews below this one, or other objects such as UIButtons.
self.subViews.append(subView) # Add the subView to the array
self.updateView() # Update this view.
def setOpacity(self, opacity):
self.image.set_alpha(opacity) # Set the opacity of this view
self.updateView() # Re-paint/fill accordingly.
def customInitial(self):
# Method for subclassing as the custom initilization method
pass
def clearSubviews(self):
self.subViews = [] # Remove ALL subviews from this vieww
self.updateView() # Tell this view to update, should re-paint the fact it has no subViews
def addBorders(self, borders = False):
# Method to draw borders to the UIView. Pretty simple, just geometry and a bit of math. I'm not going to explain this one.
if borders != False:
self.borders = borders
self.image.fill(self.borderColor, ((0, 0),(self.rect.width, self.borders[0])))
self.image.fill(self.borderColor, ((self.rect.width - self.borders[1], 0),(self.borders[1], self.rect.height)))
self.image.fill(self.borderColor, ((0, self.rect.height - self.borders[2]),(self.rect.width, self.borders[2])))
self.image.fill(self.borderColor, ((0, 0),(self.borders[3], self.rect.height)))
def setCustomCallback(self, callback):
# Allows setting of a callback on a button.
self.actions = callback
def setBackgroundImage(self, image):
self.image, self.rect = Images.load_image(image)
def userCallback(self, event, caller, withinBounds):
# Method to run the users custom callback. This will catch fatal exceptions (luckily)
try:
self.actions(self, event, caller, withinBounds)
# Method exists, and was used.
except (AttributeError, TypeError):
# Method does not exist. What now?
noticer("Method self.actions() does not exist", 2, self)
def updateView(self):
# print self.subViews
# Blitting method for viewController.
self.image.fill(self.backgroundcolor) # Re-Fill the canvas, wipe EVERYTHING
self.addBorders()
for subView in self.subViews: # Loop through each SubView
self.image.blit(subView.image, subView.rect) # Blit the subView to the canvas
self.parent.updateView() # Tell the navigationcontroller that it needs to be updated (It'll just blit this views canvas to itself). If there are nested UIViews, it'll just go up, and up, and up until it reaches the topmost object
def manageEvent(self, event, caller, withinBounds=True):
# Traversing down the events tree. We receieved an event from the parent NavigationViewController.
# We need to now pass this even down the tree to the corresponding object that the mouse landed on or whatnot.
# print "Found a subUIView"
if withinBounds:
self.userCallback(event, caller, withinBounds)
for subView in self.subViews: # Loop Through each SubView that is LISTENING for events.
if self.isVisible: # Ensure this view is visible (It should be if we've already come this far)
outside = False # Some pre-variable for later reference
mouse = (event.pos[0] - self.rect.x, event.pos[1] - self.rect.y) # Get the mouse Position
if mouse[0] > subView.rect.topleft[0]: # Check the mouse position in regards to the subView's rectangle.
if mouse[1] > subView.rect.topleft[1]:
if mouse[0] < subView.rect.bottomright[0]:
if mouse[1] < subView.rect.bottomright[1]: # Mouse is within the bounds
# It's easier to ask forgiveness than to ask permission. # Catching exceptions is key here, in case the subView doesn't have a callback method implemented
try:
subView.manageEvent(event, self, True) # Method exists, and was used.
except (AttributeError, TypeError):
noticer("Method manageEvent() does not exist", 1, subView) # Method does not exist. What now?
else:
outside = True # Move back down the tree, setting the outside variable to True if the mouse is outside.
else:
outside = True
else:
outside = True
else:
outside = True
if outside == True: # Mouse is outside, Try send the callback method again, except with the parameter inside = False (This fixes mousebuttonups)
try:
subView.manageEvent(event, self, False)
except (AttributeError, TypeError):
noticer("Method manageEvent(ddd) does not exist", 1, subView)
| {"/game.py": ["/UI/__init__.py", "/UI/NWPi/__init__.py"]} |
72,393 | nickw444/NWPi | refs/heads/master | /UI/NWPi/navigationController.py |
# NavigationController Class
# This is the topMost class on the view tree model.
# All subviews MUST be placed on this view by running "AddSubview" method
# It is recomended to only place objects of Viewcontroller class to this object as they can handle events correctly
# This class was originally implemented before UIView was implemented, This /should/ be subclassed from UIView eventually.
# However, the assignment is due tomorrow, so i don't want to screw anything up
import pygame # Grab pygame
import copy # Allow for copying of objects (not just object references which kills everything)
from noticer import * # Allow debugging and logging.
class navigationController(): # Define the class
def __init__(self, screen):
self.subViews = [] # Set the subViews Variable to data type of list
self.backgroundcolor = (50, 50, 50) # Set the self background color
self.screen = screen # Save the screen object reference for later blitting (as this is the topmost object)
self.canvas = pygame.Surface(screen.get_size()) # Draw the canvas
self.updateView() # Update this navigation controller with the new blitted canvas
def addSubView(self, identifier, object):
# Method allows the NavigationController to have subViews added.
# Will simply add them to the subViews array for use later in the self.updateView method
# The object being added MUST have a runCallback(event) method otherwise an exception will be thown (CBF catching errors)
self.subViews.append({"identifier": identifier, "object": object}) # Add to the array
self.updateView() # Update this navigation controller and blit everything from below upwards.
# method removeSubView needs a re-write and CBF right now. Concept is still here, just needs re-writing to account for the different list structure
# def removeSubView(self, object):
# # Method will simply find the object passed and remove it from
# self.subViews.remove(object)
# self.updateView()
def updateView(self):
# this method basically:
# 1. Wipes the canvas clean
# 2. Blits each subView to the canvas, in order that they are in in the list AND only if they are Visible (Saves memory this way)
# 3. Blits the canvas to the screen
noticer("Updating Navigation Controller", 0, self)
self.canvas.fill(self.backgroundcolor)
for subView in self.subViews:
if subView['object'].isVisible:
self.canvas.blit(subView['object'].canvas, (0, 0))
self.screen.blit(self.canvas, (0, 0))
def makeKeyAndVisible(self, identifier):
# This method is needed to bring a subView/viewController to the front. It re-organises the subViews list.
i = 0 # Set a counter for the loop
found = False # Set some defaults
views = copy.copy(self.subViews) # Make a copy of the subViews array so we can modify it without fucking everything up
while i < len(views): # Loopy
if (views[i]['identifier'] == identifier): # Check if the identifier we're looking for is this object
obj = self.subViews.pop(i) # Remove the object from the middle/top of the array, and get it
obj['object'].isVisible = True # Tell the subView of the object that it is now visible on screen (fixes issues with listening for events - listening for objects that are not on screen)
self.subViews.append(obj) # Re-append the object to the end
found = True # For later use, say that we did find a view
break # Break the loop, we found the one we need, no need to do any more finding. Don't work the processor too hard
else: # Didnt find the object for the identifier :(
self.subViews[i]['object'].isVisible = False # Seeing as this isn't the object we're looking for, let's tell it that no, it's no longer visible
i += 1 # Loop increment
if found != True: # Check to see if we did find one
noticer("The ViewController with identifier" + identifier + " was not found", 2, self) # Warn the console and log that we didn't find anything
# Because we did tell everything to disable itself for interactions, we need to give the top level one interactivity again.
topView = copy.copy(self.subViews) # Get the SubViews Array
top = topView.pop() # Get the last item in the array (The one that is showing)
top['object'].isVisible = True # Tell the object that it is still visible (because we told it earlier that it wasn't)
self.updateView() # Now that everything is basically over, update this navigationController, with the new arrangement of subViews
def manageEvent(self, event):
# This is the topmost even manager method
subviews = copy.copy(self.subViews) # Copy so we don't destory the REAL list
sub = subviews.pop() # Get the topMost subView
if sub['object'].isVisible: # Check to ensure this subView is visible.
sub['object'].manageEvent(event) # Send the action to the visible subview
| {"/game.py": ["/UI/__init__.py", "/UI/NWPi/__init__.py"]} |
72,394 | nickw444/NWPi | refs/heads/master | /UI/NWPi/viewController.py |
# ViewController Class
# One of the main classes in layout management.
# Can be easily subClassed and new objects can be re-drawn to it in the subclass.
# Simply subclass NWPi.viewController and implement the method "customInitial(self)".
# This will allow you to draw items to the canvas or do funny things with the viewController.
import pygame
from noticer import *
# from Images import *
class viewController():
def __init__(self, navigationController):
self.subViews = [] # Set the subViews variable to data type of list
self.isVisible = False # By default this view will be invisible
self.backgroundcolor = (230, 230, 230) # Set the default background color. Yes, we can change this later on.
self.navigationController = navigationController # Set the parent navigation controller. For use in blitting
self.screen = navigationController.screen # for later use yolo # Grab the screen and reference it
self.listeningSubViews = [] # Set the listeningSubViews array to data type of list
self.canvas = pygame.Surface(self.screen.get_size()) # initialise the canvas for this view for blitting
self.customInitial() # Run the custom initialisation method (Yes, it's empty here, but it can be subClasses)
self.updateView() # Update this view and all subViews on it.
def customInitial(self):
# SubClassable method. This can be edited to allow custom initialisation, such as custom drawing.
return
def get_rect(self):
return self.canvas.get_rect()
def setBackgroundColor(self, colors):
# Self explanatory. Set the background color. boom headshot.
self.backgroundcolor = colors
self.updateView()
def manageEvent(self, event):
# Traversing down the events tree. We receieved an event from the parent NavigationViewController.
# We need to now pass this even down the tree to the corresponding object that the mouse landed on or whatnot.
for subView in self.subViews: # Loop Through each SubView that is LISTENING for events.
if self.isVisible: # Ensure this view is visible (It should be if we've already come this far)
outside = False # Some pre-variable for later reference
mouse = event.pos # Get the mouse Position
if mouse[0] > subView.rect.topleft[0]: # Check the mouse position in regards to the subView's rectangle.
if mouse[1] > subView.rect.topleft[1]:
if mouse[0] < subView.rect.bottomright[0]:
if mouse[1] < subView.rect.bottomright[1]:
# noticer("Mouse within bounds", 0, subView) # Mouse is within the bounds
# It's easier to ask forgiveness than to ask permission. # Catching exceptions is key here, in case the subView doesn't have a callback method implemented
try:
subView.manageEvent(event, self, True) # Method exists, and was used.
except (AttributeError, TypeError):
noticer("Method manageEvent() does not exist when inside", 1, subView) # Method does not exist. What now?
else:
outside = True # Move back down the tree, setting the outside variable to True if the mouse is outside.
else:
outside = True
else:
outside = True
else:
outside = True
if outside == True: # Mouse is outside, Try send the callback method again, except with the parameter inside = False (This fixes mousebuttonups)
try:
subView.manageEvent(event, self, False)
except (AttributeError, TypeError):
noticer("Method manageEvent() does not exist when outside", 1, subView)
def addSubView(self, object, callback=False):
# This method simply allows subViews to be added to the superView.
# It also allows them to enable themselves as 'callbackable' if param callback = True
self.subViews.append(object) # Add to the subViews list
if callback == True: # check for callback
self.listeningSubViews.append(object) # Callback is enabled, add object to the listeningSubViews list
self.updateView() # Blit all subViews using the updateView method
def removeSubView(self, object):
# Remove a view from the superview. Good for removing text or sprites
self.subViews.remove(object) # Simply remove the objects from the array and you're done. Easy as pi.
if object in self.listeningSubViews:
self.listeningSubViews.remove(object) # once again, just remove them from this array too
self.updateView() # Re-blit everything
def updateView(self):
# Blitting method for viewController.
self.canvas.fill(self.backgroundcolor) # Re-Fill the canvas, wipe EVERYTHING
for subView in self.subViews: # Loop through each SubView
self.canvas.blit(subView.image, subView.rect) # Blit the subView to the canvas
# self.screen.blit(self.canvas, (0, 0))
self.navigationController.updateView() # Tell the navigationcontroller that it needs to be updated (It'll just blit this views canvas to itself)
| {"/game.py": ["/UI/__init__.py", "/UI/NWPi/__init__.py"]} |
72,400 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/home/home.py | from flask import Blueprint, render_template, request, url_for
import web_app.adapters.repository as repo
import web_app.home.services as services
home_blueprint = Blueprint('home_bp', __name__)
@home_blueprint.route('/', methods=['GET'])
def home():
movies_per_page = 5
cursor = request.args.get('cursor')
if cursor is None:
cursor = 0
else:
cursor = int(cursor)
movie_ids = services.get_ids_of_movies(repo.repository_instance)
movies = services.get_movies(movie_ids[cursor: cursor + movies_per_page], repo.repository_instance)
first_movie = None
prev_movie = None
next_movie = None
last_movie = None
if cursor > 0:
first_movie = url_for('home_bp.home')
prev_movie = url_for('home_bp.home', cursor=cursor - movies_per_page)
if cursor + movies_per_page < len(movie_ids):
next_movie = url_for('home_bp.home', cursor=cursor + movies_per_page)
last_page = movies_per_page * int(len(movie_ids) / movies_per_page)
if len(movie_ids) % movies_per_page == 0:
last_page -= movies_per_page
last_movie = url_for('home_bp.home', cursor=last_page)
return render_template(
'home.html', movie_ids=movie_ids, movies=movies,
first_movie=first_movie,
next_movie=next_movie, last_movie=last_movie,
prev_movie=prev_movie
) | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,401 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/domainmodel/watchlist.py | from web_app.domainmodel.movie import Movie
class WatchList:
def __init__(self):
self.__watchlist = []
self.__index = 0
@property
def watchlist(self) -> list:
return self.__watchlist
@property
def index(self) -> int:
return self.__index
def add_movie(self, movie: Movie):
if movie not in self.watchlist:
self.watchlist.append(movie)
def remove_movie(self, movie: Movie):
if movie in self.watchlist:
self.watchlist.remove(movie)
def select_movie_to_watch(self, index: int):
if index < 0 or index > len(self.watchlist) - 1:
return None
else:
return self.watchlist[index]
def size(self) -> int:
return len(self.watchlist)
def first_movie_in_watchlist(self):
if len(self.watchlist) == 0:
return None
else:
return self.watchlist[0]
def __iter__(self):
return self
def __next__(self):
if self.index == self.size():
raise StopIteration
else:
item = self.watchlist[self.index]
self.__index += 1
return item | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,402 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/domainmodel/watchlist_test.py | import pytest
from web_app.domainmodel.movie import Movie
from web_app.domainmodel.watchlist import WatchList
def test_size():
watchlist = WatchList()
assert watchlist.size() == 0
movie1 = Movie("Moana", 2016)
movie2 = Movie("Booksmart", 2019)
movie3 = Movie("School of Rock", 2003)
movie4 = Movie("Roma", 2018)
watchlist.add_movie(movie1)
watchlist.add_movie(movie2)
watchlist.add_movie(movie3)
watchlist.add_movie(movie4)
assert watchlist.size() == 4
def test_adding_and_removing():
watchlist = WatchList()
movie1 = Movie("Moana", 2016)
movie2 = Movie("Booksmart", 2019)
movie3 = Movie("School of Rock", 2003)
movie4 = Movie("Roma", 2018)
watchlist.add_movie(movie1)
watchlist.add_movie(movie2)
watchlist.add_movie(movie3)
watchlist.add_movie(movie4)
watchlist.add_movie(movie4)
assert watchlist.size() == 4
watchlist.remove_movie(movie1)
assert watchlist.size() == 3
watchlist.remove_movie(Movie("Juno", 2007))
assert watchlist.size() == 3
def test_iterator():
movie1 = Movie("Moana", 2016)
movie2 = Movie("Booksmart", 2019)
movie3 = Movie("School of Rock", 2003)
movie4 = Movie("Roma", 2018)
watchlist = WatchList()
watchlist.add_movie(movie1)
watchlist.add_movie(movie2)
watchlist.add_movie(movie3)
watchlist.add_movie(movie4)
it1 = iter(watchlist)
assert next(it1) == Movie("Moana", 2016)
assert next(it1) == Movie("Booksmart", 2019)
assert next(it1) == Movie("School of Rock", 2003)
assert next(it1) == Movie("Roma", 2018)
with pytest.raises(StopIteration):
next(it1)
def test_select_and_first():
movie1 = Movie("Moana", 2016)
movie2 = Movie("Booksmart", 2019)
movie3 = Movie("School of Rock", 2003)
movie4 = Movie("Roma", 2018)
watchlist = WatchList()
watchlist.add_movie(movie1)
watchlist.add_movie(movie2)
watchlist.add_movie(movie3)
watchlist.add_movie(movie4)
assert watchlist.select_movie_to_watch(0) == Movie("Moana", 2016)
assert watchlist.select_movie_to_watch(5) is None
assert watchlist.first_movie_in_watchlist() == Movie("Moana", 2016)
watchlist2 = WatchList()
assert watchlist2.first_movie_in_watchlist() is None
| {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,403 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/adapters/memory_repository.py | from bisect import insort_left
from web_app.adapters.repository import AbstractRepository
from web_app.domainmodel.movie import Movie
from web_app.domainmodel.user import User
from web_app.domainmodel.director import Director
from web_app.domainmodel.actor import Actor
from web_app.domainmodel.genre import Genre
from web_app.datafilereaders.movie_file_csv_reader import MovieFileCSVReader
class MemoryRepository(AbstractRepository):
def __init__(self):
self.__movies = list()
self.__movie_index = dict()
self.__users = list()
self.__genres = list()
self.__actors = list()
self.__directors = list()
self.__release_years = list()
self.__genre_pop = dict()
self.__reviews = list()
def get_movie(self, id: int):
if id not in self.__movie_index.keys():
return None
else:
return self.__movie_index[id]
def get_movies(self) -> list:
return self.__movies
def get_genres(self) -> list:
return self.__genres
def get_actors(self) -> list:
return self.__actors
def get_directors(self) -> list:
return self.__directors
def get_release_years(self) -> list:
return self.__release_years
def get_size_of_genre(self, a_genre: 'Genre') -> int:
return self.__genre_pop[a_genre]
def add_genre(self, a_genre: 'Genre'):
self.__genres.append(a_genre)
if a_genre not in self.__genre_pop:
self.__genre_pop[a_genre] = 0
def add_actor(self, a_actor: 'Actor'):
self.__actors.append(a_actor)
def add_director(self, a_director: 'Director'):
self.__directors.append(a_director)
def add_release_year(self, a_year: int):
self.__release_years.append(a_year)
def tidy_up(self) -> None:
self.__movies.sort()
self.__directors.sort()
self.__actors.sort()
self.__genres.sort()
self.__release_years.sort()
def add_movie(self, movie: Movie):
insort_left(self.__movies, movie)
self.__movie_index[movie.id] = movie
def get_movies_for_browse(self, id_list):
real_ids = [id for id in id_list if id in self.__movie_index]
return [self.__movie_index[id] for id in real_ids]
def get_ids_of_movies(self):
return [i for i in self.__movie_index.keys()]
def add_user(self, user: User):
self.__users.append(user)
def get_user(self, username) -> User:
return next((user for user in self.__users if user.user_name == username), None)
def get_users(self) -> list:
return self.__users
def populate(filename, repo):
csv = MovieFileCSVReader(filename)
csv.read_csv_file()
for movie in csv.dataset_of_movies:
repo.add_movie(movie) | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,404 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/datafilereaders/movie_file_csv_reader.py | import csv
from web_app.domainmodel.movie import Movie
from web_app.domainmodel.actor import Actor
from web_app.domainmodel.genre import Genre
from web_app.domainmodel.director import Director
class MovieFileCSVReader:
def __init__(self, file_name: str):
self.__file_name = file_name
self.__dataset_of_directors = set()
self.__dataset_of_actors = set()
self.__dataset_of_movies = []
self.__dataset_of_genres = set()
@property
def dataset_of_actors(self):
return self.__dataset_of_actors
@property
def dataset_of_directors(self):
return self.__dataset_of_directors
@property
def dataset_of_movies(self):
return self.__dataset_of_movies
@property
def dataset_of_genres(self):
return self.__dataset_of_genres
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
for row in movie_file_reader:
movie_class = Movie(row['Title'], int(row['Year']))
if movie_class not in self.dataset_of_movies:
movie_class.id = row['Rank']
director = Director(row['Director'])
movie_class.director = director
movie_class.description = row['Description']
for actor in row['Actors'].split(","):
actor_movie = Actor(actor)
movie_class.add_actor(actor_movie)
for genre in row['Genre'].split(","):
genre_movie = Genre(genre)
movie_class.add_genre(genre_movie)
movie_class.runtime_minutes = int(row['Runtime (Minutes)'])
self.dataset_of_movies.append(movie_class)
for actor in row['Actors'].split(","):
actor_class = Actor(actor)
if actor_class not in self.dataset_of_actors:
self.dataset_of_actors.add(actor_class)
director_class = Director(row['Director'])
if director_class not in self.dataset_of_directors:
self.dataset_of_directors.add(director_class)
for genre in row['Genre'].split(","):
genre_class = Genre(genre)
if genre_class not in self.dataset_of_genres:
self.dataset_of_genres.add(genre_class)
| {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,405 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/adapters/repository.py | import abc
from web_app.domainmodel.movie import Movie
from web_app.domainmodel.user import User
repository_instance = None
class AbstractRepository(abc.ABC):
@abc.abstractmethod
def get_movie(self, id: int):
raise NotImplementedError
@abc.abstractmethod
def add_movie(self, movie: Movie):
raise NotImplementedError
@abc.abstractmethod
def get_movies_for_browse(self, id_list):
raise NotImplementedError
@abc.abstractmethod
def get_ids_of_movies(self):
raise NotImplementedError
@abc.abstractmethod
def get_movies(self):
raise NotImplementedError
@abc.abstractmethod
def get_users(self):
raise NotImplementedError
@abc.abstractmethod
def get_actors(self):
raise NotImplementedError
@abc.abstractmethod
def get_directors(self):
raise NotImplementedError
@abc.abstractmethod
def add_user(self, user: User):
"""" Adds a User to the repository. """
raise NotImplementedError
@abc.abstractmethod
def get_user(self, username) -> User:
""" Returns the User named username from the repository.
If there is no User with the given username, this method returns None.
"""
raise NotImplementedError | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,406 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/domainmodel/user_test.py | from web_app.domainmodel.user import User
from web_app.domainmodel.movie import Movie
from web_app.domainmodel.comment import Comment
from web_app.domainmodel.watchlist import WatchList
def test_user_comments():
user = User("Hazel", "1234")
movie = Movie("Her", 2013)
comment = Comment(movie, "What are some similar movies to this?")
user.add_comment(comment)
assert comment in user.comments
user.add_comment(comment)
assert len(user.comments) == 1
def test_user_watchlist():
user = User("Hazel", "1234")
watchlist = WatchList()
user.add_watchlist(watchlist)
assert user.watchlist == watchlist
watchlist2 = WatchList()
user.add_watchlist(watchlist2)
assert user.watchlist == watchlist | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,407 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/home/services.py | from web_app.adapters.repository import AbstractRepository
def get_ids_of_movies(repo: AbstractRepository):
id_list = repo.get_ids_of_movies()
return id_list
def get_movies(id_list, repo: AbstractRepository):
movies = repo.get_movies_for_browse(id_list)
return movies | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,408 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /test/unit/test_domain_model.py | import pytest
from web_app.domainmodel.actor import Actor
from web_app.domainmodel.genre import Genre
from web_app.domainmodel.movie import Movie
from web_app.domainmodel.review import Review
from web_app.domainmodel.watchlist import WatchList
from web_app.domainmodel.user import User
def test_director_genre_actor():
# check_init
director = Director("Christopher Nolan")
actor = Actor("Chris Pratt")
genre = Genre("Horror")
print(director)
print(actor)
print(genre)
def test_movie():
# check_boolean_equality_function
movie = Movie("Moana", 2009)
print(movie)
movie3 = Movie("Moana", 2010)
print(movie3)
movie2 = Movie("Inception", 2010)
print(movie2)
print(movie > movie2)
print(movie < movie3)
print(movie3 == movie3)
# check_remove_actor_in_list_of_actors
actors = [Actor("Auli'i Cravalho"), Actor("Dwayne Johnson"), Actor("Rachel House"), Actor("Temuera Morrison")]
for actor in actors:
movie.add_actor(actor)
movie.remove_actor(Actor("Auli'i Cravalho"))
print(movie.actors)
# check_for_out_of_range_runtime
movie.runtime_minutes = 121
print("Movie runtime: {} minutes".format(movie.runtime_minutes))
movie.external_rating = 30
print("votes: {}".format(movie.external_rating))
def test_review():
# check_not_review_type_and_rating_returns_none
movie = Movie("Moana", 2016)
review_text = Movie("Me", 2324)
rating = 100
review = Review(movie, review_text, rating)
print("Review: {}".format(review.review_text))
print("Rating: {}".format(review.rating))
# check_same_review_equality
movie = Movie("Moana", 2016)
review_text = "It was a very fun movie for the kids"
rating = 8.1
review = Review(movie, review_text, rating)
review2 = Review(movie, review_text, rating)
print("Review: {}".format(review.review_text))
print("Rating: {}".format(review.rating))
print(review2 == review)
print(review == review2)
print(review2.timestamp)
print(review.timestamp)
def test_user():
user1 = User('Martin', 'pw12345')
user4 = User('Martin', 'pw12345')
user2 = User('Ian', 'pw67890')
user3 = User('Daniel', 'pw87465')
movie = Movie("Moana", 2009)
review_text = "It was so average"
rating = 10
review = Review(movie, review_text, rating)
print(movie)
movie.runtime_minutes = 107
movie3 = Movie("", 4545)
print(movie3)
movie2 = Movie("Inception", 2010)
movie2.runtime_minutes = 133
user1.watch_movie(movie)
user1.watch_movie(movie2)
user1.watch_movie(movie)
user2.add_review(review)
print(user1)
print(user4)
print(user2)
print(user3)
print(user1 == user4)
print(user1 > user2)
print(user1.time_spent_watching_movies_minutes)
print(user2.reviews)
print(user1.watched_movies)
def test_watchlist():
# init watchlist
watchlist = WatchList()
print(f"Size of watchlist: {watchlist.size()}")
# check_size
watchlist = WatchList()
print(f"Size of watchlist: {watchlist.size()}")
# check_size_of_nonempty_watchlist
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
print(f"Size of watchlist: {watchlist.size()}")
# check_add_movie
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
print(f"Size of watchlist: {watchlist.size()}")
# check add_same_movie_again
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Moana", 2016))
print(f"Size of watchlist: {watchlist.size()}")
# check_remove_movie_in_list
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.remove_movie(Movie("Moana", 2016))
print(f"Size of watchlist: {watchlist.size()}")
# check_remove_movie_not_in_list
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.remove_movie(Movie("Guardians of the Galaxy", 2012))
print(f"Size of watchlist: {watchlist.size()}")
# check_select_movie_to_watch_index_ok
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
print(watchlist.select_movie_to_watch(2))
# check_select_movie_to_watch_index_out_of_bounds
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
watchlist.add_movie(Movie("Split", 2016))
print(watchlist.select_movie_to_watch(4))
# check_iterator_reaches_final_element
watchlist = WatchList()
watchlist.add_movie(Movie("Moana", 2016))
watchlist.add_movie(Movie("Ice Age", 2002))
watchlist.add_movie(Movie("Guardians of the Galaxy", 2012))
watchlist.add_movie(Movie("Split", 2016))
watchlist.remove_movie(Movie("Guardians of the Galaxy", 2012))
for movie in watchlist:
print(movie)
| {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,409 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /test/unit/test_services.py | import pytest
from web_app.browsing import services as browse
from web_app.authentication import services as auth
from datetime import datetime
def test_browse_by_get_movie_info(a_memory_repo):
movie_info = browse.get_movie_info("Split", 2016, a_memory_repo)
assert movie_info == {'title': "Split",
'release_year': 2016,
'description': "Three girls are kidnapped by a man with a diagnosed 23 distinct personalities. They must try to escape before the apparent emergence of a frightful new 24th.",
'director': "M. Night Shyamalan",
'actors': ["James McAvoy", "Anya Taylor-Joy", "Haley Lu Richardson", "Jessica Sula"],
'genres': ["Horror", "Thriller"],
'runtime': 117}
def test_browse_by_get_non_existant_movie_info(a_memory_repo):
assert browse.get_movie_info("Nope", 2016, a_memory_repo) is None
def test_get_number_per_genre(a_memory_repo, a_file_reader):
data_from_test = dict()
for movie in a_file_reader.dataset_of_movies:
for item in movie.genres:
if item.genre_name in data_from_test:
data_from_test[item.genre_name] += 1
else:
data_from_test[item.genre_name] = 1
for key, val in data_from_test.items():
assert val == browse.get_pop_of_genre(key, a_memory_repo)
def test_add_user(a_memory_repo):
auth.add_user('Billy', 'showmeThem0ney!', a_memory_repo)
user_dict = auth.get_user('billy', a_memory_repo)
assert user_dict['username'] == 'billy'
def test_authenticate_user(a_memory_repo):
auth.add_user('Billy', 'showmeThem0ney!', a_memory_repo)
assert auth.authenticate_user('billy', 'showmeThem0ney!', a_memory_repo) is True
def test_authenticate_non_existant_user(a_memory_repo):
auth.add_user('Billy', 'showmeThem0ney!', a_memory_repo)
assert auth.services.authenticate_user('john', 'showmeThem0ney!', a_memory_repo) is False
def test_authenticate_user_with_bad_password(a_memory_repo):
auth.add_user('Billy', 'showmeThem0ney!', a_memory_repo)
assert auth.authenticate_user('billy', 'showmetheMoney!', a_memory_repo) is False
| {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,410 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/domainmodel/comment.py | from datetime import datetime
from web_app.domainmodel.movie import Movie
class Comment:
def __init__(self, movie: Movie, comment: str):
if comment == "":
self.__comment = None
else:
self.__comment = comment.strip()
self.__movie = movie
self.__replies = []
datetime_object = datetime.now()
self.__timestamp = datetime_object
self.__parent = None
@property
def comment(self):
return self.__comment
@property
def movie(self):
return self.__movie
@property
def replies(self):
return self.__replies
@property
def timestamp(self):
return self.__timestamp
@property
def parent(self):
return self.__parent
@parent.setter
def parent(self, parent):
self.__parent = parent
def __repr__(self):
return f"<{self.movie}, Comment {self.comment}, Time {self.timestamp}>"
def __eq__(self, other):
return self.__repr__() == other.__repr__()
def add_reply(self, reply):
if reply.movie == self.movie and self.parent is None:
self.__replies.append(reply)
reply.parent = self
elif self.parent is not None and reply.movie == self.parent.__movie:
self.parent.__replies.append(reply)
reply.parent = self.parent
def remove_reply(self, reply):
if reply in self.replies:
self.__replies.remove(reply) | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,411 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /test/conftest.py | import pytest
from os.path import join as path_join
import web_app.adapters.repository as repo
from web_app.adapters.memory_repository import MemoryRepository, populate
from web_app.datafilereaders.movie_file_csv_reader import MovieFileCSVReader
from web_app import create_app
TEST_DATA_PATH = path_join('test', 'data')
@pytest.fixture
def a_memory_repo():
repo.repository_instance = MemoryRepository()
populate(TEST_DATA_PATH, repo.repository_instance)
return repo.repository_instance
@pytest.fixture
def a_file_reader():
reader = MovieFileCSVReader(path_join(TEST_DATA_PATH, 'Data1000Movies.csv'))
reader.read_csv_file()
return reader
@pytest.fixture
def client():
test_app = create_app({
'TESTING': True, 'TEST_DATA_PATH': TEST_DATA_PATH, 'WTF_CSRF_ENABLED': False})
return test_app.test_client()
class TheUser:
def __init__(self, client):
self.__client = client
def login(self, username='pradakeef', password='mAgicprada123'):
return self.__client.post('/login', data={'username': username, 'password': password})
def logout(self):
return self.__client.get('/logout')
@pytest.fixture
def user_credential(client):
return TheUser(client)
| {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,412 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/domainmodel/user.py | from web_app.domainmodel.movie import Movie
from web_app.domainmodel.review import Review
from web_app.domainmodel.comment import Comment
from web_app.domainmodel.watchlist import WatchList
class User:
def __init__(self, user_name: str, password: str):
if user_name == "" or type(user_name) is not str:
self.__user_name = None
else:
self.__user_name = user_name.strip().lower()
self.__password = password
self.__watched_movies = []
self.__reviews = []
self.__comments = []
self.__time_spent_watching_movies_minutes = 0
self.__watchlist = None
@property
def user_name(self) -> str:
return self.__user_name
@property
def password(self) -> str:
return self.__password
@property
def watched_movies(self) -> list:
return self.__watched_movies
@property
def reviews(self) -> list:
return self.__reviews
@property
def comments(self) -> list:
return self.__comments
@property
def watchlist(self) -> WatchList:
return self.__watchlist
@property
def time_spent_watching_movies_minutes(self) -> int:
return self.__time_spent_watching_movies_minutes
def __repr__(self):
return f"<User {self.user_name}>"
def __eq__(self, other):
return self.user_name == other.user_name
def __lt__(self, other):
return self.user_name < other.user_name
def __hash__(self):
return hash(self.user_name)
def watch_movie(self, movie: Movie):
if movie not in self.watched_movies:
self.__watched_movies.append(movie)
if movie.runtime_minutes is not None:
self.__time_spent_watching_movies_minutes += movie.runtime_minutes
def add_review(self, review: Review):
if review not in self.reviews:
self.__reviews.append(review)
def add_comment(self, comment: Comment):
if comment not in self.comments:
self.__comments.append(comment)
def add_watchlist(self, watchlist: WatchList):
if self.watchlist is None:
self.__watchlist = watchlist | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,413 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /test/unit/test_file_reader.py | from web_app.datafilereaders.movie_file_csv_reader import MovieFileCSVReader
def test_csv_file():
# check_file_reads_in
filename = 'CS235Flix-A2-FinalProject/test/data/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
# check_length_of_movie_lists_are_accurate
print(f'number of unique movies: {len(movie_file_reader.dataset_of_movies)}')
print(f'number of unique actors: {len(movie_file_reader.dataset_of_actors)}')
print(f'number of unique directors: {len(movie_file_reader.dataset_of_directors)}')
print(f'number of unique genres: {len(movie_file_reader.dataset_of_genres)}')
# check_equality_sorting_movie_dataset_objects
all_directors_sorted = sorted(movie_file_reader.dataset_of_directors)
print(f'first 3 unique directors of sorted dataset: {all_directors_sorted[0:3]}')
all_actors_sorted = sorted(movie_file_reader.dataset_of_actors)
print(f'first 3 unique directors of sorted dataset: {all_actors_sorted[0:3]}')
all_movies_sorted = sorted(movie_file_reader.dataset_of_movies)
print(f'first 3 unique directors of sorted dataset: {all_movies_sorted[0:3]}')
# check_movie_attributes_are_accessible
for movie in all_movies_sorted[0:3]:
print(f"Movie: {movie}")
print(f"Movie Description: {movie.description}")
print(f"Movie Actors: {movie.actors}")
print(f"Movie Rating: {movie.external_rating}")
def test_read():
test = MovieFileCSVReader('CS235Flix\\memory_repository\\Data1000Movies.csv')
test.read_csv_file()
assert len(test.dataset_of_movies) == 1000
assert len(test.dataset_of_actors) == 1985
assert len(test.dataset_of_directors) == 644
assert len(test.dataset_of_genres) == 20
| {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,414 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/domainmodel/review.py | from datetime import datetime
from web_app.domainmodel.movie import Movie
class Review:
def __init__(self, movie: Movie, review_text: str, rating: int):
if review_text == "" or type(review_text) is not str:
self.__review_text = None
else:
self.__review_text = review_text.strip()
if movie is None or type(movie) is not Movie:
self.__movie = None
else:
self.__movie = movie
if rating is None or type(rating) is not int or rating < 1 or rating > 10:
self.__rating = None
else:
self.__rating = rating
datetime_object = datetime.now()
self.__timestamp = datetime_object
@property
def movie(self) -> Movie:
return self.__movie
@property
def review_text(self) -> str:
return self.__review_text
@property
def rating(self) -> int:
return self.__rating
@property
def timestamp(self) -> datetime:
return self.__timestamp
def __repr__(self):
return f"<Movie {self.movie}, Review {self.review_text}, Rating {self.rating}, Time {self.timestamp}>"
def __eq__(self, other):
return self.movie == other.movie and self.review_text == other.review_text and self.rating == other.rating and self.timestamp == other.timestamp | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,415 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/domainmodel/comment_test.py | from datetime import datetime
from domainmodel.movie import Movie
from domainmodel.comment import Comment
def test_comment_init():
movie = Movie("Her", 2013)
comment = Comment(movie, "What year was this movie set in?")
assert comment.movie == movie
assert comment.comment == "What year was this movie set in?"
assert comment.timestamp == datetime.now()
assert comment.parent is None
def test_replies():
movie = Movie("Her", 2013)
comment = Comment(movie, "What year was this movie set in?")
reply = Comment(movie, "Wait nevermind I just Googled it")
comment.add_reply(reply)
assert reply in comment.replies
assert reply.parent == comment
reply2 = Comment(movie, "haha wow")
reply.add_reply(reply2)
assert reply2.parent is comment
reply3 = Comment(movie, "oh my god")
reply2.add_reply(reply3)
assert reply3.parent is comment
reply4 = Comment(Movie("Kill Bill: Volume 1", 2003), "I hope they make a sequel")
comment.add_reply(reply4)
assert reply4.parent is None
comment.remove_reply(reply)
assert reply not in comment.replies
comment.remove_reply(reply4)
assert reply4 not in comment.replies
| {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,416 | pradakeef/CS235Flix-A2-FinalProject | refs/heads/master | /web_app/domainmodel/movie.py | from web_app.domainmodel.genre import Genre
from web_app.domainmodel.actor import Actor
from web_app.domainmodel.director import Director
class Movie:
def __init__(self, title: str, release_year: int):
if title == "" or type(title) is not str:
self.__title = None
else:
self.__title = title.strip()
if release_year is None or type(release_year) is not int or release_year < 1900:
self.__release_year = None
else:
self.__release_year = release_year
self.__director = None
self.__description = None
self.__actors = []
self.__genres = []
self.__runtime_minutes = None
self.__id = None
self.__last_actor = None
@property
def title(self) -> str:
return self.__title
@property
def release_year(self) -> int:
return self.__release_year
@property
def description(self) -> str:
return self.__description
@property
def id(self) -> int:
return self.__id
@property
def last_actor(self):
return self.actors[-1]
@id.setter
def id(self, id: int):
self.__id = id
@description.setter
def description(self, description: str):
if description is "" or type(description) is not str:
self.__description = None
else:
self.__description = description.strip()
@property
def director(self) -> Director:
return self.__director
@director.setter
def director(self, director: Director):
if director is None or type(director) is not Director:
self.__director = None
else:
self.__director = director
@property
def genres(self) -> list:
return self.__genres
@property
def actors(self) -> list:
return self.__actors
@property
def runtime_minutes(self) -> int:
return self.__runtime_minutes
@runtime_minutes.setter
def runtime_minutes(self, runtime: int):
if runtime <= 0:
raise ValueError
else:
self.__runtime_minutes = runtime
def __repr__(self):
return f"<Movie {self.title}, {self.release_year}>"
def __eq__(self, other):
return self.title == other.title and self.release_year == other.release_year
def __lt__(self, other):
return self.__repr__() < other.__repr__()
def __hash__(self):
return hash((self.title, self.release_year))
def add_actor(self, actor: Actor):
if type(actor) is Actor and actor not in self.actors:
self.__actors.append(actor)
def remove_actor(self, actor: Actor):
if actor in self.__actors:
self.__actors.remove(actor)
def add_genre(self, genre: Genre):
if type(genre) is Genre and genre not in self.genres:
self.__genres.append(genre)
def remove_genre(self, genre: Genre):
if genre in self.__genres:
self.__genres.remove(genre) | {"/web_app/home/home.py": ["/web_app/adapters/repository.py", "/web_app/home/services.py"], "/web_app/domainmodel/watchlist.py": ["/web_app/domainmodel/movie.py"], "/web_app/domainmodel/watchlist_test.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/watchlist.py"], "/web_app/adapters/memory_repository.py": ["/web_app/adapters/repository.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/datafilereaders/movie_file_csv_reader.py": ["/web_app/domainmodel/movie.py"], "/web_app/adapters/repository.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/user_test.py": ["/web_app/domainmodel/user.py", "/web_app/domainmodel/movie.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/web_app/home/services.py": ["/web_app/adapters/repository.py"], "/test/unit/test_domain_model.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/watchlist.py", "/web_app/domainmodel/user.py"], "/web_app/domainmodel/comment.py": ["/web_app/domainmodel/movie.py"], "/test/conftest.py": ["/web_app/adapters/repository.py", "/web_app/adapters/memory_repository.py", "/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/user.py": ["/web_app/domainmodel/movie.py", "/web_app/domainmodel/review.py", "/web_app/domainmodel/comment.py", "/web_app/domainmodel/watchlist.py"], "/test/unit/test_file_reader.py": ["/web_app/datafilereaders/movie_file_csv_reader.py"], "/web_app/domainmodel/review.py": ["/web_app/domainmodel/movie.py"]} |
72,417 | AMAPuiu/MQTT | refs/heads/master | /client.py | from utils import *
import logging
import socket
class Switcher():
def got_packet(self, type, msg, addr, client_socket):
name=return_type(type)
method_name="got_" + name
method=getattr(self, method_name, lambda: "Invalid")
return method(client_socket, addr, msg)
def got_connect(self, client_socket, addr, msg):
# List of errors that might appear during parsing
errors = []
# List of extracted data
data = []
# Checks reserved bites from fixed header
reserved = msg[0] & 15
if reserved != 0:
errors.append("Invalid flags in fixed header")
# Gets remaining_length of packet from fixed header
position = 1
msg_length = get_remaining_length(msg, errors, position)
if msg_length == -1:
log_parsing_error(addr,msg,"Connect",errors)
return
position+=1
size = position-1
# Checks if the length of received data is equal to the Remaining_length from fixed header+its size+the first byte
if msg_length+size+1 != len(msg):
errors.append("Remaining_length != length of packet")
# Checks protocol
position, protocol, worked = get_field(position, msg, 2, 1)
if protocol != "MQIsdp":
errors.append("Wrong protocol")
log_parsing_error(addr, msg,"Connect",errors)
send_connack(client_socket, addr, 1)
return
data.append(("Protocol",protocol))
# Checks version
version = msg[position]
if msg[position] != 3:
errors.append("Wrong protocol version")
log_parsing_error(addr, msg, "Connect", errors)
send_connack(client_socket, addr, 1)
return
data.append(("Version",version))
position += 1
# Flags
flags = msg[position]
will_flag = (flags >> 2) & 1
password_flag = (flags >> 6) & 1
user_flag = (flags >> 7) & 1
position += 1
# Stores client ID
position += 2
position, client_id, worked = get_field(position, msg, 2, 1)
if worked == 0:
errors.append("Client ID is not utf-8 encoded")
data.append(("Client ID",client_id))
# Checks if will flag is set
if will_flag == 1:
position, will_topic, worked = get_field(
position, msg, 2, 1)
if worked == 0:
errors.append("Will topic is not utf-8 encoded")
position, will_message, worked = get_field(
position, msg, 2, 0)
data.append(("Will topic",will_topic))
data.append(("Will message",will_message))
user=None
password=None
# Checks if username and password flags are set
if (password_flag)*(user_flag) == 1:
# Stores username and password
position, user, worked = get_field(position, msg, 2, 1)
if worked == 0:
errors.append("User is not utf-8 encoded")
position, password, worked = get_field(position, msg, 2, 0)
elif user_flag == 1:
position, user, worked = get_field(position, msg, 2, 1)
if worked == 0:
errors.append("User is not utf-8 encoded")
else:
position, password, worked = get_field(position, msg, 2, 0)
errors.append("Password is given, but username is not")
data.append(("User",user))
data.append(("Password",password))
# Sends Connack packet with retcode 5
send_connack(client_socket, addr, 0)
# Checks if any errors appeared
if len(errors)==0:
logging.info("{} Connect packet - ok. Data:{}".format(addr, data))
else:
log_parsing_error(addr,msg,"Connect",errors)
def got_publish(self, client_socket, addr, msg):
# List of errors that might appear during parsing
errors = []
# Gets qos level
qos = (msg[0] >> 1) & 3
if qos != 0 and qos != 1 and qos != 2:
errors.append("Invalid qos level")
# Gets remaining_length of packet from fixed header
position = 1
msg_length = get_remaining_length(
msg, errors, position)
if msg_length == -1:
log_parsing_error(addr,msg,"Publish",errors)
return
position+=1
size = position-1
# Gets topic
position, topic, worked = get_field(position, msg, 2, 1)
if worked == 0:
errors.append("Topic is not utf-8 encoded")
if "+" in topic:
errors.append("Contains wildcards:{}".format(topic))
if "#" in topic:
errors.append("Contains wildcards:{}".format(topic))
if "$SYS" in topic:
errors.append("Contains wildcards:{}".format(topic))
# Gets packet_id
if qos == 1 or qos == 2:
packet_id = int.from_bytes(msg[position:position+2], "big")
position += 2
else:
packet_id = None
# Gets message
message = msg[position:len(msg)]
message = message.decode("cp855")
# Append
publish_topic=(topic, qos, message)
# Responds
if qos == 1:
send_puback(client_socket, addr, packet_id)
elif qos == 2:
send_pubrec(client_socket, addr, packet_id)
# Receives pubrel
msg = client_socket.recv(1024)
type = (msg[0]) >> 4
reserved = msg[0] & 15
if type != 6:
errors.append("Pubrel packet wasn't received although Publish happened")
log_parsing_error(addr, msg, "Publish", errors)
return
if reserved != 2:
errors.append("Pubrel: Invalid flags in fixed header")
if len(msg) != 4:
errors.append("Pubrel: Length of received data is bigger than it should be")
msg_length = msg[1]
if msg_length != 2:
errors.append("Pubrel: Invalid length")
packet_id_response = int.from_bytes(msg[2:4], "big")
if packet_id != packet_id_response:
errors.append("Pubrel: Packet ids differ")
send_pubcomp(client_socket, addr, packet_id_response)
# Checks if any errors appeared
if len(errors)==0:
logging.info("{} Publish packet - ok. Packet id:{} Topic:{}".format(addr, packet_id, publish_topic))
else:
log_parsing_error(addr,msg,"Publish",errors)
def got_subscribe(self, client_socket, addr, msg):
# List of errors that might appear during parsing
errors = []
# Checks reserved bites from fixed header
reserved = msg[0] & 15
if reserved != 2:
errors.append("Invalid flags in fixed header")
# Gets remaining_length of packet from fixed header
position = 1
msg_length = get_remaining_length(msg, errors, position)
if msg_length == -1:
log_parsing_error(addr,msg,"Subscribe",errors)
return
position+=1
size = position-1
# Checks if the length of received data is equal to the Remaining_length from fixed header+its size+the first byte
if msg_length+size+1 != len(msg):
errors.append("Bytes have been added")
# Gets packet_ID
packet_ID = int.from_bytes(msg[position:(position+2)], "big")
position += 2
# Gets topics and qos
subscribe_topics = []
if position == msg_length+size+1:
errors.append("There are no topics")
log_parsing_error(addr,msg,"Subscribe",errors)
return
topic = ""
while position != msg_length+size+1:
position, topic, worked = get_field(position, msg, 2, 1)
if worked == 0:
errors.append("Topic is not utf-8 encoded")
qos = msg[position] & 3
if (msg[position] >> 2) != 0:
errors.append("Reserved bytes from qos are malformed")
subscribe_topics.append((topic, qos))
if qos != 0 and qos != 1 and qos != 2:
errors.append("Qos is not 0, 1 or 2")
qos = 0
position += 1
# Sends Suback as respond
send_suback(client_socket, addr, qos, packet_ID)
# Checks if any errors appeared
if len(errors)==0:
logging.info("{} Subscribe packet - ok. Packet id:{} Topics:{}".format(addr, packet_ID, subscribe_topics))
else:
log_parsing_error(addr,msg,"Subscribe",errors)
def got_unsubcribe(self, client_socket, addr, msg):
# List of errors that might appear during parsing
errors = []
# Checks reserved bites from fixed header
reserved = msg[0] & 15
if reserved != 2:
errors.append("Invalid flags in fixed header")
# Gets remaining_length of packet from fixed header
position = 1
msg_length = get_remaining_length(
msg, errors, position)
if msg_length == -1:
log_parsing_error(addr,msg,"Unsubscribe",errors)
return
position+=1
size = position-1
# Gets packet-id
packet_ID = int.from_bytes(msg[position:(position+2)], "big")
position += 2
# Gets topics
if position == msg_length+size+1:
errors.append("There are no topics")
unsubscribe_topics = []
while position != msg_length+size+1:
position, topic, worked = get_field(position, msg, 2, 1)
if worked == 0:
errors.append("Topic is not utf-8 encoded")
unsubscribe_topics.append(topic)
# Checks if there are bytes that will remain unparsed
if position < len(msg):
errors.append("Bytes have been added to the packet")
send_unsuback(client_socket, addr, packet_ID)
# Checks if any errors appeared
if len(errors)==0:
logging.info("{} Unsubscribe packet - ok. Packet id:{} Topics:{}".format(addr, packet_ID, unsubscribe_topics))
else:
log_parsing_error(addr,msg,"Unsubscribe",errors)
def got_pingreq(self, client_socket, addr, msg):
# List of errors that might appear during parsing
errors = []
# Checks reserved bites from fixed header
reserved = msg[0] & 15
if reserved != 0:
errors.append("Invalid flags in fixed header")
msg_length = msg[1]
if msg_length != 0:
errors.append("Invalid length")
send_pingresp(client_socket, addr)
# Checks if any errors appeared
if len(errors)==0:
logging.info("{} Pingreq - ok.".format(addr))
else:
log_parsing_error(addr,msg,"Pingreq",errors)
def got_disconnect(self, client_socket, addr, msg):
# List of errors that might appear during parsing
errors = []
# Checks reserved bites from fixed header
reserved = msg[0] & 15
if reserved != 0:
errors.append("Invalid flags in fixed header")
if len(msg)>2:
errors.append("Bytes have been added to the packet")
if msg[1]!=0:
errors.append("Length is too big")
# Checks if any errors appeared
if len(errors)==0:
logging.info("{} Disconnect - ok.".format(addr))
else:
log_parsing_error(addr,msg,"Disconnect",errors)
def got_unknown(self, client_socket, addr, msg):
log_parsing_error(addr,msg,"Unknown","Unexpected packet")
| {"/client.py": ["/utils.py"], "/mqtt-server3.py": ["/client.py", "/utils.py"]} |
72,418 | AMAPuiu/MQTT | refs/heads/master | /mqtt-server3.py | import socket
from threading import Thread
import sys
import traceback
import logging
from client import *
from utils import log_parsing_error
logging.basicConfig(level=logging.INFO,
format="%(asctime)s:%(levelname)s:%(message)s")
UNKNOWN_PACKET=0
CONNECT_PACKET=1
CONNACK_PACKET=2
PUBLISH_PACKET=3
PUBACK_PACKET=4
PUBREC_PACKET=5
PUBREL_PACKET=6
PUBCOMP_PACKET=7
SUBSCRIBE_PACKET=8
SUBACK_PACKET=9
UNSUBSCRIBE_PACKET=10
UNSUBACK_PACKET=11
PINGREQ_PACKET=12
PINGRESP_PACKET=13
DISCONNECT_PACKET=14
def main():
host = '127.0.0.1'
port = 1883
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind((host, port))
logging.info("Server started...")
server_socket.listen(6)
while True:
client_socket, addr = server_socket.accept()
ip, port = addr
try:
Thread(target=threaded, args=(client_socket, addr,)).start()
except:
logging.info("Thread did not start.")
traceback.print_exc()
server_socket.shutdown(socket.SHUT_RDWR)
server_socket.close()
def threaded(client_socket, addr):
type = 0
while type != DISCONNECT_PACKET: # Disconnect is received
msg = client_socket.recv(1024)
if not msg:
break
type = (msg[0]) >> 4
s=Switcher()
try:
s.got_packet(type,msg,addr,client_socket)
except:
traceback.print_exc()
client_socket.close()
# client_socket.close()
if __name__ == "__main__":
main()
| {"/client.py": ["/utils.py"], "/mqtt-server3.py": ["/client.py", "/utils.py"]} |
72,419 | AMAPuiu/MQTT | refs/heads/master | /utils.py | import socket
import logging
from scapy.contrib.mqtt import *
logging.basicConfig(level=logging.INFO,
format="%(asctime)s:%(levelname)s:%(message)s")
def send_connack(client_socket, addr, code):
mqtt_pck = MQTT(type=2)
payload = MQTTConnack(retcode=code)
connack_pck = mqtt_pck/payload
client_socket.send(bytes(connack_pck))
def send_suback(client_socket, addr, code, id):
mqtt_pck = MQTT(type=9)
payload = MQTTSuback(msgid=id, retcode=code)
suback_pck = mqtt_pck/payload
client_socket.send(bytes(suback_pck))
def send_unsuback(client_socket, addr, id):
mqtt_pck = MQTT(type=11)
payload = MQTTUnsuback(msgid=id)
unsuback_pck = mqtt_pck/payload
client_socket.send(bytes(unsuback_pck))
def send_puback(client_socket, addr, id):
mqtt_pck = MQTT(type=4)
payload = MQTTPuback(msgid=id)
puback_pck = mqtt_pck/payload
client_socket.send(bytes(puback_pck))
def send_pubrec(client_socket, addr, id):
mqtt_pck = MQTT(type=5)
payload = MQTTPubrec(msgid=id)
pubrec_pck = mqtt_pck/payload
client_socket.send(bytes(pubrec_pck))
def send_pubcomp(client_socket, addr, id):
mqtt_pck = MQTT(type=7)
payload = MQTTPubcomp(msgid=id)
pubcomp_pck = mqtt_pck/payload
client_socket.send(bytes(pubcomp_pck))
def send_pingresp(client_socket, addr):
mqtt_pck = MQTT(type=13)
client_socket.send(bytes(mqtt_pck))
def log_parsing_error(addr, msg, type, error):
logging.info("{} Malformed packet: {}. Errors: {}: {}".format(addr, type, error, msg))
def get_field(position, msg, size, matters):
field_length = int.from_bytes(msg[position:(position+size)], "big")
position += size
field = msg[position:(position+field_length)]
ok = 1
try:
field = field.decode("utf-8")
except:
field = field.decode("cp855")
if matters == 1:
ok = 0
position += field_length
return position, field, ok
def get_remaining_length(msg, errors, p):
multiplier = 1
value = 0
while True:
encodedByte = msg[p]
value += (encodedByte & 127) * multiplier
multiplier *= 128
p += 1
if multiplier > 128*128*128:
errors.append("Remaining_length is too big")
value = -1
if (encodedByte & 128) == 0:
break
return value
def return_type(type):
if type==1:
return "connect"
elif type==3:
return "publish"
elif type==8:
return "subscribe"
elif type==10:
return "unsubscribe"
elif type==12:
return "pingreq"
elif type==14:
return "disconnect"
else:
return "unknown" | {"/client.py": ["/utils.py"], "/mqtt-server3.py": ["/client.py", "/utils.py"]} |
72,420 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /cartpole/ql_bins_cartpole.py | from __future__ import print_function, division
from builtins import range
import collections
from operator import itemgetter
import random
import gym
import numpy as np
import matplotlib.pyplot as plt
learning_rate = 1e-2
discount_factor = 0.9
n_bins = 10
cart_pos_bins = np.linspace(-2.4, 2.4, n_bins)
cart_vel_bins = np.linspace(-2, 2, n_bins)
pole_ang_bins = np.linspace(-0.4, 0.4, n_bins)
pole_vel_bins = np.linspace(-3.5, 3.5, n_bins)
Q = collections.defaultdict(lambda: collections.defaultdict(lambda: 0))
def extend_bins(bins, value):
max_val = np.max(bins)
while max_val < value:
max_val += bins[1] - bins[0]
bins = np.append(bins, max_val)
min_val = np.min(bins)
while min_val > value:
min_val -= bins[1] - bins[0]
bins = np.insert(bins, 0, min_val)
return bins
def get_bin(bins, value):
ind = np.where(bins >= value)[0][0]
return (bins[ind] + bins[ind-1]) / 2.0
def get_discreet_state(cart_pos, cart_vel, pole_ang, pole_vel):
global cart_pos_bins
cart_pos_bins = extend_bins(cart_pos_bins, cart_pos)
global cart_vel_bins
cart_vel_bins = extend_bins(cart_vel_bins, cart_vel)
global pole_ang_bins
pole_ang_bins = extend_bins(pole_ang_bins, pole_ang)
global pole_vel_bins
pole_vel_bins = extend_bins(pole_ang_bins, pole_vel)
return get_bin(cart_pos_bins, cart_pos), get_bin(cart_vel_bins, cart_vel), get_bin(pole_ang_bins,
pole_ang), get_bin(pole_vel_bins,
pole_vel)
def q_argmax(d):
if len(d) == 0:
return random.randint(0, 1)
else:
return max(d.items(), key=itemgetter(1))[0]
def q_max(d):
if len(d) == 0:
return 0.0
else:
return max(d.items(), key=itemgetter(1))[1]
def ql_update(observation, action, reward, next_observation):
Q[observation][action] = Q[observation][action] + \
learning_rate * (reward + discount_factor * q_max(Q[next_observation]) -
Q[observation][action])
def epsilon_greedy_select(observation, epsilon):
r = random.random()
if r < epsilon:
return random.randint(0, 1)
else:
return q_argmax(Q[observation])
def play_one_episode(env, epsilon):
observation = get_discreet_state(*env.reset())
done = False
t = 0
while not done and t < 10000:
t += 1
# Choose E-greedy action
action = epsilon_greedy_select(observation, epsilon)
# Take action, observe
next_observation, reward, done, info = env.step(action)
next_observation = get_discreet_state(*next_observation)
# Adjust reward if episode ended
if done and t < 199:
reward = -300
# Update
ql_update(observation, action, reward, next_observation)
if done:
break
observation = next_observation
return t
def play_multiple_episodes(env, episodes):
episode_lengths = np.empty(episodes)
for i in range(episodes):
epsilon = 1.0 / np.sqrt(1 + i)
episode_lengths[i] = play_one_episode(env, epsilon)
return episode_lengths
if __name__ == '__main__':
env = gym.make('CartPole-v0')
episode_lengths = play_multiple_episodes(env, 10000)
plt.plot(episode_lengths)
plt.show()
# play a final set of episodes
# env = wrappers.Monitor(env, 'my_awesome_dir', force=True)
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,421 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /atari/breakout.py | import random
import gym
import numpy
from tqdm import tqdm as progress_bar
import tensorflow as tf
from models.neural_network import BreakoutNeuralNetwork
from PIL import Image
from visualization import plot_cost_to_go
from visualization import plot_running_avg
IMG_SIZE = (210, 160)
class Experience:
def __init__(self, experience_size=100):
self.experience_size = experience_size
self.buffer = []
def sample(self, sample_size=4):
return random.sample(self.buffer, sample_size)
def add_sample(self, state, action, reward, new_state):
state = convert_array(state)
action = convert_array(action)
reward = convert_array([reward])
new_state = convert_array(new_state)
if len(self.buffer) >= self.experience_size:
self.buffer.pop()
self.buffer.insert(0, [state, action, reward, new_state])
def convert_array(observation):
return numpy.array(observation).reshape((1, -1)).astype(numpy.float32)
def to_state_action_value(model, sample, gamma):
next_action_predictions = model.predict(sample[3])
return sample[2] + gamma * numpy.max(next_action_predictions[0])
def map_list_to_array(func, li):
return numpy.array(list(map(func, li))).reshape((len(li), -1))
def update(model, target_model, experience, gamma, experience_replay, n_actions=2, n_samples=4):
if len(experience.buffer) >= n_samples and experience_replay:
samples = experience.sample(n_samples)
else:
samples = [experience.buffer[0]]
if len(experience.buffer) == n_samples or not experience_replay:
states = map_list_to_array(lambda sample: sample[0], samples)
state_action_values = numpy.empty((n_samples, n_actions))
state_action_values[:] = map_list_to_array(
lambda sample: to_state_action_value(target_model, sample, gamma), samples)
model.update(states, state_action_values)
def convert_image(observation):
image = observation[55:-15, 7:-7]
#image = Image.fromarray(image.astype(numpy.int))
#image = image.resize((int(IMG_SIZE[0] / 2), int(IMG_SIZE[1] / 2)))
image = numpy.average(numpy.array(image), axis=2)
image = image / 255.0
return image.reshape((1, image.shape[0], image.shape[1], 1)).astype(numpy.float32)
def frames_to_state(frames_list):
return numpy.hstack(frames_list)
def update_frame_list(frames, next_observation):
frames.pop()
frames.insert(0, next_observation)
def play_one_episode(session, environment, epsilon, gamma=0.99, max_steps=10000, experience_replay=True,
use_dual_model=True):
observation = environment.reset()
observation = convert_image(observation)
dims = (None, observation.shape[1], observation.shape[2], 1)
frames_per_state = 1
frames = [observation for _ in range(frames_per_state)]
done = False
time_step = 0
total_reward = 0
experience = Experience()
n_actions = environment.action_space.n
n_samples = 4
model = BreakoutNeuralNetwork(session, dims, n_actions, environment)
if use_dual_model:
target_model = BreakoutNeuralNetwork(session, dims, n_actions, environment)
else:
target_model = model
session.run(tf.global_variables_initializer())
while not done and time_step < max_steps:
time_step += 1
# Choose E-greedy action
state = frames_to_state(frames)
action = model.sample_action(state, epsilon)
# Take action, observe
next_observation, reward, done, info = environment.step(action)
next_observation = convert_image(next_observation)
# Update state and get new state
update_frame_list(frames, next_observation)
next_state = frames_to_state(frames)
# Adjust reward if episode ended
total_reward += reward
# Save experience
experience.add_sample(state, action, reward, next_state)
# Update
update(model, target_model, experience, gamma, experience_replay, n_actions=n_actions, n_samples=n_samples)
# Update dual network
if use_dual_model and time_step % 100 == 0:
update(target_model, target_model, experience, gamma, experience_replay, n_actions=n_actions, n_samples=n_samples)
if done:
break
return total_reward
def play_multiple_episodes(environment, episodes, experience_replay, use_dual_model):
with tf.Session() as session:
total_rewards = numpy.empty(episodes)
for i in progress_bar(range(episodes), desc='Playing episode'):
epsilon = 1.0 / numpy.sqrt(1 + i)
total_rewards[i] = play_one_episode(session, environment, epsilon, experience_replay, use_dual_model)
plot_running_avg(total_rewards)
plot_cost_to_go(environment.observation_space)
if __name__ == '__main__':
play_multiple_episodes(gym.make('Breakout-v0'), 300, experience_replay=False, use_dual_model=True)
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,422 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /mountaincar/approximation_function/ql_mountaincar.py | import gym
import numpy
from tqdm import tqdm as progress_bar
from feature_transformers import MountainCarRBFFeatureTransformer
from models.numpy import SGDStateActionModel
from visualization import plot_cost_to_go
from visualization import plot_running_avg
def play_one_episode(environment, epsilon, gamma=0.99, max_steps=10000):
observation = environment.reset()
done = False
time_step = 0
total_reward = 0
sampler = environment.observation_space
feature_transformer = MountainCarRBFFeatureTransformer(sampler)
model = SGDStateActionModel(environment, feature_transformer)
while not done and time_step < max_steps:
time_step += 1
# Choose E-greedy action
action = model.sample_action(observation, epsilon)
# Take action, observe
next_observation, reward, done, info = environment.step(action)
# Adjust reward if episode ended
total_reward += reward
if done:
reward = 100
# Update
next_action_predictions = model.predict(next_observation)
state_action_value = reward + gamma * numpy.max(next_action_predictions[0])
model.update(observation, action, state_action_value)
if done:
break
observation = next_observation
return total_reward
def play_multiple_episodes(environment, episodes):
total_rewards = numpy.empty(episodes)
for i in progress_bar(range(episodes), desc='Playing episode'):
epsilon = 1.0 / numpy.sqrt(1 + i)
total_rewards[i] = play_one_episode(environment, epsilon)
plot_running_avg(total_rewards)
plot_cost_to_go(environment.observation_space)
if __name__ == '__main__':
play_multiple_episodes(gym.make('MountainCar-v0'), 300)
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,423 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /mountaincar/approximation_function/nsteps_ql_mountaincar.py | import gym
import numpy
from tqdm import tqdm as progress_bar
from feature_transformers import MountainCarRBFFeatureTransformer
from models import SGDModel
from visualization import plot_cost_to_go
from visualization import plot_running_avg
def calculate_target(rewards, state_action_values):
return rewards[-1] + sum(state_action_values[:-1])
def update_nstep_rewards(reward, rewards, gamma, time_step, n_step):
rewards = [e * gamma for e in rewards]
if time_step >= n_step:
rewards = rewards[1:] + [reward]
else:
rewards.append(reward)
return rewards
def update_nstep_state_action_values(state_action_value, state_action_values, gamma, time_step, n_step):
state_action_values = [e * gamma for e in state_action_values]
if time_step >= n_step:
state_action_values = state_action_values[1:] + [state_action_value]
else:
state_action_values.append(state_action_value)
return state_action_values
def play_one_episode(environment, epsilon, n_step=1, gamma=0.99, max_steps=10000):
observation = environment.reset()
done = False
time_step = 0
total_reward = 0
sampler = environment.observation_space
feature_transformer = MountainCarRBFFeatureTransformer(sampler)
model = SGDModel(environment, feature_transformer)
rewards = []
state_action_values = []
while not done and time_step < max_steps:
time_step += 1
# Choose E-greedy action
action = model.sample_action(observation, epsilon)
# Take action, observe
next_observation, reward, done, info = environment.step(action)
# Adjust reward if episode ended
total_reward += reward
if done:
reward = 100
# Update
next_action_predictions = model.predict(next_observation)
rewards = update_nstep_rewards(reward, rewards, gamma, time_step, n_step)
state_action_values = update_nstep_state_action_values(numpy.max(next_action_predictions[0]),
state_action_values, gamma, time_step, n_step)
target = calculate_target(rewards, state_action_values)
model.update(observation, action, target)
if done:
break
observation = next_observation
return total_reward
def play_multiple_episodes(environment, episodes):
total_rewards = numpy.empty(episodes)
for i in progress_bar(range(episodes), desc='Playing episode'):
epsilon = 1.0 / numpy.sqrt(1 + i)
total_rewards[i] = play_one_episode(environment, epsilon, n_step=3)
plot_running_avg(total_rewards)
plot_cost_to_go(environment.observation_space)
if __name__ == '__main__':
play_multiple_episodes(gym.make('MountainCar-v0'), 300)
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,424 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /models/tensorflow.py | import numpy
import tensorflow as tf
class SimpleGD:
def __init__(self, session, loss, variables, learning_rate=0.01):
self.learning_rate = learning_rate
self.session = session
self.loss = loss
self.w = variables['w']
self.b = variables['b']
self.x = variables['x']
self.y = variables['y']
self.gradients = tf.gradients(loss, [self.w, self.b])
def partial_fit(self, x, y):
for model_parameter, gradient in zip([self.w, self.b], self.gradients):
new_model_parameter = self.session.run((model_parameter - self.learning_rate * gradient),
feed_dict={self.x: x, self.y: y})
self.session.run(model_parameter.assign(new_model_parameter))
class SimpleSGDRegressor():
def __init__(self, session, dimensions, learning_rate, scope_id='0'):
self.session = session
with tf.variable_scope('SimpleSGDRegressor' + scope_id, reuse=tf.AUTO_REUSE):
self.w = tf.get_variable('w', shape=(1, dimensions), initializer=tf.zeros_initializer(), dtype=tf.float32)
self.b = tf.get_variable('b', shape=(1,), initializer=tf.zeros_initializer(), dtype=tf.float32)
x = tf.placeholder(dtype=tf.float32, shape=(1, dimensions), name='x')
y = tf.placeholder(dtype=tf.float32, shape=(1,), name='y')
variables = {'w': self.w, 'b': self.b, 'x': x, 'y': y}
init = tf.global_variables_initializer()
self.session.run(init)
loss = (y - tf.matmul(self.w, tf.transpose(x)) - self.b) ** 2
self.gradient_descent = SimpleGD(self.session, loss, variables, learning_rate)
def partial_fit(self, x, y):
self.gradient_descent.partial_fit(x, y)
def fit(self, X, Y):
for x, y in zip(X, Y):
self.partial_fit(x.reshape((1, -1)), y)
def predict(self, x):
return self.session.run(tf.matmul(self.w, tf.transpose(x)) + self.b).ravel()
class SGDModel:
def __init__(self, environment, feature_transformer, learning_rate=0.01):
self.session = tf.Session()
self.env = environment
self.models = []
self.feature_transformer = feature_transformer
for i in range(environment.action_space.n):
model = SimpleSGDRegressor(self.session, feature_transformer.dimensions, learning_rate, scope_id=str(i))
model.partial_fit(feature_transformer.transform([environment.reset()]), [0])
self.models.append(model)
def predict(self, state):
transformed_state = self.feature_transformer.transform([state])
result = numpy.stack([m.predict(transformed_state.astype(numpy.float32)) for m in self.models]).T
return result
def update(self, state, action, state_action_value):
transformed_state = self.feature_transformer.transform([state])
self.models[action].partial_fit(transformed_state.astype(numpy.float32), [state_action_value])
def sample_action(self, state, epsilon):
if numpy.random.random() < epsilon:
return self.env.action_space.sample()
else:
return numpy.argmax(self.predict(state))
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,425 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /models/numpy.py | import numpy
class SimpleSGDRegressor():
def __init__(self, dimensions, learning_rate):
self.w = numpy.zeros(shape=(1, dimensions))
self.b = numpy.zeros(shape=(1,))
self.learning_rate = learning_rate
def gradients(self, x, y):
dl_dw = -(y - self.predict(x))
return numpy.dot(dl_dw, x), dl_dw
def partial_fit(self, x, y):
dw, db = self.gradients(x, y)
self.w = self.w - self.learning_rate * dw
self.b = self.b - self.learning_rate * db
def fit(self, X, Y):
for x, y in zip(X, Y):
self.partial_fit(x.reshape((1, -1)), y)
def predict(self, x):
return (numpy.dot(self.w, x.T) + self.b).ravel()
class SGDStateActionModel:
def __init__(self, environment, feature_transformer, learning_rate=0.01):
self.models = []
self.feature_transformer = feature_transformer
for i in range(environment.action_space.n):
model = SimpleSGDRegressor(feature_transformer.dimensions, learning_rate)
model.partial_fit(feature_transformer.transform([environment.reset()]), [0])
self.models.append(model)
def predict(self, state):
transformed_state = self.feature_transformer.transform([state])
result = numpy.stack([m.predict(transformed_state.astype(numpy.float32)) for m in self.models]).T
return result
def update(self, state, action, state_action_value):
transformed_state = self.feature_transformer.transform([state])
self.models[action].partial_fit(transformed_state.astype(numpy.float32), [state_action_value])
def sample_action(self, state, epsilon):
if numpy.random.random() < epsilon:
return self.env.action_space.sample()
else:
return numpy.argmax(self.predict(state))
class SGDStateModel:
def __init__(self, environment, feature_transformer, learning_rate=0.01):
self.regressor = SimpleSGDRegressor(feature_transformer.dimensions, learning_rate)
self.regressor.partial_fit(feature_transformer.transform([environment.reset()]), [0])
self.feature_transformer = feature_transformer
def predict(self, state):
transformed_state = self.feature_transformer.transform([state])
return self.regressor.predict(transformed_state.astype(numpy.float32))
def update(self, state, state_value):
transformed_state = self.feature_transformer.transform([state])
self.regressor.partial_fit(transformed_state.astype(numpy.float32), [state_value])
class ActorCriticModel:
def __init__(self, feature_transformer, learning_rate=0.01):
self.feature_transformer = feature_transformer
self.learning_rate = learning_rate
self.w = numpy.zeros(shape=(1, feature_transformer.dimensions))
self.actions = [0, 1]
def get_action_distributions(self, action_probabilities):
distributions = numpy.zeros(shape=(action_probabilities.shape[0] + 1,))
for i in range(1, action_probabilities.shape[0]):
distributions[i] = distributions[i-1] + action_probabilities[i-1]
return distributions
def exponential_preferences(self, state):
transformed = numpy.hstack([self.feature_transformer.transform(state, action) for action in self.actions])
state_action_preferences = numpy.dot(self.w, transformed)
return numpy.exp(state_action_preferences), transformed
def policy_ln_gradient(self, state):
exp, transformed = self.exponential_preferences(state)
dexp_dw = exp * transformed
sum_exp = numpy.sum(exp)
return (transformed * sum_exp - numpy.sum(dexp_dw)) / sum_exp
def update(self, state, target, state_value):
self.w += self.learning_rate * (target - state_value) * self.policy_ln_gradient(state)
def sample_action(self, state):
exp, _ = self.exponential_preferences(state)
action_probabilities = exp / numpy.sum(exp)
action_distributions = self.get_action_distributions(action_probabilities)
r = numpy.random.uniform()
return self.actions[numpy.where(action_distributions < r)[0][-1]]
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,426 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /cartpole/approximation_function/ql_cartpole.py | import gym
import matplotlib.pyplot as plt
import numpy
import numpy.random as random
from tqdm import tqdm as progress_bar
from feature_transformers import CartPoleRBFFeatureTransformer
from models import SGDModel
gamma = 0.99
class CartPoleSampler:
def __init__(self):
self.cart_position_interval = (-1.0, 1.0)
self.cart_velocity_interval = (-1.0, 1.0)
self.pole_angle_interval = (-1.0, 1.0)
self.pole_velocity_interval = (-1.0, 1.0)
def sample(self):
return (
random.uniform(self.cart_position_interval[0], self.cart_position_interval[1]),
random.uniform(self.cart_velocity_interval[0], self.cart_velocity_interval[1]),
random.uniform(self.pole_angle_interval[0], self.pole_angle_interval[1]),
random.uniform(self.pole_velocity_interval[0], self.pole_velocity_interval[1])
)
def play_one_episode(environment, epsilon, sampler):
observation = environment.reset()
done = False
time_step = 0
feature_transformer = CartPoleRBFFeatureTransformer(sampler)
model = SGDModel(environment, feature_transformer)
while not done and time_step < 10000:
time_step += 1
# Choose E-greedy action
action = model.sample_action(observation, epsilon)
# Take action, observe
next_observation, reward, done, info = environment.step(action)
# Adjust reward if episode ended
if done and time_step < 199:
reward = -300
# Update
next_action_predictions = model.predict(next_observation)
state_action_value = reward + gamma * numpy.max(next_action_predictions[0])
model.update(observation, action, state_action_value)
if done:
break
observation = next_observation
return time_step
def play_multiple_episodes(environment, episodes):
sampler = CartPoleSampler()
episode_lengths = numpy.empty(episodes)
for i in progress_bar(range(episodes), desc='Playing episode'):
epsilon = 1.0 / numpy.sqrt(1 + i)
episode_lengths[i] = play_one_episode(environment, epsilon, sampler)
plt.plot(episode_lengths)
plt.savefig('episode_lengths.png')
if __name__ == '__main__':
play_multiple_episodes(gym.make('CartPole-v0'), 300)
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,427 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /samplers.py | import random
import numpy
class CompoundSampler:
def __init__(self, environment, actions):
self.state_sampler = environment.observation_space
self.actions = actions
def sample(self):
state_sample = self.state_sampler.sample()
action_sample = numpy.array(random.sample([0, 1], 1))
return numpy.hstack((state_sample, action_sample))
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,428 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /mountaincar/approximation_function/actor_critic_mountaincar.py | import gym
import numpy
from tqdm import tqdm as progress_bar
from feature_transformers import MountainCarCompoundRBFFeatureTransformer
from feature_transformers import MountainCarRBFFeatureTransformer
from models.numpy import ActorCriticModel
from models.numpy import SGDStateModel
from samplers import CompoundSampler
from visualization import plot_cost_to_go
from visualization import plot_running_avg
def play_one_episode(environment, gamma=0.99, max_steps=10000):
observation = environment.reset()
done = False
time_step = 0
total_reward = 0
state_sampler = environment.observation_space
compound_sampler = CompoundSampler(environment, numpy.array([0, 1]))
state_feature_transformer = MountainCarRBFFeatureTransformer(state_sampler)
compound_feature_transformer = MountainCarCompoundRBFFeatureTransformer(compound_sampler)
state_value_model = SGDStateModel(environment, state_feature_transformer)
policy_model = ActorCriticModel(compound_feature_transformer)
while not done and time_step < max_steps:
time_step += 1
# Choose action via softmax
action = policy_model.sample_action(observation)
# Take action, observe
next_observation, reward, done, info = environment.step(action)
# Adjust reward if episode ended
total_reward += reward
if done:
reward = 100
# Update
target = reward + gamma * state_value_model.predict(next_observation)
state_value = state_value_model.predict(observation)
policy_model.update(observation, action, target, state_value)
if done:
break
observation = next_observation
return total_reward
def play_multiple_episodes(environment, episodes):
total_rewards = numpy.empty(episodes)
for i in progress_bar(range(episodes), desc='Playing episode'):
total_rewards[i] = play_one_episode(environment)
plot_running_avg(total_rewards)
plot_cost_to_go(environment.observation_space)
if __name__ == '__main__':
play_multiple_episodes(gym.make('MountainCar-v0'), 300)
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,429 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /models/neural_network.py | import tensorflow as tf
import numpy
class NeuralNetwork:
def __init__(self, session, input, layers, output_size, learning_rate, scope='model'):
self.session = session
self.input = input
self.layers = layers
with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
self.target = tf.placeholder(tf.float32, shape=(None, output_size), name='G')
self.loss_function = tf.reduce_mean(tf.square(self.target - self.layers[-1]))
self.learning_rate = learning_rate
self.predict_op = self.layers[-1]
self.train_op = tf.train.GradientDescentOptimizer(self.learning_rate).minimize(self.loss_function)
def predict(self, input):
return self.session.run(
self.predict_op,
feed_dict={
self.input: input
}
)
def update(self, input, target):
return self.session.run(
self.train_op,
feed_dict={
self.input: input,
self.target: target
}
)
class MountainCarNeuralNetwork(NeuralNetwork):
def __init__(self, session, n_input, num_actions, environment, learning_rate=0.001, scope='mountaincar_network'):
self.environment = environment
with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
input_variable = tf.placeholder(tf.float32, shape=(None, n_input), name='X')
layers = []
output = tf.contrib.layers.fully_connected(input_variable, num_actions)
layers.append(output)
output = tf.contrib.layers.fully_connected(output, num_actions)
layers.append(output)
super(MountainCarNeuralNetwork, self).__init__(session, input_variable, layers, num_actions, learning_rate)
def sample_action(self, state, epsilon):
if numpy.random.random() < epsilon:
return self.environment.action_space.sample()
else:
return numpy.argmax(self.predict(state))
class BreakoutNeuralNetwork(NeuralNetwork):
def __init__(self, session, input_shape, num_actions, environment, learning_rate=0.001, scope='breakout_network'):
self.environment = environment
with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
input_variable = tf.placeholder(tf.float32, shape=input_shape, name='X')
layers = []
layers.append(tf.layers.conv2d(inputs=input_variable, filters=32, kernel_size=[5, 5], padding="same",
activation=tf.nn.relu))
layers.append(tf.layers.max_pooling2d(inputs=layers[-1], pool_size=[2, 2], strides=2))
pooling_input_size = int(layers[-1].shape[1] * layers[-1].shape[2] * layers[-1].shape[3])
layers.append(tf.reshape(layers[-1], [-1, pooling_input_size]))
layers.append(tf.contrib.layers.fully_connected(layers[-1], num_actions))
super(BreakoutNeuralNetwork, self).__init__(session, input_variable, layers, num_actions, learning_rate)
def sample_action(self, state, epsilon):
if numpy.random.random() < epsilon:
return self.environment.action_space.sample()
else:
return numpy.argmax(self.predict(state))
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,430 | kanesoban/deep-reinforcement-learning-course | refs/heads/master | /feature_transformers.py | import numpy
from sklearn.kernel_approximation import RBFSampler
from sklearn.pipeline import FeatureUnion
from sklearn.preprocessing import StandardScaler
class RBFFeatureTransformer:
def __init__(self, sampler, gammas, n_components=500, n_samples=20000):
observation_examples = numpy.array([sampler.sample() for _ in range(n_samples)])
scaler = StandardScaler()
scaler.fit(observation_examples)
self.gammas = gammas
samplers = [("rbf{}".format(i), RBFSampler(gamma=gammas[i], n_components=n_components)) for i in range(4)]
featurizer = FeatureUnion(samplers)
example_features = featurizer.fit_transform(scaler.transform(observation_examples))
self.dimensions = example_features.shape[1]
self.scaler = scaler
self.featurizer = featurizer
def transform(self, observations):
scaled = self.scaler.transform(observations)
return self.featurizer.transform(scaled)
class CartPoleRBFFeatureTransformer(RBFFeatureTransformer):
def __init__(self, environment):
gammas = [0.05, 1.0, 0.5, 0.1]
super(CartPoleRBFFeatureTransformer, self).__init__(environment, gammas, n_components=1000)
class MountainCarRBFFeatureTransformer(RBFFeatureTransformer):
def __init__(self, environment):
gammas = [5.0, 2.0, 1.0, 0.5]
super(MountainCarRBFFeatureTransformer, self).__init__(environment, gammas)
class MountainCarCompoundRBFFeatureTransformer:
def __init__(self, environment, n_actions=2):
self.state_feature_transformer = MountainCarRBFFeatureTransformer(environment)
self.dimensions = self.state_feature_transformer.dimensions + n_actions
def transform(self, observations, actions):
transformed_state = self.state_feature_transformer.transform(observations)
return numpy.hstack((transformed_state, actions))
| {"/atari/breakout.py": ["/models/neural_network.py"], "/mountaincar/approximation_function/ql_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py"], "/mountaincar/approximation_function/nsteps_ql_mountaincar.py": ["/feature_transformers.py"], "/cartpole/approximation_function/ql_cartpole.py": ["/feature_transformers.py"], "/mountaincar/approximation_function/actor_critic_mountaincar.py": ["/feature_transformers.py", "/models/numpy.py", "/samplers.py"]} |
72,483 | kmasaya/lopet | refs/heads/master | /tools/pet.import.py | #!/usr/bin/python3
# coding: UTF-8
import csv
import sys
import os
sys.path.append(os.pardir)
from settings import DB
from models import PetCategory
FILENAME = 'PET_ALL.CSV'
CSV_FIELD = (
'petname',
)
def main():
reader = csv.DictReader(open(FILENAME, 'r', encoding="cp932"), CSV_FIELD)
DB.begin()
for i, row in enumerate(reader):
PetCategory.create(
parent=None,
name=row['petname'],
)
DB.commit()
if __name__ == "__main__":
main()
| {"/tools/pet.import.py": ["/settings.py", "/models.py"], "/index.py": ["/settings.py", "/views.py", "/models.py"], "/views.py": ["/settings.py", "/models.py", "/locales.py"], "/tools/city.makejs.py": ["/models.py"], "/tools/city.import.py": ["/settings.py", "/models.py"], "/models.py": ["/settings.py"]} |
72,484 | kmasaya/lopet | refs/heads/master | /settings.py | #!/usr/bin/python3
import os
import peewee
DEBUG = True
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
STATIC_DIR = os.path.join(BASE_DIR, 'statics')
TEMPLATE_DIR = os.path.join(BASE_DIR, 'views')
JUNK_FILE_DIR = os.path.join(BASE_DIR, 'junks')
IMAGE_FILE_DIR = os.path.join(BASE_DIR, 'images')
PROFILE_IMAGE_DIR = os.path.join(IMAGE_FILE_DIR, 'profile')
ENTRY_IMAGE_DIR = os.path.join(IMAGE_FILE_DIR, 'entry')
ALLOW_IMAGE_TYPE = ('.png', '.jpeg', '.gif')
THUMBNAIL_MAX = 1024
SESSION_LIFE_TIME = 4*24*60*60
PAGE_PER_ENTRY = 30
DB_FILE_PATH = BASE_DIR + '/lopet.sqlite3'
DB = peewee.SqliteDatabase(DB_FILE_PATH, threadlocals=True)
LENGTH = {
'username': 6,
'password': 6,
}
URL = {
'index': '/',
'contact': '/contact/',
'offer': '/offer/',
'offer_form': '/offer/<offer_type>/',
'offer_lose': '/offer/lose/',
'offer_conservation': '/offer/conservation/',
'offer_witness': '/offer/witness/',
'search': '/search/',
'search_page': '/search/<page:int>/',
'search_from': '/search/<offer_type>/',
'search_from_page': '/search/<offer_type>/<page:int>/',
'search_lose': '/search/lose/',
'search_lose_page': '/search/lose/<page:int>/',
'search_conservation': '/search/conservation/',
'search_conservation_page': '/search/conservation/<page:int>/',
'search_witness': '/search/witness/',
'search_witness_page': '/search/witness/<page:int>/',
'search_city': '/search/city/',
'search_city_id': '/search/city/<city_id:int>/',
'search_city_id_page': '/search/city/<city_id:int>/<page:int>/',
'search_type': '/search/type/',
'search_type_id': '/search/type/<type_id:int>/',
'search_type_id_page': '/search/type/<type_id:int>/<page:int>/',
'search_entry': '/e/<entry_id:int>/',
'account': '/account/',
'setting': '/setting/',
'mypage': '/mypage/',
'mypage_page': '/mypage/<page:int>/',
'edit': '/edit/<entry_id:int>/',
'signin': '/signin/',
'signup': '/signup/',
'signout': '/signout/',
'user': '/u/<user_id:int>/',
'user_page': '/u/<user_id:int>/<page:int>/',
}
OFFER_TYPES = {0: 'lose', 1: 'conservation', 2: 'witness', 9: 'full'}
OFFER_NAMES = {OFFER_TYPES[0]: '่ฟทๅญ', OFFER_TYPES[1]: 'ไฟ่ญท', OFFER_TYPES[2]: '็ฎๆ', OFFER_TYPES[9]: 'ๅ
จใฆ'}
SEX_TYPES = {0: 'unknown', 1: 'male', 2: 'female'}
SEX_NAMES = {SEX_TYPES[0]: 'ไธๆ', SEX_TYPES[1]: 'ใชใน', SEX_TYPES[2]: 'ใกใน'}
MAIL_SENDTO = ''
SMTP_SERVER = ''
SMTP_PORT = 587
SMTP_USERNAME = ''
SMTP_PASSWORD = ''
if DEBUG:
STATICS_URL = '/statics/'
IMAGES_URL = '/images/'
ENTRY_IMAGES_URL = '/images/entry/'
PROFILE_IMAGE_URL = '/images/profile/'
else:
STATICS_URL = 'http://statics.example.jp/'
IMAGES_URL = 'http://images.example.jp/'
ENTRY_IMAGES_URL = 'http://images.example.jp/entry/'
PROFILE_IMAGE_URL = 'http://images.example.jp/profile/' | {"/tools/pet.import.py": ["/settings.py", "/models.py"], "/index.py": ["/settings.py", "/views.py", "/models.py"], "/views.py": ["/settings.py", "/models.py", "/locales.py"], "/tools/city.makejs.py": ["/models.py"], "/tools/city.import.py": ["/settings.py", "/models.py"], "/models.py": ["/settings.py"]} |
72,485 | kmasaya/lopet | refs/heads/master | /tools/kana.py | #!python32
#coding:utf8
# copyright: http://www.shido.info/py/python_kana.html
"""
ใใชๅคๆใฉใคใใฉใช
ๅคๆ้ขๆฐ:
zj(s): s ใซๅซใพใใ ๅ
จ่งใซใฟใซใใใฒใใใชใซๅคๆ
jz(s): s ใซๅซใพใใ ใฒใใใชใๅ
จ่งใซใฟใซใใซๅคๆ
zh(s): s ใซๅซใพใใ ๅ
จ่งใซใฟใซใใๅ่งใซใฟใซใใซๅคๆ
jh(s): s ใซๅซใพใใ ใฒใใใชใๅ่งใซใฟใซใใซๅคๆ
hz(s): s ใซๅซใพใใ ๅ่งใซใฟใซใใๅ
จ่งใซใฟใซใใซๅคๆ
hj(s): s ใซๅซใพใใ ๅ่งใซใฟใซใใใฒใใใชใซๅคๆ
ใใผใ
str.translate ใกใฝใใใใคใใฃใฆๅคๆใ
ใใใซๅ ใใฆไปฅไธใฎๆไฝใ่กใ
ๅ่งใซใฟใซใใใๅคๆใใๅ ดๅ:
ๅ่งใซใฟใซใใฎๆฟ้ณใฏ2ๆๅญใง่กจใใใใฎใงใใใใใๆญฃ่ฆ่กจ็พใ็จใใฆๅถๅพกๆๅญ1ๆๅญ (€ -- )
ใซใใใใใฆใใ translate ใ็จใใฆๅ
จ่งใฎๆฟ้ณใซ็ฝฎใๆใใใ
ๅนณไปฎๅใใๅคๆใใๅ ดๅ:
ใใใ ใด ใซ็ฝฎใๆใใฆใใ translate ใงๅคๆใใใ
ๅนณไปฎๅใซๅคๆใใๅ ดๅ
translate ใฎ็ตๆใฎ ใด ใ ใใใซ็ฝฎใๆใใใ
"""
import re, functools
C_OFF = 0x80
S_HIR = 'ใใใใใใผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ' \
'ใใใใใใใใใใใใใใใใใกใคใฆใจใชใซใฌใญใฎใฏใฒใตใธใปใพใฟใใใใใใใใใใใใใใ' \
'ใฃใใใ
ใใใใ
ใ' \
'ใใใใใใใใใใใ ใขใฅใงใฉใฐใณใถในใผใด' \
'ใฑใดใทใบใฝ' \
S_ZEN = 'ใใใใใใผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ๏ผ' \
'ใขใคใฆใจใชใซใญใฏใฑใณใตใทในใปใฝใฟใใใใใใใใใใใใใใใใใ ใกใขใคใฆใจใฉใชใซใฌใญใฏใฒใณ' \
'ใใกใฃใฅใงใฉใฃใฅใง' \
'ใฌใฎใฐใฒใดใถใธใบใผใพใใใ
ใใใใใใใใด' \
'ใใใใใ'
S_SEI = '๏ฝค๏ฝก๏ฝข๏ฝฃ -0123456789' \
'๏ฝฑ๏ฝฒ๏ฝณ๏ฝด๏ฝต๏ฝถ๏ฝท๏ฝธ๏ฝน๏ฝบ๏ฝป๏ฝผ๏ฝฝ๏ฝพ๏ฝฟ๏พ๏พ๏พ๏พ๏พ๏พ
๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏ฝฆ๏พ' \
'๏ฝฏ๏ฝง๏ฝจ๏ฝฉ๏ฝช๏ฝซ๏ฝฌ๏ฝญ๏ฝฎ'
S_DAK ='๏ฝถ๏ฝท๏ฝธ๏ฝน๏ฝบ๏ฝป๏ฝผ๏ฝฝ๏ฝพ๏ฝฟ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏พ๏ฝณ'
S_HAT ='๏พ๏พ๏พ๏พ๏พ'
TENN, MARU = '๏พ', '๏พ'
L_DAK = [c+TENN for c in S_DAK] + [c+MARU for c in S_HAT]
S_CCH = ''.join(chr(i+C_OFF) for i in range(len(L_DAK)))
S_HAN = S_SEI + S_CCH
L_HAN = list(S_SEI) + L_DAK
H_DAK = dict(zip(L_DAK, S_CCH))
R_DAK = re.compile('[{}]{}|[{}]{}'.format(S_DAK, TENN, S_HAT, MARU))
def comb(*fs):
return lambda x: functools.reduce(lambda y,f:f(y), fs, x)
def trans(k,v):
assert len(k)==len(v)
tbl = str.maketrans(k,v) if type(v) is str else \
str.maketrans(dict(zip(k,v)))
return lambda s: s.translate(tbl)
def replace(c0, c1): return lambda s: s.replace(c0,c1)
subd = lambda s: R_DAK.sub(lambda m:H_DAK[m.group()], s)
zj=comb(trans(S_ZEN, S_HIR), replace('ใด', 'ใใ'))
jz=comb(replace('ใใ', 'ใด'), trans(S_HIR, S_ZEN))
zh=trans(S_ZEN, L_HAN)
jh=comb(replace('ใใ', 'ใด'), trans(S_HIR, L_HAN))
hz=comb(subd, trans(S_HAN, S_ZEN))
hj=comb(subd, trans(S_HAN, S_HIR), replace('ใด', 'ใใ'))
def test(name, fun, s):
print(name, 'ok' if s==fun(s) else 'ng', sep=' .... ')
if __name__=='__main__':
test('zen>han>zen', comb(zh, hz), S_ZEN)
test('zen>hira>zen', comb(zj, jz), S_ZEN)
s_hir = S_HIR.replace('ใด', 'ใใ')
test('hira>zen>hira', comb(jz, zj), s_hir)
test('hira>han>hira', comb(jh, hj), s_hir)
s_han=''.join(L_HAN)
test('han>hira>han', comb(hj, jh), s_han)
test('han>zen>han', comb(hz, zh), s_han)
| {"/tools/pet.import.py": ["/settings.py", "/models.py"], "/index.py": ["/settings.py", "/views.py", "/models.py"], "/views.py": ["/settings.py", "/models.py", "/locales.py"], "/tools/city.makejs.py": ["/models.py"], "/tools/city.import.py": ["/settings.py", "/models.py"], "/models.py": ["/settings.py"]} |
72,486 | kmasaya/lopet | refs/heads/master | /index.py | #!/usr/bin/python3
import hashlib
from bottle import run, get, post, static_file, error, request, abort
from settings import STATIC_DIR, URL, LENGTH, PROFILE_IMAGE_DIR, ENTRY_IMAGE_DIR, OFFER_TYPES, DEBUG
from views import render, request_is_get, signin, signout, form_get, session_user, mail_send, upload_images_save, _
from models import *
@get(URL['index'])
@get('/index.py')
def index_view():
template_name = 'index.html'
return render(template_name)
@get(URL['contact'])
@post(URL['contact'])
def contact_view():
template_name = 'contact.html'
if request_is_get():
return render(template_name)
name = form_get('name')
from_address = form_get('email')
body = form_get('body', '')
agree = form_get('cb', False)
if not agree:
return render(template_name, message=_('Please agree'))
if not name or not from_address:
return render(template_name, message=_('has not been entered'))
send = mail_send(from_address=from_address, subject=_('Was accepted - example.jp'), body="%s\n\n%s" % (name, body))
if not send:
return render(template_name, message=_('An error has occurred'))
return render(template_name, message=_('Has been sent'))
@get(URL['signup'])
@post(URL['signup'])
def signup_view():
template_name = 'signup.html'
if request_is_get():
return render(template_name)
username = form_get('username')
password = form_get('password')
email = form_get('email')
agree = request.forms.get('cb', False)
if not agree:
return render(template_name, message=_('Please agree'))
if not (username.isalnum() and password.isalnum()):
return render(template_name, message=_('Username and Password is alphabet or num'))
if User.select().where(User.username == username, User.password == password).count():
return render(template_name, message=_('User exist'))
if not (len(username) >= LENGTH['username'] and len(password) >= LENGTH['password']):
return render(template_name, message=_('Username or Password not enough'))
user = User.create(
username=username,
password=password,
password_hash=hashlib.sha256(password.encode()).hexdigest(),
email=email
)
UserProfile.create(
user=user
)
signin(user)
return render('redirect.html', url=URL['setting'])
@get(URL['signin'])
@post(URL['signin'])
def signin_view():
template_name = 'signin.html'
if request_is_get():
return render(template_name)
username = form_get('username')
password = form_get('password')
try:
user = User.get(User.username == username, User.password == password, User.is_active == True)
except:
return render(template_name, message=_('username or password is an error'))
signin(user)
return render('redirect.html', url=URL['index'])
@get(URL['signout'])
def signout_view():
signout()
return render('redirect.html', url=URL['index'])
@get(URL['account'])
def account_view():
template_name = 'account.html'
return render(template_name)
@get(URL['mypage'])
@get(URL['mypage_page'])
def mypage_view(page=1):
template_name = 'mypage.html'
user = session_user()
if user is None:
abort(404, _('access denied'))
if request_is_get():
entries = Entry.select().where(Entry.user == user, Entry.is_active == True).order_by(Entry.created_at.desc())
return render(template_name, entries=entries, page=page)
@get(URL['edit'])
@post(URL['edit'])
def edit_view(entry_id):
template_name = 'edit.html'
user = session_user()
if user is None:
abort(404, _('access denied'))
try:
entry = Entry.get(Entry.user == user, Entry.id == entry_id, Entry.is_active == True)
except:
abort(404)
cities = City.select()
pet_categories = PetCategory.select()
entry_images = Entry_Image.select().where(Entry_Image.user == user, Entry_Image.entry == entry, Entry_Image.is_active == True)
if request_is_get():
return render(template_name, entry=entry, entry_images=entry_images, cities=cities, pet_categories=pet_categories)
if form_get('remove-image'):
remove_image_id = form_get('image_id')
try:
image = Entry_Image.get(Entry_Image.user == user, Entry_Image.id == remove_image_id)
except:
abort(404)
image.is_active = False
image.save()
return render('redirect.html', url='')
if form_get('close'):
close_entry_id = form_get('entry_id')
agree = form_get('cb', False)
if not agree:
return render('redirect.html', url='')
try:
entry = Entry.get(Entry.user == user, Entry.id == close_entry_id)
except:
abort(404)
entry.is_open = False
entry.save()
return render('redirect.html', url=URL['mypage'])
try:
city = City.get(City.id == int(form_get('city')))
city_note = form_get('city_note', '')
pet_category = PetCategory.get(PetCategory.id == int(form_get('pet_category', '')))
pet_category_note = form_get('pet_category_note', '')
petname = form_get('petname', '')
special = form_get('special', '')
note = form_get('note', '')
find_at = form_get('date', datetime.datetime.now())
except:
return render(template_name, entry=entry, entry_images=entry_images, cities=cities, pet_categories=pet_categories)
entry.petcategory = pet_category
entry.petcategory_note = pet_category_note
entry.city = city
entry.city_note = city_note
entry.name = petname
entry.special = special
entry.note = note
entry.find_at = datetime.datetime.strptime(find_at, '%Y-%m-%d %H:%M')
entry.modified_at = datetime.datetime.now()
entry.save()
upload_images = request.files.getlist('images[]')
upload_images_save('entry', upload_images, user, entry)
return render('redirect.html', url=URL['search_entry'].replace('<entry_id:int>', str(entry.id)))
@get(URL['setting'])
@post(URL['setting'])
def setting_view():
template_name = 'setting.html'
user = session_user()
if user is None:
abort(404, _('access denied'))
if request_is_get():
user_images = UserProfile_Image.select().where(UserProfile_Image.user == user, UserProfile_Image.is_active == True)
return render(template_name, user_images=user_images)
if form_get('remove-image'):
remove_image_id = form_get('image_id')
try:
image = UserProfile_Image.get(UserProfile_Image.user == user, UserProfile_Image.id == remove_image_id)
except:
abort(404)
image.is_active = False
image.save()
return render('redirect.html', url='')
profile = UserProfile.get(UserProfile.user == user)
user.email = form_get('email', '')
user.nickname = form_get('nickname', 'anonymous')
profile.body = form_get('body', '')
user.save()
profile.save()
upload_images = request.files.getlist('images[]')
upload_images_save('profile', upload_images, user)
return render('redirect.html', url=URL['user'].replace('<user_id:int>', str(user.id)))
@get(URL['offer'])
def offer_view():
template_name = 'offer.html'
return render(template_name)
@get(URL['offer_form'])
@post(URL['offer_form'])
def offer_form_view(offer_type):
template_name = 'offer_form.html'
user = session_user()
if user is None:
return render('redirect.html', url=URL['offer'])
cities = City.select()
pet_categories = PetCategory.select()
if request_is_get():
return render(template_name, cities=cities, pet_categories=pet_categories, offer_type=offer_type)
for (id, name) in OFFER_TYPES.items():
if name == offer_type:
offer_id = id
break
try:
city = City.get(City.id == int(form_get('city')))
city_note = form_get('city_note', '')
pet_category = PetCategory.get(PetCategory.id == int(form_get('pet_category', '')))
pet_category_note = form_get('pet_category_note', '')
petname = form_get('petname', '')
special = form_get('special', '')
note = form_get('note', '')
find_at = form_get('date', datetime.datetime.now())
except:
return render(template_name, cities=cities, pet_categories=pet_categories, offer_type=offer_type)
entry = Entry.create(
user=user,
type=offer_id,
petcategory=pet_category,
petcategory_note=pet_category_note,
city=city,
city_note=city_note,
name=petname,
special=special,
note=note,
find_at=datetime.datetime.strptime(find_at, '%Y-%m-%d %H:%M'),
modified_at=datetime.datetime.now(),
)
upload_images = request.files.getlist('images[]')
upload_images_save('entry', upload_images, user, entry)
return render('redirect.html', url=URL['search'])
@get(URL['search_city'])
def search_city_view():
template_name = 'search_city.html'
if request_is_get():
cities = City.select().where(City.parent == None)
return render(template_name, cities=cities)
@get(URL['search_type'])
def search_type_view():
template_name = 'search_type.html'
if request_is_get():
petcategories = PetCategory.select()
return render(template_name, petcategories=petcategories)
@get(URL['search_city_id'])
@get(URL['search_city_id_page'])
def search_city_id_view(city_id, page=1):
template_name = 'search_list.html'
try:
city = City.get(City.id == city_id)
if city.parent is not None:
city = city.parent
except:
abort(404)
if request_is_get():
entries = Entry.select().join(City).where(((Entry.city == city)|(City.parent == city)), Entry.is_active == True)
print('---')
print(entries.count())
return render(template_name, entries=entries.order_by(Entry.created_at.desc()), city=city, page=page)
@get(URL['search_type_id'])
@get(URL['search_type_id_page'])
def search_type_id_view(type_id, page=1):
template_name = 'search_list.html'
try:
petcategory = PetCategory.get(PetCategory.id == type_id)
except:
abort(404)
if request_is_get():
entries = Entry.select().where(Entry.petcategory == petcategory, Entry.is_active == True)
return render(template_name, entries=entries.order_by(Entry.created_at.desc()), petcategory=petcategory, page=page)
@get(URL['search'])
@get(URL['search_page'])
@get(URL['search_from'])
@get(URL['search_from_page'])
def search_from_view(offer_type='full', page=1):
template_name = 'search_list.html'
for (id, name) in OFFER_TYPES.items():
if name == offer_type:
offer_id = id
break
if request_is_get():
if offer_id == 9:
entries = Entry.select().where(Entry.is_active == True)
else:
entries = Entry.select().where(Entry.type == offer_id, Entry.is_active == True)
return render(template_name, entries=entries.order_by(Entry.created_at.desc()), page=page, offer_type=offer_type)
@get(URL['search_entry'])
@post(URL['search_entry'])
def search_entry_view(entry_id):
template_name = 'search_entry.html'
try:
entry = Entry.get(Entry.id == entry_id, Entry.is_active == True)
except:
abort(404)
if request_is_get():
entry_images = Entry_Image.select().where(Entry_Image.entry == entry, Entry_Image.is_active == True)
entry_comments = Comment.select().where(Comment.entry == entry, Comment.is_active == True)
return render(template_name, entry=entry, entry_images=entry_images, entry_comments=entry_comments)
user = session_user()
if user is None:
return render('redirect.html', url=URL['signup'])
body = form_get('body')
parent = form_get('parent')
if body is None:
return render('redirect.html', url='')
Comment.create(
user=user,
entry=entry,
parent=parent,
body=body,
)
return render('redirect.html', url='')
@get(URL['user'])
@get(URL['user_page'])
def user_view(user_id, page=1):
template_name = 'user.html'
try:
page_user = User.get(User.id == user_id, User.is_active == True)
page_user_profile = UserProfile.get(UserProfile.user == page_user)
except:
abort(404)
if request_is_get():
page_user_images = UserProfile_Image.select().where(UserProfile_Image.user == page_user, UserProfile_Image.is_active == True)
entries = Entry.select().where(Entry.user == page_user, Entry.is_active == True).order_by(Entry.created_at.desc())
return render(template_name, page_user=page_user, page_user_profile=page_user_profile, entries=entries, page_user_images=page_user_images, page=page)
@get('/statics/<filename:path>')
def send_statics(filename):
return static_file(filename, root=STATIC_DIR)
@get('/images/entry/<filename:path>')
def send_static_images(filename):
return static_file(filename, root=ENTRY_IMAGE_DIR)
@get('/images/profile/<filename:path>')
def send_static_profiles(filename):
return static_file(filename, root=PROFILE_IMAGE_DIR)
@error(404)
def error404(err):
return render('404.html', error=err)
@error(500)
def error500(err):
return render('500.html', error=err)
if __name__ == '__main__':
if DEBUG:
run(host='localhost', port=8080, reloader=True, debug=True)
else:
run(server='cgi')
| {"/tools/pet.import.py": ["/settings.py", "/models.py"], "/index.py": ["/settings.py", "/views.py", "/models.py"], "/views.py": ["/settings.py", "/models.py", "/locales.py"], "/tools/city.makejs.py": ["/models.py"], "/tools/city.import.py": ["/settings.py", "/models.py"], "/models.py": ["/settings.py"]} |
72,487 | kmasaya/lopet | refs/heads/master | /views.py | #!/usr/bin/python
import os
import hashlib
import datetime
import time
import imghdr
from PIL import Image as PILImage
import smtplib
from email.mime.text import MIMEText
from email.header import Header
from email.utils import formatdate
from bottle import jinja2_template as template
from bottle import response, request
from settings import URL, SESSION_LIFE_TIME, MAIL_SENDTO, SMTP_PASSWORD, SMTP_PORT, SMTP_SERVER, SMTP_USERNAME, PAGE_PER_ENTRY, OFFER_TYPES, OFFER_NAMES, ENTRY_IMAGE_DIR, JUNK_FILE_DIR, PROFILE_IMAGE_DIR, ALLOW_IMAGE_TYPE, THUMBNAIL_MAX, IMAGE_FILE_DIR, IMAGES_URL, STATICS_URL, PROFILE_IMAGE_URL, ENTRY_IMAGES_URL
from models import Session, Entry_Image, UserProfile_Image
from locales import locales
def gettext(string, locale='ja'):
if string in locales[locale]:
return locales[locale][string]
return string
_ = gettext
def mail_send(from_address, subject, body, encode='UTF-8'):
def create_message(from_address, to_address, subject, body, encode):
message = MIMEText(body, "plain", encode)
message["Subject"] = str(Header(subject, encode))
message["From"] = from_address
message["To"] = to_address
message["Date"] = formatdate()
return message
def sendmail(from_address, to_address, message):
smtp = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)
smtp.login(SMTP_USERNAME, SMTP_PASSWORD)
smtp.sendmail(from_address, [to_address], message.as_string())
smtp.close()
message = create_message(from_address, MAIL_SENDTO, subject, body, encode)
sendmail(from_address, MAIL_SENDTO, message)
return True
def request_is_get():
if request.method == 'GET':
return True
return False
def form_get(name, default=None):
try:
return request.forms.decode().get(name, default)
except:
return request.forms.get(name, default)
def signin(user):
sid = hashlib.sha256(repr(time.time()).encode()).hexdigest()
response.set_cookie('sid', sid, max_age=SESSION_LIFE_TIME, path='/')
response.set_cookie('username', user.username, max_age=SESSION_LIFE_TIME, path='/')
Session.create(
user=user,
sid=sid
)
def signout():
sid = request.get_cookie('sid', None)
if sid:
response.delete_cookie('sid')
response.delete_cookie('username')
query = Session.delete().where(Session.sid == sid)
query.execute()
def session_user():
sid = request.get_cookie('sid', None)
username = request.get_cookie('username', None)
try:
session = Session.get(Session.sid == sid)
except:
signout()
return None
if session.accessed_at < datetime.datetime.now() - datetime.timedelta(seconds=SESSION_LIFE_TIME):
signout()
return None
if session.user.username != username:
return None
if session.user.is_active is False:
return None
return session.user
def make_thumbnail(filename, base_path):
(name, ext) = os.path.splitext(filename)
original_filename = name + ".original" + ext
original_filepath = os.path.join(base_path, original_filename)
base_filepath = os.path.join(base_path, filename)
try:
img = PILImage.open(base_filepath)
img.save(original_filepath)
img.thumbnail((THUMBNAIL_MAX, THUMBNAIL_MAX), PILImage.ANTIALIAS)
img.save(base_filepath)
del img
except:
pass
def upload_images_save(upload_type, upload_images, user, entry=None):
for upload_image in upload_images:
file_ext = '.' + imghdr.what(upload_image.file, h=None)
if file_ext not in ALLOW_IMAGE_TYPE:
(name, ext) = os.path.splitext(upload_image.filename)
filename = '%s%s' % (datetime.datetime.now(), ext)
upload_image.save(os.path.join(JUNK_FILE_DIR, filename))
else:
if upload_type == 'entry':
entry_image_save(upload_image, user, entry, file_ext)
elif upload_type == 'profile':
profile_image_save(upload_image, user, file_ext)
def entry_image_save(upload_image, user, entry, file_ext):
filename = '%s-%s' % (entry.id, file_ext)
image = Entry_Image.create(
user=user,
entry=entry,
filename=filename,
)
save_filename = '%s-%s%s' % (entry.id, image.id, file_ext)
image.filename = save_filename
image.save()
upload_image.save(os.path.join(ENTRY_IMAGE_DIR, save_filename))
make_thumbnail(image.filename, ENTRY_IMAGE_DIR)
def profile_image_save(upload_image, user, file_ext):
filename = '%s-%s' % (user.id, file_ext)
image = UserProfile_Image.create(
user=user,
filename=filename,
)
save_filename = '%s-%s%s' % (user.id, image.id, file_ext)
image.filename = save_filename
image.save()
upload_image.save(os.path.join(PROFILE_IMAGE_DIR, save_filename))
make_thumbnail(image.filename, PROFILE_IMAGE_DIR)
def render(template_name, **kwargs):
return template(template_name, kwargs, request=request, user=session_user(), URL=URL, _=_, form_get=form_get, page_per_entry=PAGE_PER_ENTRY, offer_types=OFFER_TYPES, offer_names=OFFER_NAMES, STATICS_URL=STATICS_URL, IMAGES_URL=IMAGES_URL, PROFILE_IMAGE_URL=PROFILE_IMAGE_URL, ENTRY_IMAGES_URL=ENTRY_IMAGES_URL)
| {"/tools/pet.import.py": ["/settings.py", "/models.py"], "/index.py": ["/settings.py", "/views.py", "/models.py"], "/views.py": ["/settings.py", "/models.py", "/locales.py"], "/tools/city.makejs.py": ["/models.py"], "/tools/city.import.py": ["/settings.py", "/models.py"], "/models.py": ["/settings.py"]} |
72,488 | kmasaya/lopet | refs/heads/master | /tools/city.makejs.py | #!/usr/bin/python3
import sys
import os
import json
sys.path.append(os.pardir)
from models import City
def main():
cities = City.select()
city_dict = {}
for city in cities:
if city.parent is None:
city_dict[city.id] = []
city_dict[city.id].append({'id': city.id, 'name': city.name})
else:
city_dict[city.parent.id].append({'id': city.id, 'name': city.name})
print(json.dumps(city_dict, ensure_ascii=False))
if __name__ == '__main__':
main()
| {"/tools/pet.import.py": ["/settings.py", "/models.py"], "/index.py": ["/settings.py", "/views.py", "/models.py"], "/views.py": ["/settings.py", "/models.py", "/locales.py"], "/tools/city.makejs.py": ["/models.py"], "/tools/city.import.py": ["/settings.py", "/models.py"], "/models.py": ["/settings.py"]} |
72,489 | kmasaya/lopet | refs/heads/master | /locales.py | #!/usr/bin/python3
locales = {
'ja': {
'Please agree': 'ๅฉ็จ่ฆ็ดใซๅๆใใฆไธใใ',
'has not been entered': 'ๅ
ฅๅๆผใใใใใพใ',
'Was accepted - lopet': 'ๅ็ใใใพใใ',
'An error has occurred': 'ใจใฉใผใ็บ็ใใพใใ',
'Has been sent': '้ไฟกใใใพใใ',
'Username and Password is alphabet or num': 'ใฆใผใถๅใจใในใฏใผใใฏ่ฑๆฐๅญใงๅ
ฅๅใใฆใใ ใใ',
'User exist': 'ใฆใผใถใๆขใซๅญๅจใใพใ',
'Username or Password not enough': 'ใฆใผใถๅใใในใฏใผใใฎๆๅญๆฐใ่ถณใใพใใ',
'username or password is an error': 'ใฆใผใถๅใใในใฏใผใใซ่ชคใใใใใพใ',
'access denied': 'ใขใฏใปในใงใใพใใ',
'name': 'ๅๅ',
'email address': 'Eใกใผใซใขใใฌใน',
'body': 'ๆฌๆ',
'Send': '้ไฟก',
'Prefectural': '้ฝ้ๅบ็',
'City': 'ๅธ็บๆ',
'City note': 'ไป่ฟ',
'Pet Category': 'ใใใใฎ็จฎ้ก',
'Pet Category note': 'ใใใใฎ็จฎ้ก่ฉณ็ดฐ',
'Lose Date': 'ๆฅๆ',
'Pet name': 'ใใใใฎๅๅ',
'Special': '็นๅพด',
'Note': '่ฃ่ถณไบ้
',
'note': 'no',
'Image(Multiple)': '็ปๅ(่คๆฐ้ธๆๅฏ)',
'Register': '็ป้ฒ',
'Remove': 'ๅ้ค',
'Entry Close': 'ๆ็จฟใ้ใใ',
'Entry Remove': 'ใจใณใใชใๅ้ค',
'register': '็ป้ฒ',
'Comment': 'ใณใกใณใ',
'Nickname': 'ใใใฏใใผใ ',
'change': 'ๅคๆด',
'username': 'ใฆใผใถๅ',
'password': 'ใในใฏใผใ',
'signin': 'ใญใฐใคใณ',
'signup': 'ใฆใผใถ็ป้ฒ',
'6 or more characters': '6ๆๅญไปฅไธ',
'Input in any': '',
}
} | {"/tools/pet.import.py": ["/settings.py", "/models.py"], "/index.py": ["/settings.py", "/views.py", "/models.py"], "/views.py": ["/settings.py", "/models.py", "/locales.py"], "/tools/city.makejs.py": ["/models.py"], "/tools/city.import.py": ["/settings.py", "/models.py"], "/models.py": ["/settings.py"]} |
72,490 | kmasaya/lopet | refs/heads/master | /tools/city.import.py | #!/usr/bin/python3
# coding: UTF-8
import csv
import sys
import os
sys.path.append(os.pardir)
import kana
from settings import DB
from models import City
FILENAME = 'KEN_ALL.CSV'
CSV_FIELD = (
'tmp1',
'tmp2',
'tmp3',
'ken-yomigana',
'shi-yomigana',
'tmp4',
'ken',
'shi',
'tmp5',
'tmp6',
'tmp7',
'tmp8',
'tmp9',
'tmp10',
'tmp11',
)
def main():
reader = csv.DictReader(open(FILENAME, 'r', encoding="cp932"), CSV_FIELD)
DB.begin()
for i, row in enumerate(reader):
if i == 0:
continue
if not i % 1000:
print(i)
cities = City.select().where(City.name == row['ken'])
if not cities.count():
parent = City.create(
parent=None,
name=row['ken'],
yomigana=kana.hj(row['ken-yomigana'])
)
else:
parent = City.get(City.name == row['ken'])
cities = City.select().where(City.name == row['shi'])
if not cities.count():
City.create(
parent=parent,
name=row['shi'],
yomigana=kana.hj(row['shi-yomigana'])
)
DB.commit()
if __name__ == "__main__":
main()
| {"/tools/pet.import.py": ["/settings.py", "/models.py"], "/index.py": ["/settings.py", "/views.py", "/models.py"], "/views.py": ["/settings.py", "/models.py", "/locales.py"], "/tools/city.makejs.py": ["/models.py"], "/tools/city.import.py": ["/settings.py", "/models.py"], "/models.py": ["/settings.py"]} |
72,491 | kmasaya/lopet | refs/heads/master | /models.py | #!/usr/bin/python3
import datetime
import os
from peewee import Model as PeeweeModel, ForeignKeyField, CharField, TextField, BooleanField, IntegerField, DateTimeField
from settings import DB, DB_FILE_PATH, OFFER_TYPES, SEX_TYPES
class BaseModel(PeeweeModel):
class Meta:
database = DB
class User(BaseModel):
username = CharField(max_length=16, unique=True)
password = CharField(max_length=64)
password_hash = CharField(max_length=512)
email = CharField(max_length=128, null=True)
nickname = CharField(max_length=32, default='anonymous')
fullname = CharField(max_length=32, null=True)
telephone = CharField(max_length=32, null=True)
created_at = DateTimeField(default=datetime.datetime.now)
is_active = BooleanField(default=True)
class UserProfile(BaseModel):
user = ForeignKeyField(User, unique=True)
body = TextField(default='')
class UserProfile_Image(BaseModel):
user = ForeignKeyField(User)
filename = CharField(max_length=32)
body = TextField(null=True)
sort_order = IntegerField(default=0)
created_at = DateTimeField(default=datetime.datetime.now)
is_active = BooleanField(default=True)
class PetCategory(BaseModel):
parent = ForeignKeyField('self', null=True)
name = CharField(max_length=32, unique=True)
body = TextField(default='')
class City(BaseModel):
parent = ForeignKeyField('self', null=True)
name = CharField(max_length=32)
yomigana = CharField(max_length=32)
class Entry(BaseModel):
user = ForeignKeyField(User)
type = IntegerField(choices=tuple(OFFER_TYPES.items()))
petcategory = ForeignKeyField(PetCategory)
city = ForeignKeyField(City)
name = CharField(max_length=32)
petcategory_note = CharField(max_length=32, default='')
city_note = CharField(max_length=32, default='')
sex = IntegerField(choices=tuple(SEX_TYPES.items()), default=0)
length = IntegerField(default=0)
scale = IntegerField(default=0)
age = IntegerField(default=100)
special = TextField(default='')
note = TextField(default='')
find_at = DateTimeField()
modified_at = DateTimeField()
created_at = DateTimeField(default=datetime.datetime.now)
is_open = BooleanField(default=True)
is_active = BooleanField(default=True)
class Entry_Image(BaseModel):
user = ForeignKeyField(User)
entry = ForeignKeyField(Entry, related_name='image')
filename = CharField(max_length=32)
body = TextField(null=True)
sort_order = IntegerField(default=0)
created_at = DateTimeField(default=datetime.datetime.now)
is_active = BooleanField(default=True)
class Comment(BaseModel):
user = ForeignKeyField(User)
entry = ForeignKeyField(Entry)
parent = ForeignKeyField('self', null=True)
body = TextField()
created_at = DateTimeField(default=datetime.datetime.now)
is_active = BooleanField(default=True)
class Message(BaseModel):
send = ForeignKeyField(User, related_name='send')
to = ForeignKeyField(User, related_name='to')
parent = ForeignKeyField('self', null=True)
title = CharField(max_length=32)
body = TextField()
created_at = DateTimeField(default=datetime.datetime.now)
readed_at = DateTimeField(null=True)
is_active = BooleanField(default=True)
class Session(BaseModel):
user = ForeignKeyField(User)
sid = CharField(max_length=512)
accessed_at = DateTimeField(default=datetime.datetime.now)
created_at = DateTimeField(default=datetime.datetime.now)
if __name__ == '__main__':
if not os.path.exists(DB_FILE_PATH):
User.create_table()
UserProfile.create_table()
UserProfile_Image.create_table()
PetCategory.create_table()
City.create_table()
Entry_Image.create_table()
Entry.create_table()
Comment.create_table()
Message.create_table()
Session.create_table()
| {"/tools/pet.import.py": ["/settings.py", "/models.py"], "/index.py": ["/settings.py", "/views.py", "/models.py"], "/views.py": ["/settings.py", "/models.py", "/locales.py"], "/tools/city.makejs.py": ["/models.py"], "/tools/city.import.py": ["/settings.py", "/models.py"], "/models.py": ["/settings.py"]} |
72,495 | miketwo/morse | refs/heads/master | /tests/test_advanced.py | # -*- coding: utf-8 -*-
import morse
import pytest
# Parameterized testing. Change the test cases to generate more.
@pytest.mark.parametrize("input_string, expected", [
("abc 123", ".- -... -.-.|.---- ..--- ...--"),
("AbC 123", ".- -... -.-.|.---- ..--- ...--"),
(" AbC 123 ", ".- -... -.-.|.---- ..--- ...--"),
("Hey, not a bad implementation", ".... . -.--|-. --- -|.-|-... .- -..|.. -- .--. .-.. . -- . -. - .- - .. --- -.")
])
def test_encode(input_string, expected):
assert morse.translate.encode(input_string) == expected
@pytest.mark.parametrize("input_string, expected", [
(".- -... -.-.|.---- ..--- ...--", "ABC 123"),
(".... . -.--|-. --- -|.-|-... .- -..|.. -- .--. .-.. . -- . -. - .- - .. --- -.", "HEY NOT A BAD IMPLEMENTATION")
])
def test_decode(input_string, expected):
assert morse.translate.decode(input_string) == expected
| {"/tests/test_advanced.py": ["/morse/__init__.py"], "/tests/test_basic.py": ["/morse/__init__.py"]} |
72,496 | miketwo/morse | refs/heads/master | /tests/test_basic.py | # -*- coding: utf-8 -*-
import unittest
import morse
class BasicTestSuite(unittest.TestCase):
"""Docs here."""
def test_cyclic(self):
# We should be able to make a round trip with encoding/decoding
aString = "HERE IS A STRING TO TEST 12345"
result = morse.translate.decode(morse.translate.encode(aString))
self.assertEqual(aString, result)
def test_cyclic2(self):
aString = "HERE IS A STRING TO TEST 12345"
result = morse.translate.decode(morse.translate.encode(aString))
self.assertEqual(aString, result)
if __name__ == '__main__':
unittest.main()
| {"/tests/test_advanced.py": ["/morse/__init__.py"], "/tests/test_basic.py": ["/morse/__init__.py"]} |
72,497 | miketwo/morse | refs/heads/master | /morse/translate.py | # -*- coding: utf-8 -*-
# Morse Code Translation Project
# For any alpha numeric input translate the input into morse code
# using the following guidelines:
# 1. Use the table at the following web address as a guide:
# https://en.wikipedia.org/wiki/Morse_code#/media/File:International_Morse_Code.svg
# 2. Ignore case
# 3. Put spaces ' ' between individual letters and pipes '|' between words
# 4. So the fragments "abc 123" would translate to .- -... -.-.|.---- ..--- ...--
# omit punctuation
# Nice to have
# 1. Translating from morse code to text
# 2. Integrating with an api
# 3. Test Driven
import string
GLOBAL_TRANSLATION_DICT = {
'A': '.-', 'B': '-...', 'C': '-.-.',
'D': '-..', 'E': '.', 'F': '..-.',
'G': '--.', 'H': '....', 'I': '..',
'J': '.---', 'K': '-.-', 'L': '.-..',
'M': '--', 'N': '-.', 'O': '---',
'P': '.--.', 'Q': '--.-', 'R': '.-.',
'S': '...', 'T': '-', 'U': '..-',
'V': '...-', 'W': '.--', 'X': '-..-',
'Y': '-.--', 'Z': '--..', ' ': '|',
'0': '-----', '1': '.----', '2': '..---',
'3': '...--', '4': '....-', '5': '.....',
'6': '-....', '7': '--...', '8': '---..',
'9': '----.',
}
# Create the reverse so we can also go from morse to text
GLOBAL_REVERSE_TRANSLATION = dict((v, k) for (k, v) in GLOBAL_TRANSLATION_DICT.items())
GLOBAL_REVERSE_TRANSLATION[' '] = ''
def clean_up_string(aString):
tmp = aString.upper()
tmp = tmp.translate(None, string.punctuation)
tmp = tmp.strip()
return tmp
def encode(aString):
tmp = clean_up_string(aString)
# This next line converts each character in the string by using the
# translation hash, joining them all with spaces.
tmp = " ".join(map(lambda x: GLOBAL_TRANSLATION_DICT[x], tmp))
tmp = tmp.replace(" | ", "|")
return tmp
def decode(morse):
morse = morse.replace("|", " | ")
# we split into words in order to covert by groups instead of character-by-
# character
morse = morse.split()
tmp = "".join(map(lambda x: GLOBAL_REVERSE_TRANSLATION[x], morse))
return tmp
| {"/tests/test_advanced.py": ["/morse/__init__.py"], "/tests/test_basic.py": ["/morse/__init__.py"]} |
72,498 | miketwo/morse | refs/heads/master | /scripts/translate.py | #!/usr/bin/env python
# encoding: utf-8
import argparse
import morse
DESC = '''
DESCRIPTION
translate is a program to translate morse code
USAGE
# Translate to morse code
translate.py "text to translate"
- . -..- -|- ---|- .-. .- -. ... .-.. .- - .
# Or in reverse
translate.py -r "- . -..- -|- ---|- .-. .- -. ... .-.. .- - ."
TEXT TO TRANSLATE
NOTES
Case is ignored. All text is internally converted to uppercase.
Punctuation is ignored.
'''
def parse_args():
parser = argparse.ArgumentParser(
description=DESC,
formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument(
'text',
help=("Text or morse code to translate"))
parser.add_argument(
'-r', '--reverse', action="store_true",
help=("Translate morse code back to text"))
args = parser.parse_args()
return args
def main():
args = parse_args()
if args.reverse:
print morse.translate.decode(args.text)
else:
print morse.translate.encode(args.text)
if __name__ == '__main__':
main()
| {"/tests/test_advanced.py": ["/morse/__init__.py"], "/tests/test_basic.py": ["/morse/__init__.py"]} |
72,499 | miketwo/morse | refs/heads/master | /morse/__init__.py | # -*- coding: utf-8 -*-
__version__ = '0.0.1'
__author__ = 'Michael Ricks-Aherne'
# Import all submodules here
import translate
| {"/tests/test_advanced.py": ["/morse/__init__.py"], "/tests/test_basic.py": ["/morse/__init__.py"]} |
72,500 | mithem/Stater | refs/heads/master | /stater_server.py | from Stater import server
import argparse
if __name__ == "__main__":
p = argparse.ArgumentParser()
p.add_argument("--hostname", "-host", type=str, default="localhost")
p.add_argument("--port", "-p", type=int, default=8084)
p.add_argument("--superpath", "--path", type=str, default="/")
args = p.parse_args()
server.address = (args.hostname, args.port)
server.start(args.superpath)
| {"/Stater/base.py": ["/Stater/utils.py", "/Stater/err.py"], "/test_utils.py": ["/Stater/utils.py"]} |
72,501 | mithem/Stater | refs/heads/master | /Stater/server.py | import json
import os
import string
import serverly
from serverly import Request, Response, serves, logger, error_response
from Stater import base, err
address = ("localhost", 8084)
serverly.name = "StaterServer"
logger.filename = "server.log"
logger.verbose = True
serverly.register_error_response(401, "Unauthorized.", "base")
serverly.register_error_response(
406, "Unable to parse required parameters (JSON). Expected ")
serverly.register_error_response(404, "Server not found.", "base")
@serves("GET", "/api/getserver")
def api_get_server(req: Request):
try:
name = req.obj.get("name", "NOTANAME")
except AttributeError:
name = "NOTANAME"
if name == "NOTANAME":
response = error_response(406, "'name'")
else:
try:
req_server = base.get_server(name=name)
if req_server != None:
print("SERVER FOUND!")
del req_server["password"]
req_server["components"] = json.loads(
req_server["components"])
for key, value in req_server["components"].items():
value["name"] = key
response = Response(body=req_server)
else:
print(serverly.error_response_templates)
response = error_response(404)
except Exception as e:
logger.handle_exception(e)
response = Response(500, body=str(e))
return response
@serves("POST", "/api/register(server)?")
def api_register_server(req: Request):
try:
base.register_server(req.obj["name"], req.obj.get("description", None), req.obj.get(
"repoURL", None), req.obj.get("mainStatus", None), req.obj.get("components", None), req.obj["password"])
create_server_details_page(base.get_server(req.obj["name"]))
response = Response(201, body="Successfully registered server.")
except KeyError:
response = error_response(406, "'name'", "'password'")
except (err.NameAlreadyUsedError, err.RepoURLAlreadyUsedError) as e:
response = Response(406, body=str(e))
except Exception as e:
logger.handle_exception(e)
response = Response(500, body=type(e).__name__ + ": " + str(e))
return response
@serves("DELETE", "/api/delete(server)?")
def api_delete_server(req: Request):
try:
base.authenticate(req.obj.get("name", "notaname"),
req.obj.get("password", ""))
if req.obj.get("name", None) != None:
base.delete_server(req.obj.get("name"))
delete_server_details_page(req.obj.get("name"))
else:
server = base.get_server(id=req.obj.get("id", -1))
base.delete_server(id=server.get("id", -1))
delete_server_details_page(server.get("name", "notaname"))
response = Response(
body="Deleted server successfully (just from the Stater-system :P).")
except err.AuthenticationError:
response = error_response(401)
except err.ServerNotFoundError:
response = error_response(404)
except Exception as e:
response = Response(
500, body=f"Exception ({type(e).__name__}): " + str(e))
return response
@serves("PUT", "/api/updateserver")
def api_update_status(req: Request):
try:
components = req.obj.get("components", None)
print("components:", components, type(components))
base.update_server(req.obj["name"], req.obj["password"], main_status=req.obj.get(
"mainStatus", None), components=components)
response = Response(body="Updated server.")
except err.AuthenticationError:
response = error_response(401)
except KeyError:
response = error_response(
406, "'name'", "'password'", "(optional) 'components'", "(optional) 'mainStatus'")
except Exception as e:
response = Response(500, body=str(e))
return response
@serves("PUT", "/api/change(server)?")
def api_change_server(req: Request):
try:
id = req.obj.get("id", -1)
if id == -1:
server = base.get_server(name=req.obj["name"])
else:
server = base.get_server(id=id)
compo = req.obj.get("components", None)
if compo != None:
components = json.loads(compo)
else:
components = None
base.authenticate(server.get("name"), req.obj["password"])
base.change_server(server.get("id"), req.obj.get("newName", None), req.obj.get("description", None), req.obj.get(
"repoURL", None), req.obj.get("mainStatus", None), components, req.obj.get("newPassword", None))
response = Response(body="Changed server successfully.")
except err.AuthenticationError:
response = error_response(401)
except KeyError:
response = error_response(406, "'id'/'name'", "'password'")
except err.ServerNotFoundError:
response = error_response(404)
except Exception as e:
serverly.logger.handle_exception(e)
response_msg = str(e)
return response
@serves("PUT", "/api/updatecomponent")
def api_update_component(req: Request):
try:
base.authenticate(req.obj["name"], req.obj["password"])
server_name = req.obj.get("serverName", req.obj["name"])
component_name = req.obj.get(
"component", req.obj.get("componentName", "NOTACOMPONENT"))
status = req.obj.get("status", req.obj.get("newStatus", "NOTASTATUS"))
if server_name == "NOTANAME" or component_name == "NOTACOMPONENT" or status == "NOTASTATUS":
raise KeyError()
base.update_component(
server_name, req.obj["password"], component_name, status)
response = Response(body="Updated component.")
except err.AuthenticationError:
response = error_response(401)
except KeyError:
response = error_response(
406, "'name'", "'password'", "'componentName'", "'status'")
except Exception as e:
serverly.logger.handle_exception(e)
response_msg = str(e)
return response
@serverly.serves_post("/api/authenticate")
def api_authenticate(req: Request):
try:
base.authenticate(req.obj["name"], req.obj["password"])
request = Request(body="Authorized.")
except KeyError:
response = error_response(406, "'name'", "'password'")
except err.AuthenticationError:
response = error_response(401)
except err.ServerNotFoundError:
response = error_response(404)
except Exception as e:
serverly.logger.handle_exception(e)
response = Response(500, body=str(e))
return response
def create_server_details_page(server: dict):
name = server.get("name")
repo_url = server.get("repoURL")
with open("Stater/src/server_template.html", "r") as f:
template = string.Template(f.read())
server_detail_page_content = template.safe_substitute(
server_name=name, json_not_parsed=json.dumps({"name": name}), server_description=server.get("description"), repo_url=str(repo_url))
filename = "Stater/src/servers/" + str(name) + ".html"
with open(filename, "w") as f:
f.write(server_detail_page_content)
serverly.static_page(filename, "/server/" + name)
def delete_server_details_page(server_name: str):
serverly.unregister("GET", "/server/"+server_name)
os.remove("Stater/src/servers/" + server_name + ".html")
serverly.static_page("Stater/src/dashboard.html", "/dashboard")
serverly.static_page("Stater/src/login.html", "/login")
serverly.static_page("Stater/src/register.html", "/register")
def start(superpath="/"):
init_custom_servers()
serverly.address = address
serverly.start(superpath)
def init_custom_servers():
for f in os.listdir("Stater/src/servers/"):
os.remove("Stater/src/servers/" + f)
for s in base.get_all_servers(limit=0):
create_server_details_page(s)
| {"/Stater/base.py": ["/Stater/utils.py", "/Stater/err.py"], "/test_utils.py": ["/Stater/utils.py"]} |
72,502 | mithem/Stater | refs/heads/master | /Stater/base.py | """
status-system of server as well as submodules
---
- 0: no errors
- 1: partially constrained
- 2: major/complete fail
- 3: offline
"""
from fileloghelper import Logger
import pymysql.cursors
from pymysql.err import OperationalError
from Stater.utils import get_server_params, encrypt
from Stater.err import *
import json
logger = Logger("base.log", "register", True, True)
logger.header(True, True, "Stater - base", 0, True, "moonshine")
def exec_sql(sql_command="SELECT * FROM tasks", verbose=True, logger: Logger = None):
"""Execute sql_command on database and return None or whatever is returned from the database. If sql_command is not specified, all tasks will get returned"""
result = None
if logger != None and type(logger) == Logger:
logger.set_context("exec_sql")
elif verbose == True:
logger = Logger("exec_sql.log", "exec_sql", True, True)
try:
connection = pymysql.connect(host='localhost',
user='stater_db_wrapper',
password='stater_wrapper007',
db='stater',
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
except OperationalError as e:
logger.handle_exception(e)
raise AuthenticationError("Access denied to database")
if verbose and logger != None:
logger.success("connected to database", False)
if verbose and logger != None:
logger.debug("executing SQL-Command: " + sql_command)
with connection.cursor() as cursor:
cursor.execute(sql_command)
if "SELECT" in sql_command:
result = cursor.fetchall()
else:
connection.commit()
if verbose and logger != None:
logger.debug("SQL query returned: " + str(result))
try:
connection.close()
if verbose and logger != None:
logger.success("Shut down connection to database", False)
except Exception as e:
if logger != None and type(logger) == Logger:
logger.handle_exception(e)
else:
print(e)
finally:
return result
def authenticate(name: str, password: str):
"""return True if authenticated. If not, raise AuthenticationError"""
server = get_server(name)
if server == None:
raise ServerNotFoundError(f"Server '{name}' not found.")
enc_password = encrypt(password)
if server.get("password") == enc_password:
return True
else:
raise AuthenticationError(f"Cannot authenticate {name}.")
def register_server(name: str, description: str = None, repo_url: str = None, main_status: int = None, components: dict = None, password: str = None):
"""register server.
:param name: a unique name for the server
:param description: longer, human-readable description of the server (optional)
:param repo_url: url to the github-repo (optional)
:param components: dict of dicts for seperate sub-components of the server. Similar to this structure: {'some-name': {'status': 0}}
:param password: new password to set. Cannot be reset.
:type name: str
:type description: str
:type repo_url: str
:type main_status: int
:type components: dict
:type password: str
"""
logger.debug("trying to register server " + name)
if password == None:
raise TypeError("Password required.")
components, password, joined = get_server_params(name=name, description=description, repo_url=repo_url,
main_status=main_status, components=components, password=password)
keys = ["name", "password", "joined"]
values = ["'" + name + "'", "'" + password + "'", "'" + joined + "'"]
if description != None:
keys.append("description")
values.append("'" + description + "'")
if repo_url != None:
keys.append("repoURL")
values.append("'" + repo_url + "'")
if main_status != None:
keys.append("mainStatus")
values.append(main_status)
if components != None:
keys.append("components")
values.append("'" + json.dumps(components)[1:-1] + "'")
columns = ""
my_values = ""
for key in keys:
columns += str(key) + ", "
for value in values:
my_values += str(value) + ", "
columns = columns[:-2]
my_values = my_values[:-2]
try:
exec_sql(
f"INSERT INTO servers ({columns}) VALUES ({my_values});", True, logger)
except pymysql.err.IntegrityError as e:
if "name" in str(e):
raise NameAlreadyUsedError(f"Name '{name}' is already used.")
if "repoURL" in str(e):
raise RepoURLAlreadyUsedError(
f"repo-url '{repo_url}' is already used.")
def get_server(name: str = "", id: int = None):
"""Return already parsed (json -> dict) server dict object. If server does not exist, return None."""
try:
if id == None:
result = exec_sql(
f"SELECT * FROM servers WHERE name='{name}';", False)
else:
result = exec_sql(f"SELECT * FROM servers WHERE id={id};", False)
if len(result) == 1:
return result[0]
else:
return None
except Exception as e:
logger.handle_exception(e)
raise e
def change_server(id: int, name: str = None, description: str = None, repo_url: str = None, main_status: int = None, components: dict = None, password: str = None):
"""Change server according to arguments"""
try:
logger.set_context("change_server")
components_changed = components != None
if get_server(id=id) == None:
raise ServerNotFoundError(f"Server with id {id} not found")
components, encrypted_password, djoined = get_server_params(
name, description, repo_url, main_status, components, password)
if name != None:
logger.debug(f"changing name of server {id}", True)
exec_sql(f"UPDATE servers SET name='{name}' WHERE id={id}", False)
if description != None:
logger.debug(f"changing description of server {id}", True)
exec_sql(
f"UPDATE servers SET description='{description}' WHERE id={id}", False)
if repo_url != None:
logger.debug(f"changing repo_url of server {id}", True)
exec_sql(
f"UPDATE servers SET repoURL='{repo_url}' WHERE id={id}", False)
if main_status != None:
logger.debug(f"changing main_status of server {id}", True)
exec_sql(
f"UPDATE servers SET mainStatus={main_status} WHERE id={id}", False)
if components_changed:
logger.debug(f"changing components of server {id}", True)
exec_sql(
f"UPDATE servers SET components='{json.dumps(components)[1:-1]}' WHERE id={id}", False)
if password != None:
logger.debug(f"changing password of server {id}", True)
exec_sql(
f"UPDATE servers SET password='{encrypted_password}' WHERE id={id}")
except Exception as e:
logger.handle_exception(e)
raise e
def get_all_servers(order_by: str = "id", limit: int = 10):
"""return list of all servers, ordered by order_by, with a limit of limit"""
try:
params = {
"id": "id",
"djoined": "joined",
"joined": "joined",
"name": "name",
"status": "mainStatus",
"main_status": "mainStatus"
}
if not order_by in params.keys():
raise ValueError("'by'-parameter not valid.")
if type(limit) == int:
if limit < 0 or limit > 50:
raise ValueError("limit not in range 1-50 (both included)")
else:
raise TypeError("limit not of type int.")
by = params[order_by]
if limit == 0:
sql = "SELECT * FROM servers"
else:
sql = f"SELECT * FROM servers ORDER BY {by} LIMIT {limit}"
return list(exec_sql(sql, False))
except Exception as e:
logger.handle_exception(e)
raise e
def delete_server(name: str = None, id: int = None):
try:
if name != None:
if type(name) != str:
raise TypeError("name not of type str.")
server = get_server(name)
elif id != None:
if type(id) != int:
raise TypeError("id not of type int.")
server = get_server(id=id)
if server == None:
raise ServerNotFoundError("Server not found. Could not delete.")
id = server.get("id")
exec_sql(f"DELETE FROM servers WHERE id={id}", False)
except Exception as e:
logger.handle_exception(e)
raise e
def update_server(name: str, password: str, main_status: int = None, components: dict = None):
try:
authenticate(name, password)
components_where_none = components == None
if type(components) == str:
components = json.loads(components)
components, _, __ = get_server_params(
main_status=main_status, components=components)
id = get_server(name).get("id")
if main_status != None:
exec_sql(
f"UPDATE servers SET mainStatus={main_status} WHERE id={id}")
if not components_where_none:
exec_sql(
f"UPDATE servers SET components='{components}' WHERE id={id}")
except Exception as e:
logger.handle_exception(e)
raise e
def update_component(server_name: str, password: str, component_name: str, component_status: int):
try:
authenticate(server_name, password)
server = get_server(server_name)
server["components"] = json.loads(server["components"])
try:
server["components"][component_name]["status"] = component_status
except KeyError:
raise ComponentNotFoundError(
f"Component '{component_name}' not found")
exec_sql(
f"UPDATE servers SET components='{json.dumps(server['components'])}' WHERE id={server.get('id')}")
except Exception as e:
logger.handle_exception(e)
raise e
| {"/Stater/base.py": ["/Stater/utils.py", "/Stater/err.py"], "/test_utils.py": ["/Stater/utils.py"]} |
72,503 | mithem/Stater | refs/heads/master | /Stater/err.py | class AuthenticationError(Exception):
pass
class ServerNotFoundError(Exception):
pass
class NameAlreadyUsedError(Exception):
pass
class RepoURLAlreadyUsedError(Exception):
pass
class ComponentNotFoundError(Exception):
pass
| {"/Stater/base.py": ["/Stater/utils.py", "/Stater/err.py"], "/test_utils.py": ["/Stater/utils.py"]} |
72,504 | mithem/Stater | refs/heads/master | /Stater/utils.py | import re
import json
from hashlib import sha256
import datetime
from fileloghelper import Logger
logger = Logger("utils.log", "utils", True, True)
def get_server_params(name: str = None, description: str = None, repo_url: str = None, main_status: int = None, components: dict = None, password: str = None):
"""check args for user errors and return components: str (in json format), encrypted_password: str, djoined: str"""
if name == None:
name = "validname"
if description == None:
description = ""
if repo_url == None:
repo_url = "https://valid.test"
if main_status == None:
main_status = 0
if components == None:
components = {}
if password == None:
password = "abcdefg12345678"
if len(name) > 20:
raise ValueError("name argument too long (max 20)")
if len(name) < 4:
raise ValueError("name too short")
if not re.match("^[a-z_][a-z_.-]", name) or "#" in name:
raise ValueError("Username invalid.")
if len(description) > 1024:
raise ValueError("description argument too long")
if not re.match("^https?://(www\.)?[\w.]+\.\w{2,}[a-zA-Z/_.-]*$", repo_url):
raise ValueError("repo_url argument invalid.")
if type(main_status) != int:
raise TypeError("'main_status' expected to be of type int.")
if main_status < 0 or main_status > 3:
raise ValueError("main_status argument not 0, 1, 2, or 3")
if type(components) != dict:
raise TypeError("components is not a dict.")
elif type(components) == dict:
for key, value in components.items():
if type(value) != dict:
raise TypeError(
"(One) component in components: dict is not of type dict")
name = key
get_server_params(name)
description = value.get("description", "NOTADESCRIPTION")
status = value.get("status", "NOTFOUND")
if status == "NOTFOUND":
status = value.get("code", -1)
if status != -1:
del value["code"]
value["status"] = status
if name == "NOTANAME":
raise ValueError(
"name attribute of one component not specified.")
if type(name) != str:
raise TypeError(
"name attribute of one component not of type str")
if type(status) != int:
raise TypeError(
"status attribute of one component invalid (excepted int between 0 and 3 (both included, see docs))")
if status == -1:
raise ValueError("status of one component not specified")
if status < 0 or status > 3:
raise ValueError(
"status of one component not in range 0-3 (both included)")
if type(password) != str:
raise TypeError("password required to be of type str.")
elif len(password) < 8:
raise ValueError("password too short.")
encrypted_password = encrypt(password)
djoined = datetime.datetime.now().isoformat(timespec="seconds")
return json.dumps(components), encrypted_password, djoined
def encrypt(password: str):
return sha256(bytes(password, "utf-8")).hexdigest()
| {"/Stater/base.py": ["/Stater/utils.py", "/Stater/err.py"], "/test_utils.py": ["/Stater/utils.py"]} |
72,505 | mithem/Stater | refs/heads/master | /test_utils.py | from Stater.utils import get_server_params
import pytest
def test_get_server_params():
get_server_params(
components={"hello": {"code": 0}, "test": {"status": 2}})
def test_get_server_params_2():
with pytest.raises(ValueError):
get_server_params(repo_url="hello")
def test_get_server_params_3():
get_server_params(repo_url="http://github.com/mithem/test")
| {"/Stater/base.py": ["/Stater/utils.py", "/Stater/err.py"], "/test_utils.py": ["/Stater/utils.py"]} |
72,515 | edobranchi/Hashing | refs/heads/main | /main.py | import Linear_Hash
import Chained_Hash
import plot
def print_menu(): ## Your menu design here
print(30 * "-", "MENU", 30 * "-")
print("1. Popolazione Hash Lineare")
print("2. Popolazione Hash Concatenato")
print("3. Grafici Hash Lineare")
print("4. Grafici Hash Concatenato")
print("5. Test Ricerca con successo concatenamento")
print("6. Test Ricerca senza successo concatenamento")
print("7. Test Ricerca con successo lineare")
print("8. Test Ricerca senza successo lineare")
print(67 * "-")
def print_sub_menu():
print(30 * "-", "MENU", 30 * "-")
print("1. Ricerca Valore:")
print("2. Cancella valore:")
print("3. Stampa la tabella")
print("4. Uscita")
print(67 * "-")
loop = True
while loop: ## While loop which will keep going until loop = False
print_menu() ## Displays menu
choice = int(input("Enter your choice [1-5]: "))
if choice == 1:
print("Creazione Hash lineare")
hash_dim = int(input("Dimensione tabella hash desiderata:"))
num_ins = int(input("Numero di inserimenti: "))
success_bool = Linear_Hash.insert_generation(hash_dim,num_ins)
if success_bool==True:
annidated_loop = True
else:
annidated_loop= False
while annidated_loop:
print_sub_menu()
choice_linear= int(input("Enter your choice [1-3]: "))
if choice_linear == 1:
search_value = int(input("Inserire il valore da cercare:"))
Linear_Hash.linear_search(search_value)
elif choice_linear == 2:
delete_value = int(input("Inserire il valore da eliminare:"))
Linear_Hash.linear_delete(delete_value)
elif choice_linear == 3:
Linear_Hash.linear_display()
elif choice_linear==4:
print("Torno al menu precedente")
annidated_loop=False
else:
print("Nessuna scelta corrispondente riprovare...")
if choice == 2:
print("Creazione Hash concatenato")
hash_dim = int(input("Dimensione tabella hash desiderata:"))
num_ins = int(input("Numero di inserimenti: "))
Chained_Hash.list_creation(hash_dim)
Chained_Hash.insert(num_ins)
annidated_loop=True
while annidated_loop:
print_sub_menu()
choice_linear= int(input("Enter your choice [1-3]: "))
if choice_linear == 1:
search_num = int(input("Inserisci il valore da cercare: "))
Chained_Hash.hash_search(search_num)
elif choice_linear == 2:
del_num = int(input("Inserisci il valore da eliminare: "))
Chained_Hash.hash_delete(del_num)
elif choice_linear == 3:
Chained_Hash.display_hash()
elif choice_linear==4:
print("Torno al menu precedente")
annidated_loop=False
else:
input("Nessuna scelta corrispondente riprovare")
if choice == 3:
hash_dim = int(input("Inserisci la dimensione della tabella:"))
num_ins = int(input("Inserisci il numero di inserimenti da creare:"))
plot.linear_plot(hash_dim,num_ins)
if choice == 4:
hash_dim = int(input("Inserisci la dimensione della tabella:"))
num_ins = int(input("Inserisci il numero di inserimenti da creare:"))
plot.chained_plot(num_ins,hash_dim)
elif choice==5:
hash_dim = int(input("Inserisci la dimensione della tabella:"))
plot.research_plot_chained_success(hash_dim)
elif choice == 6:
hash_dim = int(input("Inserisci la dimensione della tabella:"))
plot.research_plot_chained_notsuccess(hash_dim)
elif choice == 7:
hash_dim = int(input("Inserisci la dimensione della tabella:"))
plot.research_plot_linear_success(hash_dim)
elif choice == 8:
hash_dim = int(input("Inserisci la dimensione della tabella:"))
plot.research_plot_linear_notsuccess(hash_dim)
| {"/main.py": ["/Linear_Hash.py", "/Chained_Hash.py", "/plot.py"]} |
72,516 | edobranchi/Hashing | refs/heads/main | /Chained_Hash.py | from random import randint
global HashTable
def list_creation(hash_dim):
global HashTable
HashTable = [[] for _ in range(hash_dim)]
#funzione di hash
def Hashing(rand_keyvalue):
return rand_keyvalue % len(HashTable)
#inserimento
def insert(num_ins):
for i in range(num_ins):
rand_keyvalue = randint(0, 100)
rand_value = randint(0, 300)
hash_key = Hashing(rand_keyvalue)
HashTable[hash_key].append(rand_value)
#Stampa della lista
def display_hash():
global HashTable
for i in range(len(HashTable)):
print(i, end=" ")
for j in HashTable[i]:
print("-->", end=" ")
print(j, end=" ")
print()
def hash_search(search_value):
for index1,list in enumerate(HashTable):
for index,element in enumerate(list):
if element == search_value:
print("valore trovato in : ",index1," alla posizione: ",index+1)
return (index1,index)
print("valore non trovato")
#cancellazzione elemento
def hash_delete(delete_value):
index=hash_search(delete_value)
try:
HashTable[index[0]].pop(index[1])
except:
print("Impossibile cancellare")
| {"/main.py": ["/Linear_Hash.py", "/Chained_Hash.py", "/plot.py"]} |
72,517 | edobranchi/Hashing | refs/heads/main | /plot.py | import random
import math
import numpy as np
from matplotlib import pyplot as plt
def truncate(number, digits) -> float:
stepper = 10.0 ** digits
return math.trunc(stepper * number) / stepper
def linear_plot(hash_dim,num_ins):
if num_ins>hash_dim:
print("Il numero di inserimenti eccede la dimensione della tabella, riprova")
return
hash_table = [None] * hash_dim
collision = 0
linear_index=0
for i in range(num_ins):
insert_value=random.randrange(40,50)
h_k = insert_value % hash_dim # calcolo h'(k)
h_k = (h_k + linear_index) % hash_dim # calcolo h(k)= (h'(k)+i)mod m
while hash_table[h_k] != None: # se la posizione h_k รจ occupata incrementa il contatore collisione
collision += 1 # scorre alla posizione successiva
h_k += 1
if h_k >= hash_dim: # se arriva in fondo alla tabella ricomincia dalla prima posizione
h_k = 0
hash_table[h_k] = insert_value
load_factor= i/hash_dim
load_factor=truncate(load_factor,3)
print(i," ",load_factor," ",collision)
result_list=[i,load_factor,collision]
result_linear = open('Result/result_linear.txt', 'a')
result_linear.writelines(str(result_list) + "\n")
result_linear.close()
with open('Result/result_linear.txt','r+') as f:
lines = f.readlines()
x_values = [line.split(",")[1] for line in lines]
y_values = [line.split(",")[2] for line in lines]
x_values = [s.replace("(", "").replace("'", "").replace(" ", "") for s in x_values]
y_values = [s.replace("'", "").replace("\n", "").replace(" ", "").replace("]","") for s in y_values]
x_values[:] = (elem[:5] for elem in x_values)
x_values = [float(item) for item in x_values]
y_values = [float(item) for item in y_values]
# Note that even in the OO-style, we use `.pyplot.figure` to create the figure.
fig, ax = plt.subplots() # Create a figure and an axes.
ax.plot(x_values, y_values, label='linear') # Plot some data on the axes.
ax.set_xlabel('Load Factor:') # Add an x-label to the axes.
ax.set_ylabel('Collision') # Add a y-label to the axes.
ax.set_title("Collisioni al variare del fattore di carico") # Add a title to the axes.
plt.yticks(np.arange(0,550000,step=50000))
plt.xticks(np.arange(0,1.1, step=0.1))
plt.savefig('result/load_factor_collision_linear_hash.png')
plt.show()
f.close()
open('Result/result_linear.txt','w').close()
def chained_plot(num_ins,hash_dim):
HashTable = [[] for _ in range(hash_dim)]
chained_collision=0
for i in range(num_ins):
rand_keyvalue = random.randrange(1000, 2000)
rand_value = random.randrange(100, 200)
hash_key = rand_keyvalue % len(HashTable)
HashTable[hash_key].append(rand_value)
chained_collision = chained_collision + HashTable.index(HashTable[-1])
load_factor = (i + 1) / hash_dim
print(rand_value," ", chained_collision," ",load_factor)
result_list = [rand_value, chained_collision,truncate(float(load_factor),2)]
result_linear = open('Result/result_chained.txt', 'a')
result_linear.writelines(str(result_list) + "\n")
result_linear.close()
with open('Result/result_chained.txt','r+') as f:
lines = f.readlines()
x_values = [line.split(",")[2] for line in lines]
y_values = [line.split(",")[1] for line in lines]
x_values = [s.replace("(", "").replace("'", "").replace(" ", "").replace("]","").replace("\n","") for s in x_values]
y_values = [s.replace(")", "").replace("\n", "").replace(" ", "").replace("]","") for s in y_values]
x_values[:] = (elem[:5] for elem in x_values)
x_values = [float(item) for item in x_values]
y_values = [float(item) for item in y_values]
# Note that even in the OO-style, we use `.pyplot.figure` to create the figure.
fig, ax = plt.subplots() # Create a figure and an axes.
ax.plot(x_values, y_values, label='linear') # Plot some data on the axes.
ax.set_ylabel('Collisioni:') # Add an x-label to the axes.
ax.set_xlabel('Load Factor:') # Add a y-label to the axes.
ax.set_title("Collisioni con load factor = " +str(load_factor)) # Add a title to the axes.
plt.xticks(np.arange(0,1.1,step=0.1))
plt.yticks(np.arange(0,550000, step=50000))
plt.savefig('Result/load_factor_collision_chained_hash.png')
plt.show()
f.close()
open('Result/result_chained.txt','w').close()
def research_plot_linear_notsuccess(hash_dim):
with open('Result/result_search_linear_notsuccess.txt', 'w') as f:
f.write('')
f.close()
for num_ins in range(1, hash_dim, hash_dim // 100):
print("numins",num_ins)
print("hash_dim",hash_dim//100)
hash_table = [None] * hash_dim
collision = 0
linear_index=0
for i in range(num_ins):
insert_value=random.randrange(1,10000,2)
h_k = insert_value % hash_dim # calcolo h'(k)
h_k = (h_k + linear_index) % hash_dim # calcolo h(k)= (h'(k)+i)mod m
while hash_table[h_k] != None: # se la posizione h_k รจ occupata incrementa il contatore collisione
collision += 1 # scorre alla posizione successiva
h_k += 1
if h_k >= hash_dim: # se arriva in fondo alla tabella ricomincia dalla prima posizione
h_k = 0
hash_table[h_k] = insert_value
load_factor=num_ins/hash_dim
linear_index=0
count=0
times=0
while times <= 200:
print("ciclo " + str(times))
search_value=random.randrange(1,10000,2)
print("devo cercare" + str(search_value))
h_k = search_value % hash_dim # calcolo h'(k)
h_k = (h_k + linear_index) % hash_dim
print("count: " + str(count))
i=0
maybe=h_k-1
counter=0
while i <= hash_dim:
print(h_k)
print(hash_dim)
print (i)
if h_k == hash_dim or i == hash_dim:
h_k=0
i=0
elif hash_table[h_k] == None: #ritorna il primo valore corrispondente che trova
print("non presente")
count=count+1
break
elif hash_table[h_k] == search_value:
print("trovato")
count=count-counter
count=count+1
times=times-1
break
elif maybe == h_k:
count=count+1
break
else:
counter=counter+1
h_k=h_k+1
i=i+1
count = count + 1
times=times+1
count = count/200
result_linear = open('Result/result_search_linear_notsuccess.txt', 'a')
result_linear.writelines(str(count) + " ," + str(load_factor) +"\n")
result_linear.close()
with open('Result/result_search_linear_notsuccess.txt','r+') as f:
lines = f.readlines()
y_values = [line.split(",")[0] for line in lines]
x_values = [line.split(",")[1] for line in lines]
x_values = [s.replace("(", "").replace("'", "").replace(" ", "") for s in x_values]
y_values = [s.replace("'", "").replace("\n", "").replace(" ", "").replace("]","") for s in y_values]
x_values[:] = (elem[:5] for elem in x_values)
x_values = [float(item) for item in x_values]
y_values = [float(item) for item in y_values]
# Note that even in the OO-style, we use `.pyplot.figure` to create the figure.
fig, ax = plt.subplots() # Create a figure and an axes.
ax.plot(x_values, y_values,'orange',label='Ricerca senza successo')# Plot some data on the axes.
ax.set_xlabel('Load Factor:') # Add an x-label to the axes.
ax.set_ylabel('Comparazioni medie per ricerca') # Add a y-label to the axes.
ax.set_title("Comparazioni medie necessarie per una ricerca \n al variare del fattore di carico") # Add a title to the axes.
plt.yticks(np.arange(0,1200,step=100))
plt.xticks(np.arange(0,1.1, step=0.1))
plt.legend(loc='upper left')
plt.savefig('result/lineare_senzasuccesso.png')
plt.show()
f.close()
def research_plot_linear_success(hash_dim):
with open('Result/result_search_linear_success.txt', 'w') as f:
f.write('')
f.close()
for num_ins in range(1, hash_dim, hash_dim // 100):
print("numins",num_ins)
print("hash_dim",hash_dim//100)
hash_table = [None] * hash_dim
collision = 0
linear_index=0
for i in range(num_ins):
insert_value=random.randrange(1,10000,2)
h_k = insert_value % hash_dim # calcolo h'(k)
h_k = (h_k + linear_index) % hash_dim # calcolo h(k)= (h'(k)+i)mod m
while hash_table[h_k] != None: # se la posizione h_k รจ occupata incrementa il contatore collisione
collision += 1 # scorre alla posizione successiva
h_k += 1
if h_k >= hash_dim: # se arriva in fondo alla tabella ricomincia dalla prima posizione
h_k = 0
hash_table[h_k] = insert_value
load_factor=num_ins/hash_dim
linear_index=0
count=0
times=0
while times <= 200:
print("ciclo " + str(times))
search_value=random.randrange(1,10000,2)
print("devo cercare" + str(search_value))
h_k = search_value % hash_dim # calcolo h'(k)
h_k = (h_k + linear_index) % hash_dim
print("count: " + str(count))
i=0
counter=0
maybe=h_k-1
while i <= hash_dim:
if h_k == hash_dim or i == hash_dim:
h_k=0
i=0
elif hash_table[h_k] == None: #ritorna il primo valore corrispondente che trova
print("non presente")
count=count-counter
times=times-1
break
elif hash_table[h_k] == search_value:
print("trovato")
count=count+1
break
elif maybe == h_k:
count=count-counter
times=times-1
break
else:
counter=counter+1
h_k=h_k+1
i=i+1
count = count + 1
times=times+1
count = count/200
result_linear = open('Result/result_search_linear_success.txt', 'a')
result_linear.writelines(str(count) + " ," + str(load_factor) +"\n")
result_linear.close()
with open('Result/result_search_linear_success.txt','r+') as f:
lines = f.readlines()
y_values = [line.split(",")[0] for line in lines]
x_values = [line.split(",")[1] for line in lines]
x_values = [s.replace("(", "").replace("'", "").replace(" ", "") for s in x_values]
y_values = [s.replace("'", "").replace("\n", "").replace(" ", "").replace("]","") for s in y_values]
x_values[:] = (elem[:5] for elem in x_values)
x_values = [float(item) for item in x_values]
y_values = [float(item) for item in y_values]
fig, ax = plt.subplots() # Create a figure and an axes.
#ax.plot(x_values, y_values2, label='Ricerca senza successo')
ax.plot(x_values, y_values,label='Ricerca con successo')# Plot some data on the axes.
ax.set_xlabel('Load Factor:') # Add an x-label to the axes.
ax.set_ylabel('Comparazioni medie per ricerca') # Add a y-label to the axes.
ax.set_title("Comparazioni medie necessarie per una ricerca \n al variare del fattore di carico") # Add a title to the axes.
plt.yticks(np.arange(0,100,step=10))
plt.xticks(np.arange(0,1.1, step=0.1))
plt.legend(loc='upper left')
plt.savefig('result/lineare_successo.png')
plt.show()
f.close()
def research_plot_chained_notsuccess(hash_dim):
with open('Result/result_search_notsuccess_chained.txt', 'w') as f:
f.write('')
f.close()
for num_ins in range(1,hash_dim,hash_dim//100):
HashTable = [[] for _ in range(hash_dim)]
load_factor = num_ins / hash_dim
for ins in range(num_ins):
rand_value = random.randrange(0, 10000,2)
hash_key = rand_value % len(HashTable)
HashTable[hash_key].append(rand_value)
ricerca = 0
i = 0
while i < 200:
print("entrato")
search_value = random.randrange(0, 10000,2)
hash_key = search_value % len(HashTable)
list = HashTable[hash_key]
edo=0
if not list:
print("lista vuota")
ricerca=ricerca+1
i=i+1
else:
for z,j in enumerate(list):
print(list)
if j == search_value:
print("cerco: ", search_value, "valore trovato in : ", hash_key, " alla posizione: ", z+1)
i = i-1
ricerca=ricerca-edo
break
else:
print("cerco : ", search_value, " non trovato")
ricerca = ricerca+1
edo=edo+1
i=i+1
print("Ricerca: ",ricerca)
ricerca=ricerca/200
result_linear = open('Result/result_search_notsuccess_chained.txt', 'a')
result_linear.writelines(str(ricerca) + " ," + str(load_factor) + "\n")
result_linear.close()
with open('Result/result_search_notsuccess_chained.txt','r+') as f:
lines = f.readlines()
y_values = [line.split(",")[0] for line in lines]
x_values = [line.split(",")[1] for line in lines]
x_values = [s.replace("(", "").replace("'", "").replace(" ", "") for s in x_values]
y_values = [s.replace("'", "").replace("\n", "").replace(" ", "").replace("]","") for s in y_values]
x_values[:] = (elem[:5] for elem in x_values)
x_values = [float(item) for item in x_values]
y_values = [float(item) for item in y_values]
# Note that even in the OO-style, we use `.pyplot.figure` to create the figure.
fig, ax = plt.subplots() # Create a figure and an axes.
t1 =np.arange(0,1.1,0.1)
t2 =np.arange(1,2.1,0.1)
plt.plot(t1, t2,'red',label='1+ฮฑ')
ax.plot(x_values, y_values,'blue',label='Ricerca senza successo')# Plot some data on the axes.
ax.set_xlabel('Load Factor:') # Add an x-label to the axes.
ax.set_ylabel('Comparazioni medie per ricerca') # Add a y-label to the axes.
ax.set_title("Comparazioni medie necessarie per una ricerca senza successo \n al variare del fattore di carico") # Add a title to the axes.
plt.yticks(np.arange(0,3,step=0.25))
plt.xticks(np.arange(0,1.1, step=0.1))
plt.legend(loc='upper left')
plt.savefig('result/result_notsearch_combo.png')
plt.show()
f.close()
def research_plot_chained_success(hash_dim):
with open('Result/result_search_success_chained.txt', 'w') as f:
f.write('')
f.close()
for num_ins in range(1,hash_dim,hash_dim//100):
HashTable = [[] for _ in range(hash_dim)]
load_factor = num_ins / hash_dim
for ins in range(num_ins):
rand_value = random.randrange(0, 10000, 2)
hash_key = rand_value % len(HashTable)
HashTable[hash_key].append(rand_value)
ricerca = 0
i = 0
while i < 200:
search_value = random.randrange(0, 10000, 2)
hash_key = search_value % len(HashTable)
list = HashTable[hash_key]
if not list:
pass
else:
for z, j in enumerate(list):
print(list)
if j == search_value:
print("cerco: ", search_value, "valore trovato in : ", hash_key, " alla posizione: ", z + 1)
ricerca=ricerca+1
break
else:
print("cerco : ", search_value, " non trovato")
ricerca = ricerca + 1
i = i + 1
ricerca = ricerca / 200
result_linear = open('Result/result_search_success_chained.txt', 'a')
result_linear.writelines(str(ricerca) + " ," + str(load_factor) + "\n")
result_linear.close()
with open('Result/result_search_success_chained.txt', 'r+') as f:
lines = f.readlines()
y_values = [line.split(",")[0] for line in lines]
x_values = [line.split(",")[1] for line in lines]
x_values = [s.replace("(", "").replace("'", "").replace(" ", "") for s in x_values]
y_values = [s.replace("'", "").replace("\n", "").replace(" ", "").replace("]", "") for s in y_values]
x_values[:] = (elem[:5] for elem in x_values)
x_values = [float(item) for item in x_values]
y_values = [float(item) for item in y_values]
fig, ax = plt.subplots() # Create a figure and an axes.
t1 = np.arange(0, 1.1, 0.1)
t2 = np.arange(1, 2.1, 0.1)
plt.plot(t1, t2, 'red', label='1+ฮฑ')
ax.plot(x_values, y_values, 'orange', label='Ricerca con successo') # Plot some data on the axes.
ax.set_xlabel('Load Factor:') # Add an x-label to the axes.
ax.set_ylabel('Comparazioni medie per ricerca') # Add a y-label to the axes.
ax.set_title("Comparazioni medie necessarie per una ricerca con successo \n al variare del fattore di carico") # Add a title to the axes.
plt.yticks(np.arange(0, 3, step=0.25))
plt.xticks(np.arange(0, 1.1, step=0.1))
plt.legend(loc='upper left')
plt.savefig('result/result_success_chained_search.png')
plt.show()
f.close()
| {"/main.py": ["/Linear_Hash.py", "/Chained_Hash.py", "/plot.py"]} |
72,518 | edobranchi/Hashing | refs/heads/main | /Linear_Hash.py | import random #LIBRERIE E VARIABILI GLOBALI
global hash_table
collision=0 #collision counter
linear_index=0
#popolazione della tabella con placeholder
def insert_generation(hash_dim,insert_dim):
global hash_table
if insert_dim>hash_dim:
print("Il numero di inserimenti eccede la dimensione della tabella, riprova")
return False
hash_table = [None] * hash_dim #GENERAZIONE INSERIMENTI
for i in range (insert_dim):
insert_value = random.randrange(0,100,1)
linear_insert(hash_dim,insert_value,hash_table) #chiamata per inserire
return True
def linear_display():
global hash_table
print(hash_table)
def linear_insert(hash_dim, insert_value,hash_table): #INSERIMENTO
global collision
global linear_index
h_k = insert_value % hash_dim #calcolo h'(k)
h_k = (h_k + linear_index) % hash_dim #calcolo h(k)= (h'(k)+i)mod m
while hash_table[h_k] != None : #se la posizione h_k รจ occupata incrementa il contatore collisione
collision += 1 #scorre alla posizione successiva
h_k += 1
if h_k >= hash_dim: #se arriva in fondo alla tabella ricomincia dalla prima posizione
h_k = 0
hash_table[h_k]= insert_value #se trova una posizione nuova inserisce il valore
def linear_delete(delete_value): #CANCELLAZIONE
global hash_table
i = linear_search(delete_value) #cerca il valore da cancellare
if i==None:
print("impossibile cancellare")
else:
hash_table[i] = None
print("valore cancellato in posizione: ", i,)
def linear_search(search_value): #RICERCA
global hash_table
hash_dim = len(hash_table)
found = False
for i in range(hash_dim):
if hash_table[i] == search_value: #ritorna il primo valore corrispondente che trova
print("trovato in posizione : " , i)
found = True
return i
if found == False:
print ("Valore non presente ")
| {"/main.py": ["/Linear_Hash.py", "/Chained_Hash.py", "/plot.py"]} |
72,530 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /bike/__init__.py | import os
from flask import Flask,render_template,request
from flask_sqlalchemy import SQLAlchemy
from flask_bootstrap import Bootstrap
from flask_login import LoginManager
from flask_bcrypt import Bcrypt
db=SQLAlchemy()
bootstrap=Bootstrap()
login_manager=LoginManager()
login_manager.login_view='auth.do_the_login'
login_manager.login_message="Welcome!"
bcrypt=Bcrypt()
def create_app(config_type):
app=Flask(__name__)
configuration=os.path.join(os.getcwd(),'config',config_type+'.py')
app.config.from_pyfile(configuration)
db.init_app(app)
bootstrap.init_app(app)
login_manager.init_app(app)
bcrypt.init_app(app)
from bike.garage import main
app.register_blueprint(main)
from bike.auth import auth
app.register_blueprint(auth)
return app | {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,531 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /run.py | from bike import create_app,db
from bike.auth.models import Users
flaskApp=create_app('prod')
with flaskApp.app_context():
db.create_all()
if not Users.query.filter_by(user_name='Sri_Ganesh_Cars').first():
Users.create_user(user='Sri_Ganesh_Cars',email='sriganeshcars@gmail.com',password='secret')
flaskApp.run(debug=True) | {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,532 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /bike/auth/__init__.py | from flask import Blueprint
auth=Blueprint('auth',__name__,template_folder='templates')
from bike.auth import routes | {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,533 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /bike/garage/routes.py | from flask import render_template,flash,redirect,url_for,request
from bike.garage import main
from bike.garage.models import Vehicle
from flask_login import login_required
from bike.garage.forms import Add_vehicle_form,search_form,Customer_form
from bike import db
import os
from werkzeug.utils import secure_filename
UPLOAD_FOLDER = r'..\bike\bike\static\images'
@main.route('/')
def display_route():
bikes=Vehicle.query.filter_by(isSold='False').all()
return render_template('home.html',bikes=bikes)
@main.route('/create',methods=['GET','POST'])
@login_required
def add_vehicle():
form=Add_vehicle_form()
if form.validate_on_submit():
file = request.files.getlist('url')
img=""
if not form.isSold.data=='True' and file:
for f in file:
if f.filename:
filename = secure_filename(f.filename)
f.save(os.path.join(UPLOAD_FOLDER, filename))
if img=="":
img=filename
else:
img=img+","+filename
if form.isSold=='False':
form.soldDate.data='Nil'
form.isDealer.data='Nil'
user=Vehicle(
vehicleNumber=form.vehicleNumber.data,
insuranceEndDate=form.insuranceEndDate.data,
purchaseDate=form.purchaseDate.data,
year=form.year.data,
make=form.make.data,
model=form.model.data,
purchaseShop=form.purchaseShop.data,
isSold=form.isSold.data,
soldDate=form.soldDate.data,
isDealer=form.isDealer.data,
buyerName=form.buyerName.data,
address=form.address.data,
phoneNo=form.phoneNo.data,
idNumber=form.idNumber.data,
salePrice=form.salePrice.data,
url=img,
purchasePrice=form.purchasePrice.data,
soldPrice=form.soldPrice.data,
owners=form.owners.data,
engine=form.engine.data,
chasis=form.chasis.data,
finance=form.finance.data,
colour=form.colour.data,
kms=form.kms.data,
fuel=form.fuel.data
)
db.session.add(user)
db.session.commit()
flash("Added Successfully")
return redirect(url_for('main.display_route'))
return render_template('add_vehicle.html',form=form)
@main.route('/view/<id>')
def view(id):
bike=Vehicle.query.get(id)
return render_template('view.html',bike=bike)
@main.route('/edit/<id>',methods=['GET','POST'])
@login_required
def edit(id):
vehicle=Vehicle.query.get(id)
form=Add_vehicle_form(obj=vehicle)
if form.validate_on_submit():
vehicle.vehicleNumber=form.vehicleNumber.data
vehicle.insuranceEndDate=form.insuranceEndDate.data
vehicle.purchaseDate=form.purchaseDate.data
vehicle.year=form.year.data
vehicle.make=form.make.data
vehicle.model=form.model.data
vehicle.purchaseShop=form.purchaseDate.data
vehicle.isSold=form.isSold.data
vehicle.isDealer=form.isDealer.data
vehicle.buyerName=form.buyerName.data
vehicle.address=form.address.data
vehicle.phoneNo=form.phoneNo.data
vehicle.idNumber=form.idNumber.data
vehicle.salePrice=form.salePrice.data
vehicle.purchasePrice=form.purchasePrice.data
vehicle.soldPrice=form.soldPrice.data
vehicle.owners=form.owners.data
vehicle.engine=form.engine.data
vehicle.chasis=form.chasis.data
vehicle.finance=form.finance.data
vehicle.colour=form.colour.data
vehicle.kms=form.kms.data
vehicle.fuel=form.fuel.data
vehicle.soldDate=form.soldDate.data
file = request.files.getlist('url')
if file:
for f in file:
if f.filename:
filename = secure_filename(f.filename)
f.save(os.path.join(UPLOAD_FOLDER, filename))
if vehicle.url==None or vehicle.url=="":
vehicle.url=filename
else:
vehicle.url=vehicle.url+","+filename
if form.isSold.data=='True' and vehicle.url != "":
list=vehicle.url.split(',')
for l in list:
if os.path.exists(os.path.join(UPLOAD_FOLDER,l)):
os.remove(os.path.join(UPLOAD_FOLDER,l))
vehicle.url=""
db.session.commit()
flash("Edited Successfully!")
return redirect(url_for('main.display_route'))
return render_template('edit.html',form=form,flag='edit')
@main.route('/delete/<b_id>',methods=['GET','POST'])
@login_required
def delete_vehicle(b_id):
bike=Vehicle.query.get(b_id)
if request.method == 'POST':
if bike.url != "":
list=bike.url.split(',')
for l in list:
if os.path.exists(os.path.join(UPLOAD_FOLDER,l)):
os.remove(os.path.join(UPLOAD_FOLDER,l))
db.session.delete(bike)
db.session.commit()
flash('Deleted Successfully!')
return redirect(url_for('main.display_route'))
return render_template('delete.html',bike=bike)
@main.route('/search/<flag>',methods=['GET','POST'])
@login_required
def search(flag):
form=search_form()
if form.validate_on_submit():
bike=Vehicle.query.filter_by(vehicleNumber=form.vehicleNumber.data).first()
if bike and flag == 'search':
return redirect(url_for('main.view',id=bike.id))
elif bike and flag=='edit1':
return redirect(url_for('main.edit',id=bike.id))
elif bike and flag=='delete':
return redirect(url_for('main.delete_vehicle',b_id=bike.id))
flash('No record found!')
return render_template('edit.html',form=form,flag=flag)
@main.route('/search-cust',methods=['GET','POST'])
@login_required
def searchCustomer():
cust=Customer_form()
flag='form'
if cust.validate_on_submit():
cust=Vehicle.query.filter_by(phoneNo=cust.phoneNo.data).all()
flag='display'
if not cust:
flash('No record found!')
return redirect(url_for('main.searchCustomer'))
return render_template('customer.html',form=cust,flag=flag)
| {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,534 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /config/dev.py | SECRET_KEY='topsecret'
SQLALCHEMY_DATABASE_URI='postgresql://postgres:top_secret@localhost/catalog_db'
SQLALCHEMY_TRACK_MODIFICATIONS=False
DEBUG=True
| {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,535 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /bike/garage/__init__.py | # garage/__init__.py
from flask import Blueprint
main=Blueprint('main',__name__,template_folder='templates')
from bike.garage import routes
| {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,536 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /bike/garage/forms.py | from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField, PasswordField, BooleanField,IntegerField,FloatField,RadioField, SelectField,FileField
from wtforms.validators import EqualTo, Email,Length,DataRequired,ValidationError,Optional
from datetime import datetime
class Add_vehicle_form(FlaskForm):
vehicleNumber=StringField("Registration Number",validators=[DataRequired(),Length(3,10,message='Invalid registration number! Enter without space')])
make=SelectField("Manufactured by",validators=[DataRequired()],choices=[('Tata Motors','Tata Motors'),
('Hyundai','Hyundai'),('Maruthi Suzuki','Maruthi Suzuki'),('Chevrolet','Chevrolet'),('Mahindra','Mahindra'),
('Honda','Honda'),('Toyota','Toyota'),('Ford','Ford'),('Renault','Renault')],coerce=str)
model=StringField("Model",validators=[DataRequired()])
year=IntegerField("Manufacturing year",validators=[DataRequired()])
owners=SelectField("No. of owners",validators=[Optional()],choices=[('1','One'),('2','Two'),('3','Three'),('More than 3','More than 3')],coerce=str)
kms=IntegerField("Kilometers run",validators=[DataRequired()])
colour=StringField("Colour",validators=[Optional()])
fuel=SelectField("Fuel",validators=[DataRequired()],choices=[('Petrol','Petrol'),('Diesel','Diesel'),('LPG','LPG'),('Petrol and LPG','Petrol and LPG')],coerce=str)
finance=StringField("Hypothecation",validators=[Optional()])
insuranceEndDate=StringField("Insurance end date",validators=[Optional()],default='Nil')
engine=StringField("Engine number",validators=[Optional()],default='Nil')
chasis=StringField("Chasis Number",validators=[Optional()],default='Nil')
purchaseDate=StringField("Purchase date",validators=[DataRequired()])
purchaseShop=StringField("Purchased from",validators=[DataRequired()])
purchasePrice=FloatField("Purchase Price",validators=[Optional()])
salePrice=FloatField("Sale Price",validators=[DataRequired()])
isSold=SelectField("Vehicle is sold?",choices=[('True','Yes'),('False','No')],validators=[DataRequired()],coerce=str)
soldDate=StringField("Sold Date ",validators=[Optional()],default=datetime.date(datetime.now()))
soldPrice=FloatField("Sold Price",validators=[Optional()],default=0)
isDealer=SelectField("Is sold to dealer?",validators=[Optional()],choices=[('True','Yes'),('False','No')],coerce=str)
buyerName=StringField("Buyer's Name",validators=[Optional()],default='Nil')
address=StringField("Buyer's Address",validators=[Optional()],default='Nil')
phoneNo=StringField("Buyer's Contact number",validators=[Optional()],default='Nil')
idNumber=StringField("Buyer's ID Proof",validators=[Optional()],default='Nil')
url=FileField('Photo',render_kw={'multiple': True})
submit=SubmitField()
class search_form(FlaskForm):
vehicleNumber=StringField("Registration Number",validators=[DataRequired(),Length(3,10,message='Invalid registration number! Enter without space')])
submit=SubmitField()
class Customer_form(FlaskForm):
phoneNo=StringField("Contact number",validators=[DataRequired()])
submit=SubmitField()
| {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,537 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /bike/auth/models.py | from bike import db,bcrypt
from datetime import datetime
from flask_login import UserMixin
from flask import flash
class Users(UserMixin,db.Model):
__tablename__='users'
id=db.Column(db.Integer,primary_key=True)
user_name=db.Column(db.String(15),nullable=False)
user_email=db.Column(db.String(30),unique=True,index=True)
user_pw=db.Column(db.String(60))
register_date=db.Column(db.DateTime,default=datetime.now)
def check_password(self,password):
return bcrypt.check_password_hash(self.user_pw,password)
@classmethod
def create_user(cls,user,email,password):
usr=cls(user_name=user,
user_email=email,
user_pw=bcrypt.generate_password_hash(password).decode('utf-8')
)
db.session.add(usr)
db.session.commit()
return usr | {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,538 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /bike/auth/routes.py | from bike.auth import auth
from flask import render_template,request,redirect,flash,url_for
from bike.auth.forms import Registration_form, Login_form
from bike.auth.models import Users
from bike import login_manager,bcrypt
from flask_login import login_user,logout_user,login_required
@auth.route('/register', methods=['GET','POST'])
@login_required
def register():
form=Registration_form()
if form.validate_on_submit():
Users.create_user(
user=form.name.data,
email=form.email.data,
password=form.password.data
)
flash('Registration Successful')
return redirect(url_for('auth.do_the_login'))
return render_template('register.html',form=form)
@auth.route('/login', methods=['GET','POST'])
def do_the_login():
form=Login_form()
if form.validate_on_submit():
user=Users.query.filter_by(user_email=form.email.data).first()
if not user or not user.check_password(form.password.data):
flash("Invalid credentials! Please try again")
return redirect(url_for('auth.do_the_login'))
login_user(user,remember=form.stay_logged_in.data)
flash('Logged in successfully!')
return redirect(url_for('main.display_route'))
return render_template('login.html',form=form)
@auth.route('/logout')
@login_required
def do_the_logout():
logout_user()
flash("Signed out successfully!")
return redirect(url_for('main.display_route'))
@login_manager.user_loader
def load_user(id):
return Users.query.get(int(id))
| {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,539 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /bike/auth/forms.py | from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField, PasswordField, BooleanField
from wtforms.validators import EqualTo, Email,Length,DataRequired,ValidationError
class Registration_form(FlaskForm):
name=StringField("Enter your name/username",validators=[DataRequired(),Length(3,15,message='character lenght should be between 3 & 15')])
email=StringField("Enter your email",validators=[DataRequired(),Email()])
password=PasswordField("Enter your password",validators=[DataRequired(),EqualTo('confirm',message='password does not match')])
confirm=PasswordField("confirm your password",validators=[DataRequired()])
submit=SubmitField()
class Login_form(FlaskForm):
email=StringField("Enter your registered email",validators=[DataRequired(),Email()])
password=PasswordField("Enter your password",validators=[DataRequired()])
stay_logged_in=BooleanField("Stay logged in")
submit=SubmitField() | {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,540 | ArunSelvaraj7/carDealerFlaskApp | refs/heads/master | /bike/garage/models.py | from bike import db
class Vehicle(db.Model):
__tablename__='vehicle'
id=db.Column(db.Integer,primary_key=True)
vehicleNumber=db.Column(db.String(15),nullable=False)
make=db.Column(db.String(30),nullable=False)
model=db.Column(db.String(30),nullable=False)
year=db.Column(db.Integer,nullable=False)
# isInsurance=db.Column(db.String(10),nullable=False)
insuranceEndDate=db.Column(db.String(20))
salePrice=db.Column(db.Float,nullable=False)
purchaseDate=db.Column(db.String(20),nullable=False)
purchaseShop=db.Column(db.String(30),nullable=False)
isSold=db.Column(db.String(10),nullable=False)
isDealer=db.Column(db.String(10))
buyerName=db.Column(db.String(15))
address=db.Column(db.String(45))
phoneNo=db.Column(db.String(12))
idNumber=db.Column(db.String(30))
url=db.Column(db.String(200))
purchasePrice=db.Column(db.Float)
soldPrice=db.Column(db.Float)
soldDate=db.Column(db.String(20))
owners=db.Column(db.String(30))
engine=db.Column(db.String(40))
chasis=db.Column(db.String(40))
finance=db.Column(db.String(50))
colour=db.Column(db.String(20))
kms=db.Column(db.Integer)
fuel=db.Column(db.String(20))
def __init__(self,vehicleNumber,insuranceEndDate,purchaseDate,year,
make,model,purchaseShop,isSold,isDealer,buyerName,address,phoneNo,idNumber,salePrice,url,
purchasePrice,soldPrice,owners,engine,chasis,finance,colour,kms,fuel,soldDate):
self.insuranceEndDate=insuranceEndDate
self.vehicleNumber=vehicleNumber
self.salePrice=salePrice
self.purchaseDate=purchaseDate
self.year=year
self.purchaseShop=purchaseShop
self.make=make
self.model=model
self.isSold=isSold
self.isDealer=isDealer
self.buyerName=buyerName
self.address=address
self.phoneNo=phoneNo
self.idNumber=idNumber
self.url=url
self.purchasePrice=purchasePrice
self.soldPrice=soldPrice
self.owners=owners
self.engine=engine
self.chasis=chasis
self.finance=finance
self.colour=colour
self.kms=kms
self.fuel=fuel
self.soldDate=soldDate
def __repr__(self):
return 'The Vehicle number is {}'.format(self.vehicleNumber)
| {"/bike/__init__.py": ["/bike/garage/__init__.py", "/bike/auth/__init__.py"], "/run.py": ["/bike/__init__.py", "/bike/auth/models.py"], "/bike/garage/routes.py": ["/bike/garage/__init__.py", "/bike/garage/models.py", "/bike/garage/forms.py", "/bike/__init__.py"], "/bike/auth/models.py": ["/bike/__init__.py"], "/bike/auth/routes.py": ["/bike/auth/__init__.py", "/bike/auth/forms.py", "/bike/auth/models.py", "/bike/__init__.py"], "/bike/garage/models.py": ["/bike/__init__.py"]} |
72,541 | oleynes/FundRFID | refs/heads/master | /FundRFID/manager/views.py | from django.shortcuts import render
from django.contrib import messages
from .forms import MemberForm, LookupForm
from .models import Member
from django.shortcuts import redirect
import pdb
# Create your views here.
def register(request):
if request.method == 'GET':
form = MemberForm()
return render(request, context={'form':form}, template_name='register.html')
elif request.method == 'POST':
member = MemberForm(request.POST)
if member.is_valid():
print('inside member valid')
post = member.save(commit=False)
post.save()
messages.add_message(request, messages.INFO, 'Form Submitted Successfully! Use the Fundrace Lookup page '
'to check your score!')
return redirect('/')
else:
print('member was invalid')
messages.add_message(request, messages.INFO, 'Something went wrong, maybe try again in a few minutes?')
return render(request, context={'form': MemberForm()}, template_name='register.html')
else:
form = MemberForm()
return render(request, context={'form': form}, template_name='register.html')
def lookup(request):
if request.method == 'GET':
form = LookupForm()
return render(request, context={'form': form}, template_name='lookup.html')
elif request.method == 'POST':
form_data = LookupForm(request.POST)
if form_data.is_valid():
_id = form_data.cleaned_data['paws_id']
member = Member.objects.get(pk=_id)
return render(request, context={'score': member.score}, template_name='score.html')
else:
form = LookupForm()
return render(request, context={'form': form}, template_name='lookup.html')
else:
return redirect('/') | {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,542 | oleynes/FundRFID | refs/heads/master | /FundRFID/api_endpoint/views.py | from manager.models import Member
from django.db.models import F
from django.http import JsonResponse
# Create your views here.
def update_cli(request, tag_id, score):
member = Member.objects.get(tag_UID=tag_id)
member.score = F('score') + score
try:
member.save()
return JsonResponse({'status': True})
except:
return JsonResponse({'status': False})
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,543 | oleynes/FundRFID | refs/heads/master | /FundRFID/forms/models.py | from django.db import models
# Create your models here.
class FormLink(models.Model):
link = models.CharField(max_length=500)
title = models.CharField(max_length=300)
description = models.TextField()
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,544 | oleynes/FundRFID | refs/heads/master | /FundRFID/manager/migrations/0001_initial.py | # Generated by Django 3.0.5 on 2020-04-25 00:33
from django.db import migrations, models
import manager.models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Member',
fields=[
('name', models.CharField(max_length=300)),
('tag_UID', models.CharField(blank=True, max_length=16, verbose_name='Tag UID')),
('email', models.EmailField(max_length=254)),
('score', models.IntegerField(blank=True)),
('img', models.ImageField(blank=True, upload_to=manager.models.create_upload_url, verbose_name='Member Image')),
('PAWS_ID', models.CharField(max_length=6, primary_key=True, serialize=False, verbose_name='PAWS ID')),
('class_year', models.CharField(choices=[('FR', 'Freshman'), ('SO', 'Sophomore'), ('JR', 'Junior'), ('SR', 'Senior'), ('SS', 'Super Senior'), ('GR', 'Graduate'), ('AL', 'Alumni')], default='FR', max_length=2)),
],
),
]
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,545 | oleynes/FundRFID | refs/heads/master | /FundRFID/manager/models.py | from django.db import models
from .validators import validate_pawsid
# Create your models here.
CLASS_YEAR = [
('FR', 'Freshman'),
('SO', 'Sophomore'),
('JR', 'Junior'),
('SR', 'Senior'),
('SS', 'Super Senior'),
('GR', 'Graduate'),
('AL', 'Alumni')
]
def create_upload_url(instance, filename):
return 'usr/{0}'.format(filename)
# stores client info and score
class Member(models.Model):
name = models.CharField(max_length=300)
tag_UID = models.CharField(max_length=16, blank=True, verbose_name='Tag UID')
email = models.EmailField(max_length=254)
score = models.IntegerField(default=0)
img = models.ImageField(upload_to=create_upload_url, blank=True, verbose_name='Member Image')
PAWS_ID = models.IntegerField(verbose_name='PAWS ID', primary_key=True, validators=[validate_pawsid])
class_year = models.CharField(max_length=2, choices=CLASS_YEAR, default='FR')
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,546 | oleynes/FundRFID | refs/heads/master | /FundRFID/home/models.py | from django.db import models
# Create your models here.
class Event(models.Model):
name = models.CharField(max_length=300)
location = models.CharField(max_length=300)
dt = models.DateTimeField()
description = models.TextField()
img = models.ImageField(blank=True, upload_to='events/images/')
def has_img(self):
return self.img is not None
class Announcement(models.Model):
name = models.CharField(max_length=300)
description = models.TextField()
img = models.ImageField(blank=True, upload_to='announcements/images/')
post_date = models.DateTimeField(auto_now=True)
def has_img(self):
return self.img is not None
class EboardMember(models.Model):
POSITIONS = [
('0', 'President'),
('1', 'Vice President'),
('2', 'Treasurer'),
('3', 'Secretary'),
('6', 'Fundraising Chair'),
('7', 'Event\'s Coordinator'),
('8', 'Mystique Chair'),
('4', 'Publicist'),
('5', 'Historian'),
('9', 'Freshman Rep.'),
]
CLASS_YEAR = [
('FR', 'Freshman'),
('SO', 'Sophomore'),
('JR', 'Junior'),
('SR', 'Senior'),
('SS', 'Super Senior'),
('GR', 'Graduate'),
]
first_name = models.CharField(max_length=300)
last_name = models.CharField(max_length=300)
position = models.CharField(choices=POSITIONS, max_length=2, default='FR')
profile = models.ImageField(default='util/blank_profile.png', upload_to='eboard/images/')
email = models.EmailField()
class_year = models.CharField(choices=CLASS_YEAR, max_length=2, default='FR')
def has_img(self):
return self.profile is not None
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,547 | oleynes/FundRFID | refs/heads/master | /FundRFID/home/views.py | from django.shortcuts import render
from .models import EboardMember, Event, Announcement
# Create your views here.
def index(request):
announcements = Announcement.objects.all().order_by('post_date')
return render(request, template_name='index.html', context={'announcements': announcements})
def about(request):
return render(request, template_name='about.html')
def events(request):
all_events = Event.objects.all().order_by('dt')
return render(request, template_name='events.html', context={'events': all_events})
def sort_members(collection):
ls = [None] * 10
for m in collection:
ls[int(m.position)] = m
return ls
def eboard(request):
eboard_members = EboardMember.objects.all()
eboard_members = sort_members(eboard_members)
return render(request, template_name='eboard.html', context={'eboard': eboard_members})
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,548 | oleynes/FundRFID | refs/heads/master | /FundRFID/manager/forms.py | from django import forms
from .models import Member
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Submit
from .validators import validate_pawsid
class MemberForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
super(MemberForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_method = 'post'
self.helper.form_action = ''
self.helper.add_input(Submit('submit', 'Submit'))
class Meta:
model = Member
fields = ['name', 'email', 'PAWS_ID', 'class_year']
class LookupForm(forms.Form):
def __init__(self, *args, **kwargs):
super(LookupForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_method = 'post'
self.helper.form_action = ''
self.helper.add_input(Submit('submit', 'Submit'))
paws_id = forms.IntegerField(label='PAWS ID', validators=[validate_pawsid])
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,549 | oleynes/FundRFID | refs/heads/master | /FundRFID/forms/admin.py | from django.contrib import admin
from .models import FormLink
# Register your models here.
class FormLinkAdmin(admin.ModelAdmin):
fieldsets = [
('Link', {'fields': ['link']}),
('Info', {'fields': ['title', 'description']}),
]
admin.site.register(FormLink, FormLinkAdmin)
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,550 | oleynes/FundRFID | refs/heads/master | /FundRFID/manager/admin.py | from django.contrib import admin
# Register your models here.
from .models import Member
class MemberAdmin(admin.ModelAdmin):
fieldsets = [
('Member Information', {'fields': ['name', 'email', 'img', 'PAWS_ID']}),
('Tag Info', {'fields': ['tag_UID']}),
('Score Info', {'fields': ['score']}),
]
admin.site.register(Member, MemberAdmin)
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,551 | oleynes/FundRFID | refs/heads/master | /FundRFID/home/admin.py | from django.contrib import admin
from .models import Event, Announcement, EboardMember
# Register your models here.
class EventAdmin(admin.ModelAdmin):
fieldsets = [
('Event Information', {'fields': ['name', 'dt', 'location']}),
('Event Details', {'fields': ['description', 'img']}),
]
class AnnouncementAdmin(admin.ModelAdmin):
fieldsets = [
('Announcement Information', {'fields': ['name']}),
('Announcement Details', {'fields': ['description', 'img']})
]
class EboardMemberAdmin(admin.ModelAdmin):
fieldsets = [
('Personal Info', {'fields': ['first_name', 'last_name', 'email']}),
('Extra Info', {'fields': ['profile', 'position', 'class_year']}),
]
admin.site.register(Event, EventAdmin)
admin.site.register(Announcement, AnnouncementAdmin)
admin.site.register(EboardMember, EboardMemberAdmin)
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,552 | oleynes/FundRFID | refs/heads/master | /FundRFID/manager/validators.py | from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _
import math
def validate_pawsid(value):
if count_digits(value) is not 6:
print('value: {}'.format(value))
print('num_digits: {}'.format(count_digits(value)))
raise ValidationError(
_('Your PAWS ID should be 6 digits')
)
def count_digits(val):
return int(math.log10(val)) + 1
| {"/FundRFID/manager/views.py": ["/FundRFID/manager/forms.py", "/FundRFID/manager/models.py"], "/FundRFID/manager/models.py": ["/FundRFID/manager/validators.py"], "/FundRFID/home/views.py": ["/FundRFID/home/models.py"], "/FundRFID/manager/forms.py": ["/FundRFID/manager/models.py", "/FundRFID/manager/validators.py"], "/FundRFID/forms/admin.py": ["/FundRFID/forms/models.py"], "/FundRFID/manager/admin.py": ["/FundRFID/manager/models.py"], "/FundRFID/home/admin.py": ["/FundRFID/home/models.py"]} |
72,556 | rocket-ron/aca-webdev | refs/heads/master | /flask-backend/app/main/views.py | from flask import abort, jsonify, redirect, render_template, request, session, url_for
from . import main
from .forms import InputForm
from uuid import uuid4
from database import get_db, log_query, log_click
from parse import parse_raw
@main.route('/', methods=['GET', 'POST'])
def index():
form = InputForm()
if form.validate_on_submit():
session['session_id'] = unicode(uuid4())
session['state'] = form.state.data
session['raw_query'] = form.query.data
session['parsed_query'] = parse_raw(session['raw_query'])
log_query(session['session_id'], session['state'], session['raw_query'], session['parsed_query'])
return redirect(url_for('main.results'))
return render_template('index.html', form=form)
@main.route('/results')
def results():
response = dict(parsed_query=session['parsed_query'], user_state=session['state'])
return render_template('results.html', response=response)
@main.route('/_clicks', methods=['POST'])
def _clicks():
if ('session_id' not in session) or (not request.form) or ('event' not in request.form):
abort(400)
event = request.form['event']
log_click(session['session_id'], event)
return jsonify({'status': 'OK'}), 201
| {"/flask-backend/app/main/views.py": ["/flask-backend/app/main/forms.py"]} |
72,557 | rocket-ron/aca-webdev | refs/heads/master | /flask-backend/app/main/database.py | import sqlite3
from flask import current_app, g
def get_db():
db = getattr(g, '_database', None)
if db is None:
db = g._database = sqlite3.connect(current_app.config['DATABASE_URI'])
return db
def log_query(session_id, state, raw_query, parsed_query):
conn = get_db()
cur = conn.cursor()
cur.execute("INSERT INTO Queries (session_id, state, raw_query, parsed_query) VALUES (?, ?, ?, ?)", (session_id, state, raw_query, parsed_query))
conn.commit()
cur.close()
def log_click(session_id, click_event):
conn = get_db()
cur = conn.cursor()
cur.execute("INSERT INTO Clicks (session_id, click_event) VALUES (?, ?)", (session_id, click_event))
conn.commit()
cur.close()
| {"/flask-backend/app/main/views.py": ["/flask-backend/app/main/forms.py"]} |
72,558 | rocket-ron/aca-webdev | refs/heads/master | /flask-backend/app/main/parse.py | def parse_raw(raw_query):
return raw_query + "_parsed"
| {"/flask-backend/app/main/views.py": ["/flask-backend/app/main/forms.py"]} |
72,559 | rocket-ron/aca-webdev | refs/heads/master | /flask-backend/app/main/forms.py | from flask_wtf import Form
from wtforms import StringField, SubmitField, SelectField
from wtforms.validators import Required
from us.states import mapping
us_mapping = sorted(mapping('abbr', 'name').items())
class InputForm(Form):
state = SelectField('Select your state:', choices=us_mapping, validators =[ Required()])
query = StringField('What kind of plan are you looking for?', validators =[ Required()])
submit = SubmitField('Submit')
| {"/flask-backend/app/main/views.py": ["/flask-backend/app/main/forms.py"]} |
72,560 | rocket-ron/aca-webdev | refs/heads/master | /flask-backend/app/main/elastic.py | from elasticsearch import Elasticsearch
from elasticsearch_dsl import Search
def get_best_plans(query):
client = Elasticsearch()
s = Search(using=client, index="data", doc_type="plan")\
.query("match", marketing_name=query)
response = s.execute()
return response
| {"/flask-backend/app/main/views.py": ["/flask-backend/app/main/forms.py"]} |
72,566 | kangminsu1/Extended-Kalman-Filter-for-Tracking-Surrounding-Vehicles | refs/heads/main | /Lidar_EKF_for_Real_Car.py | from Extended_KF import *
import time
from datetime import datetime
import warnings
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
import threading
import math
warnings.filterwarnings("ignore")
# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@for only lidar for SCI@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
class EKF_Processor:
def __init__(self):
self.LIDAR = {}
self.predict_info_x = {} # State Vector
self.predict_info_p = {} # State Covariance
self.DT = None
# Plotting My Vehicles----------------------------------
def plot_car(self, x, y, yaw=0.0, WIDTH=1.53, LENGTH=4.37, truckcolor="-k", BACKTOWHEEL=1.0):
outline = np.array([[-BACKTOWHEEL, (LENGTH - BACKTOWHEEL), (LENGTH - BACKTOWHEEL), -BACKTOWHEEL, -BACKTOWHEEL],
[WIDTH / 2, WIDTH / 2, - WIDTH / 2, -WIDTH / 2, WIDTH / 2]])
Rot1 = np.array([[math.cos(yaw), math.sin(yaw)],
[-math.sin(yaw), math.cos(yaw)]])
outline = (outline.T.dot(Rot1)).T
outline[0, :] += x
outline[1, :] += y
plt.plot(np.array(outline[0, :]).flatten(),
np.array(outline[1, :]).flatten(), truckcolor)
plt.plot(x, y, "*", label="My Vehicle")
return outline
# EKF initialize---------------------
def ekf_initialize(self, key, value):
predict_x, predict_p = Init_EKF(value, self.DT)
self.predict_info_x[key] = predict_x
self.predict_info_p[key] = predict_p
# EKF prediction---------------------
def ekf_prediction(self, key, value):
predict_x, predict_p = EKF(self.predict_info_x[key], self.predict_info_p[key], value[0:2], self.DT)
self.predict_info_x[key] = predict_x
self.predict_info_p[key] = predict_p
# EKF Tracking-----------------------
def tracking(self):
measurement = self.LIDAR
compare_key = []
pred_key = list(self.predict_info_x.keys())
# ์ฌ๊ธฐ๋ ๋ด๊ฐ tracking ํ๊ณ ์ ํ๋ ์ฐจ๋์ด ์ด๋ ์๋์ง ํ์ธํ๋ ๋ถ
# ๋จผ์ ์ธก์ ๋ GT LIDAR DATA ๊ฐ์ ธ์ด
temp_gt = {}
for key, value in measurement.items():
Simliarity = np.rad2deg(math.atan2(value[0], value[1])) # ์๋ ์ฐจ๋์ x, y๋ฅผ atan2๋ก ํ์ฌ๊ธ ๋ด ์ฐจ๋๊ณผ์ ์๋๊ฐ์ ์ป๋ ๊ณผ์
temp_gt[key] = Simliarity
# ๊ทธ ๋ค์ predictionํ ์ขํ ๊ฐ์ ๋ถ๋ฌ์์ ์๋ก ๋น๊ตํ๊ธฐ (Cosine ์ ์ฌ๋ ๊ฒ์ถ ๊ธฐ๋ฒ) --> ์ถํ Iou Bounding Box๋ก ๋ฐ๊พธ๋ ๊ฒ์ ์ถ์ฒํจ
# Cosine ์ ์ฌ๋๋ฅผ ์ด ์ด์ ๋ ๊ฐ ์ฐจ๋์ edge point๋ฅผ ์ฐ์ง ์๊ณ ์ค๋ก์ง x, y ์ขํ ๊ฐ๋ง์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ
for key, value in self.predict_info_x.items():
Simliarity = np.rad2deg(math.atan2(value[0], value[1])) #์ด๊ฒ ๋ํ ์์ ๋ง์ฐฌ๊ฐ์ง
# ํ๋์ฉ ๋น๊ตํ๊ธฐ
P_key_lists = []
# ๋ง์ฝ ๋น๊ตํ๊ณ ์ ํ๋ ์ฐจ๋์ด predictionํ ์ฐจ๋๊ณผ์ ์ฐจ์ด๊ฐ 20๋ ์ดํ๋ก ๋ํ๋ ๊ฒฝ์ฐ ๊ทธ ๊ฐ์ ๊ฐ์ ธ์จ๋ค.
for temp_key, temp_value in temp_gt.items():
difference = abs(abs(Simliarity) - abs(temp_value))
if difference < 20:
# GT key data ๋ค์ด ๋ค์ด์จ๋ค
P_key_lists.append(temp_key)
# 0๋ณด๋ค ํด ๋ prediction ์์
if len(P_key_lists) > 0:
# Euclidien ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๋ฒ---------------
results = {}
for key_p in P_key_lists:
results[key_p] = np.hypot(measurement[key_p][0] - value[0], measurement[key_p][0] - value[1])
# ๋น๊ตํด์ ๊ฐ์ฅ ์ ํฉํ ์ธก์ lidar ์์ด๋ append
# ์ด POINT๊ฐ ์ค์ predict_info์ ์๋์ง ๊ฒ์ ์์
while True:
if len(results) == 0:
break
POINT = min(results.keys(), key=lambda k: results[k])
if POINT in pred_key:
break
else:
del results[POINT]
# Euclidien ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๋ฒ---------------
compare_key.append(POINT)
# ๋ง์ฝ ๊ฒฐ๊ณผ ๊ฐ์ด 0๋ณด๋ค ํฌ๋ค๋ฉด EKF ๊ณ์ ์์
if len(results) > 0:
self.ekf_prediction(POINT, measurement[POINT])
# ๋ชจ๋ํฐ๋ง-----------------------------
comp_key = list(set(compare_key))
for POINT in comp_key:
text2 = "Vehicle ID: " + str(POINT)
# Plotting prediction
plt.plot(measurement[POINT][0], measurement[POINT][1], '*', label=text2)
# ๋ชจ๋ํฐ๋ง-----------------------------
measurement_keys = temp_gt.keys()
# ๊ธฐ์กด์ ์ธก์ ๋ ์ฐจ๋ ๋ฐ์ดํฐ์ ์ด์ ์ prediction๋ ์ฐจ๋์ ์ขํ๋ฅผ ๋น๊ตํด์ ๋จ์ ์ฐจ๋ ๋ฐ์ดํฐ๋ค์ delete
residual = list(set(compare_key) - set(measurement_keys))
for id in residual:
del self.predict_info_x[id]
del self.predict_info_p[id]
# ํ์ฌ ์ธก์ ๋ ์ฐจ๋ ๋ฐ์ดํฐ์ ์ด์ ์ prediction๋ ์ฐจ๋ ์ขํ๋ฅผ ๋น๊ตํด์ ๋จ์ ์ฐจ๋ ๋ฐ์ดํฐ๋ค์ append
others = list(set(measurement_keys) - set(compare_key)) # Extract another velocity
for id in others:
self.ekf_initialize(id, measurement[id])
def get_ekf(self, Vehicle_heading, other_info_dict, ALL_STOP):
matplotlib.use('TkAgg')
while True:
if ALL_STOP == 1:
break
# ๋ชจ๋ํฐ๋ง-----------------------------
plt.cla()
# for stopping simulation with the esc key.
plt.gcf().canvas.mpl_connect(
'key_release_event',
lambda event: [exit(0) if event.key == 'escape' else None])
yaw = (Vehicle_heading + 90) * math.pi / 180 # (heading + 90) ๊ฐ๋ณ ๊ฐ๋ฅ
self.plot_car(0.0, 0.0, yaw)
# ๋ชจ๋ํฐ๋ง-----------------------------
# ์ธ๋ถ ์ฐจ๋ ๋ฐ์ดํฐ ๋ถ๋ฌ์ค๊ธฐ-----------------------
Lidar_measurement = {}
for key, value in other_info_dict.items():
Lidar_measurement[key] = [value[0], value[1], value[2]] # x, y, velocity
# For DT---------------------
self.DT = 0.1
# For DT---------------------
self.LIDAR = Lidar_measurement
# ๋ง์ฝ ์ฒ์์ด๋ผ๋ฉด ์ธก์ ๋ ๋ฐ์ดํฐ๋ก initialize----------------
if len(self.predict_info_x) == 0:
for key, value in Lidar_measurement.items():
self.ekf_initialize(key, value)
else:
# ์๋๋ฉด tracking ์์
self.tracking()
plt.title("Lidar Detection and Tracking [LiDAR]")
plt.legend()
plt.xlim(-50, 50)
plt.ylim(-50, 50)
plt.pause(0.001)
print("LiDAR Clear")
print("EKF Processor Clear")
if __name__ == "__main__":
Vehicle_heading = 0.0
other_info_dict = {'1': [-10.0, 10.0, 0.0], '2': [10.0, -10.0, 0.0]} #x, y, velocity [Essential]
ALL_STOP = 0 # for break while
ekf = EKF_Processor()
Sensor_Fusion_and_Tracking = threading.Thread(target=ekf.get_ekf, args=(Vehicle_heading, other_info_dict, ALL_STOP))
Sensor_Fusion_and_Tracking.start()
# Example for realtime checking
heading = 0.0
times = 0.0
DT = 0.1
SIM_TIME = 50.0
while SIM_TIME >= times:
if ALL_STOP == 1:
break
time.sleep(0.1)
times += DT
heading += 0.1
for key, value in other_info_dict.items():
yaw = np.deg2rad(heading)
x = value[0] * math.cos(yaw) + value[1] * math.sin(yaw)
y = value[0] * -math.sin(yaw) + value[1] * math.cos(yaw)
other_info_dict[key] = [x, y, 0.0] | {"/Lidar_EKF_for_Real_Car.py": ["/Extended_KF.py"]} |
72,567 | kangminsu1/Extended-Kalman-Filter-for-Tracking-Surrounding-Vehicles | refs/heads/main | /Extended_KF.py | import numpy as np
from scipy.spatial.transform import Rotation as Rot
import scipy.linalg
import math
def compute_F_and_Q(DT):
__noise_ax = 9
__noise_ay = 9
__F = np.array([
[1.0, 0.0, DT, 0.0],
[0.0, 1.0, 0.0, DT],
[0.0, 0.0, 1.0, 0.0],
[0.0, 0.0, 0.0, 1.0]
])
# Setting Q
DT_2 = DT ** 2
DT_3 = DT ** 3
DT_4 = DT ** 4
E11 = DT_4 * __noise_ax / 4
E13 = DT_3 * __noise_ax / 2
E22 = DT_4 * __noise_ay / 4
E24 = DT_3 * __noise_ay / 2
E31 = DT_3 * __noise_ax / 2
E33 = DT_2 * __noise_ax
E42 = DT_3 * __noise_ay / 2
E44 = DT_2 * __noise_ay
__Q = np.array([[E11, 0.0, E13, 0.0],
[0.0, E22, 0.0, E24],
[E31, 0.0, E33, 0.0],
[0.0, E42, 0.0, E44]])
return __F, __Q
# State Vector ์์ธก ๋ถ
def predict(x, F, P, Q):
state_x = F @ x
state_p = (F @ P @ F.T) + Q
return state_x, state_p
# State Vector ์
๋ฐ์ดํธ ๋ถ
def update(X, P, Z):
__HL = np.array([[1, 0, 0, 0],
[0, 1, 0, 0]])
__RL = np.array([[0.2, 0],
[0, 0.2]])
__xI = np.identity(4)
Y = Z - __HL @ X
PHLT = P @ __HL.T
S = np.array(__HL @ PHLT + __RL)
K = PHLT @ np.linalg.inv(S)
X += K @ Y
P = (__xI - K @ __HL) @ P
return X, P
# ์ด๊ธฐ State Vector ์ค์ ๋ถ [x, y, yaw, velocity]
def Init_EKF(current_info, DT):
__x = np.array([[current_info[0], current_info[1], 0.0, 0.0]]).T
__P = np.array([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1000, 0],
[0, 0, 0, 1000]])
__F, __Q = compute_F_and_Q(DT)
__x, __P = predict(__x, __F, __P, __Q)
__x = np.round(__x, 4)
return __x, __P
# Prediction๊ณผ Update๋ฅผ ์ํํ๋ ๋ถ
def EKF(X, P, measurement, DT):
__z = np.array([[measurement[0], measurement[1]]]).T
__F, __Q = compute_F_and_Q(DT)
X, P = predict(X, __F, P, __Q)
X, P = update(X, P, __z)
X = np.round(X, 4)
return X, P
| {"/Lidar_EKF_for_Real_Car.py": ["/Extended_KF.py"]} |
72,568 | helloworld0833/myachievementspyqt | refs/heads/master | /utilities.py | def parser(file_input):
try:
file_input = file_input.decode('utf-8')
except UnicodeDecodeError:
file_input = file_input.decode('gbk')
lines = []
for line in file_input.split('\r'):
if line.strip():
lines.append(line.strip()+'\n')
return lines
def append_item_to_file(item, file_name):
if item[-1] != '\n':
item = item+'\n'
with open(file_name, 'a') as f:
f.write(item)
def delete_item_from_file(item, file_name):
with open(file_name, 'a+b') as f:
f.seek(0)
lines = parser(f.read())
with open(file_name, 'w') as f:
for line in lines:
if item.strip() != line.strip():
f.write(line)
def calculate_points(lines):
calculate_points = 0
for line in lines:
calculate_points += int((line.strip().split(' ')[-2]))
return calculate_points
| {"/v_box_layout.py": ["/list_widget.py", "/push_button.py", "/utilities.py"], "/list_widget.py": ["/utilities.py"], "/window.py": ["/v_box_layout.py"], "/push_button.py": ["/utilities.py"]} |
72,569 | helloworld0833/myachievementspyqt | refs/heads/master | /v_box_layout.py | from PyQt5.QtWidgets import QWidget, QLabel, QVBoxLayout, QTextBrowser, QHBoxLayout, QTextEdit
from PyQt5.QtCore import Qt
from list_widget import ListWidget
from push_button import ButtonDone, ButtonDelete, ButtonAdd
from utilities import parser, calculate_points
class VBoxLayoutWidget(QWidget):
def __init__(self, maximumWidth=280):
super().__init__(maximumWidth=maximumWidth)
self.next_vbox_layout_widget = None
def set_layout(self, file_name_tuple):
file_type, file_usage = file_name_tuple
file_name = '{}_{}.txt'.format(file_type, file_usage)
vertical_box_layout = QVBoxLayout()
vertical_box_layout.setContentsMargins(0, 0, 0, 0)
label = QLabel(' '.join(file_name_tuple))
label.setAlignment(Qt.AlignCenter)
vertical_box_layout.addWidget(label)
if file_type == 'complete':
with open(file_name, 'a+b') as f:
f.seek(0)
achievement_points = calculate_points(parser(f.read()))
self.text_browser = QTextBrowser(maximumHeight=27)
self.text_browser.setAlignment(Qt.AlignCenter)
self.text_browser.setText('achievement points: {}'.format(achievement_points))
vertical_box_layout.addWidget(self.text_browser)
self.list_widget = ListWidget(file_name, 'recent')
vertical_box_layout.addWidget(self.list_widget)
button_delete = ButtonDelete(self, file_name)
vertical_box_layout.addWidget(button_delete)
else:
self.list_widget = ListWidget(file_name)
vertical_box_layout.addWidget(self.list_widget)
points_text_edit = None
if file_usage == 'note':
button_delete = ButtonDelete(self, file_name)
vertical_box_layout.addWidget(button_delete)
task_text_edit = QTextEdit(maximumHeight=27)
task_text_edit.setPlaceholderText('note')
vertical_box_layout.addWidget(task_text_edit)
else:
horizontal_box_layout = QHBoxLayout()
horizontal_box_layout.setContentsMargins(0, 0, 0, 0)
button_done = ButtonDone(self, file_name)
horizontal_box_layout.addWidget(button_done)
button_delete = ButtonDelete(self, file_name)
horizontal_box_layout.addWidget(button_delete)
widget = QWidget(maximumHeight=27)
widget.setContentsMargins(0, 0, 0, 0)
widget.setLayout(horizontal_box_layout)
vertical_box_layout.addWidget(widget)
horizontal_box_layout = QHBoxLayout()
horizontal_box_layout.setContentsMargins(0, 0, 0, 0)
task_text_edit = QTextEdit(maximumHeight=27)
task_text_edit.setPlaceholderText('task')
horizontal_box_layout.addWidget(task_text_edit)
points_text_edit = QTextEdit(maximumHeight=27)
points_text_edit.setPlaceholderText('points')
points_text_edit.setText('1')
horizontal_box_layout.addWidget(points_text_edit)
widget = QWidget(maximumHeight=27)
widget.setContentsMargins(0, 0, 0, 0)
widget.setLayout(horizontal_box_layout)
vertical_box_layout.addWidget(widget)
button_add = ButtonAdd(self.list_widget, task_text_edit, file_name, points_text_edit)
vertical_box_layout.addWidget(button_add)
self.setLayout(vertical_box_layout)
| {"/v_box_layout.py": ["/list_widget.py", "/push_button.py", "/utilities.py"], "/list_widget.py": ["/utilities.py"], "/window.py": ["/v_box_layout.py"], "/push_button.py": ["/utilities.py"]} |
72,570 | helloworld0833/myachievementspyqt | refs/heads/master | /list_widget.py | from PyQt5.QtWidgets import QListWidget
from utilities import parser
class ListWidget(QListWidget):
def __init__(self, file_name, mode=''):
super().__init__(minimumHeight=515)
with open(file_name, 'a+b') as f:
f.seek(0)
lines = self._preprocess(parser(f.read()), mode)
for line in lines:
self.addItem('{}'.format(line.strip()))
def _preprocess(self, lines, mode):
if mode == 'recent':
return lines[-20:]
else:
return lines
def add_item(self, item):
self.addItem(item)
def delete_item(self, item):
row = self.row(item)
self.takeItem(row)
| {"/v_box_layout.py": ["/list_widget.py", "/push_button.py", "/utilities.py"], "/list_widget.py": ["/utilities.py"], "/window.py": ["/v_box_layout.py"], "/push_button.py": ["/utilities.py"]} |
72,571 | helloworld0833/myachievementspyqt | refs/heads/master | /window.py | from PyQt5.QtWidgets import QMainWindow, QHBoxLayout, QWidget
from v_box_layout import VBoxLayoutWidget
class Window(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle('my board')
main_horizontal_box_layout = QHBoxLayout()
prior_widget = None
for file_name in [('dashboard', 'work'), ('dashboard', 'fun'), ('dashboard', 'note'), ('complete', 'work'), ('complete', 'fun')]:
widget = VBoxLayoutWidget(maximumWidth=280)
widget.set_layout(file_name)
if prior_widget:
prior_widget.next_vbox_layout_widget = widget
prior_widget = widget
main_horizontal_box_layout.addWidget(widget)
widget = QWidget()
widget.setLayout(main_horizontal_box_layout)
self.setCentralWidget(widget)
| {"/v_box_layout.py": ["/list_widget.py", "/push_button.py", "/utilities.py"], "/list_widget.py": ["/utilities.py"], "/window.py": ["/v_box_layout.py"], "/push_button.py": ["/utilities.py"]} |
72,572 | helloworld0833/myachievementspyqt | refs/heads/master | /push_button.py | import datetime
from PyQt5.QtWidgets import QPushButton
from utilities import append_item_to_file, delete_item_from_file
class ButtonDone(QPushButton):
def __init__(self, vbox_layout_widget, file_name):
super().__init__()
self.vbox_layout_widget = vbox_layout_widget
self.list_widget = vbox_layout_widget.list_widget
self.file_name = file_name
self.setText('Done')
self.pressed.connect(self._done)
def _done(self):
selected_items = self.list_widget.selectedItems()
for item in selected_items:
self.list_widget.delete_item(item)
delete_item_from_file(item.text(), self.file_name)
delete_item_from_file(item.text(), 'backup_{}'.format(self.file_name))
now = datetime.datetime.now()
item_and_time = '{} {}/{}/{}\n'.format(item.text(), now.month, now.day, now.year)
complete_widget = self.vbox_layout_widget.next_vbox_layout_widget.next_vbox_layout_widget.next_vbox_layout_widget
complete_widget.list_widget.addItem(item_and_time.strip())
achievement_points = complete_widget.text_browser.toPlainText().split(' ')
achievement_points[-1] = str(int(achievement_points[-1])+int(item.text().strip().split(' ')[-1]))
complete_widget.text_browser.setText(' '.join(achievement_points))
file_usage = self.file_name.split('.')[0].split('_')[-1]
append_item_to_file(item_and_time, 'complete_{}.txt'.format(file_usage))
append_item_to_file(item_and_time, 'backup_complete_{}.txt'.format(file_usage))
class ButtonDelete(QPushButton):
def __init__(self, vbox_layout_widget, file_name):
super().__init__()
self.vbox_layout_widget = vbox_layout_widget
self.list_widget = vbox_layout_widget.list_widget
self.file_name = file_name
self.setText('Delete')
self.pressed.connect(self._delete)
def _delete(self):
selected_items = self.list_widget.selectedItems()
for item in selected_items:
self.list_widget.delete_item(item)
delete_item_from_file(item.text(), self.file_name)
delete_item_from_file(item.text(), 'backup_{}'.format(self.file_name))
if 'complete' in self.file_name:
achievement_points = self.vbox_layout_widget.text_browser.toPlainText().split(' ')
achievement_points[-1] = str(int(achievement_points[-1])-int(item.text().strip().split(' ')[-2]))
self.vbox_layout_widget.text_browser.setText(' '.join(achievement_points))
class ButtonAdd(QPushButton):
def __init__(self, list_widget, task_text_edit, file_name, points_text_edit=None):
super().__init__()
self.list_widget = list_widget
self.task_text_edit = task_text_edit
self.points_text_edit = points_text_edit
self.file_name = file_name
self.setText('Add')
self.pressed.connect(self._add)
def _add(self):
item = self.task_text_edit.toPlainText()
points = self.points_text_edit.toPlainText() if self.points_text_edit else ''
if item:
if points:
item += ' points: {}'.format(points)
self.points_text_edit.setText('1')
self.list_widget.addItem(item)
self.task_text_edit.clear()
append_item_to_file(item, self.file_name)
append_item_to_file(item, 'backup_{}'.format(self.file_name))
| {"/v_box_layout.py": ["/list_widget.py", "/push_button.py", "/utilities.py"], "/list_widget.py": ["/utilities.py"], "/window.py": ["/v_box_layout.py"], "/push_button.py": ["/utilities.py"]} |
72,573 | NedelkoA/lections | refs/heads/master | /hash.py | from hashlib import md5
import datetime
def hash_md5(str1):
return md5(str1.encode())
class Greeter:
def greet(self, name):
name = name.replace(' ', '')
name = name.title()
date = datetime.datetime.time(datetime.datetime.now())
print(date.hour)
if 12 > date.hour and 6 < date.hour:
return "Good morning " + name
elif 22 > date.hour and 18 < date.hour:
return "Good evening " + name
elif 6 > date.hour and 22 < date.hour:
return "Good night " + name
return "Hello " + name
# print(datetime.now())
# print(datetime(2018, 5, 23, 12, 30))
# if datetime.now() < datetime(2018, 5, 23, 12, 30):
# print(1)
#print(datetime.time(datetime.now()).hour)
gr = Greeter()
print(gr.greet("ivan")) | {"/7.py": ["/hash.py"]} |
72,574 | NedelkoA/lections | refs/heads/master | /lesson8.py | import asyncio
from datetime import datetime
from random import randint
# async def slow_operation():
# await asyncio.sleep(1)
# return 'Future is done'
#
#
# def got_result(future):
# print(future.result())
# loop.stop()
#
#
# loop = asyncio.get_event_loop()
# task = loop.create_task(slow_operation())
# task.add_done_callback(got_result)
# loop.run_forever()
async def slow_routine():
await asyncio.sleep(3)
return datetime.now()
# print(datetime.now())
# loop = asyncio.get_event_loop()
# loop.run_until_complete(asyncio.gather(*[
# slow_routine()
# for x in range(3)
# ]))
# print(datetime.now(), ' ')
async def gen_list():
await asyncio.sleep(1)
list1 = [
randint(1, 10)
for x in range(5)
]
print(list1)
return list1
async def sqrt_coro():
result = await gen_list()
print([
pow(x, 1/2)
for x in result
])
loop = asyncio.get_event_loop()
loop.run_until_complete(sqrt_coro())
| {"/7.py": ["/hash.py"]} |
72,575 | NedelkoA/lections | refs/heads/master | /7.py | import unittest
from hash import Greeter
from unittest.mock import Mock, patch
from datetime import datetime
# class MD5TestCase(unittest.TestCase):
# @patch('hash.md5')
# def test_some_test(self, mock_md5):
# hash_md5('some str')
# print(mock_md5.calls)
# mock_md5.assert_called_with(
# 'some str'.encode()
# )
# class StringTestCase(unittest.TestCase):
# def test_upper(self):
# self.assertEqual('foo'.upper(), 'Foo')
#
# @patch('hashlib.md5')
# def test_profile(self, mock_md5):
# mock_md5()
# mock_md5.return_value = 'Some hash'
# mock_md5.assert_called_with('some param')
# mock_md5.calls()
# profile = Mock(first_name='Ivan')
# print(profile.first_name)
# profile.balance.return_value = 15
# profile.balance.side_effect = Exception('some error')
# print(profile.balance())
class GreeterTestCase(unittest.TestCase):
def test_greet(self):
gr = Greeter()
self.assertEqual(gr.greet('Ivan'), 'Hello Ivan')
def test_greet_2(self):
gr = Greeter()
self.assertEqual(gr.greet(' Ivan '), 'Hello Ivan')
def test_greet_3(self):
gr = Greeter()
self.assertEqual(gr.greet('ivan'), 'Hello Ivan')
@patch('hash.datetime')
def test_greet_4(self, mock_datetime):
gr = Greeter()
mock_datetime.datetime.time.return_value = datetime.time()
self.assertEqual(gr.greet('ivan'), 'Good evening Ivan')
| {"/7.py": ["/hash.py"]} |
72,578 | christhemart/jpdriller | refs/heads/master | /website/jpdriller/views.py | import random
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.models import User
from django.db import IntegrityError
from django.db.models import Max
from django.http import HttpResponse
from django.shortcuts import render
from django.shortcuts import redirect
from .models import *
def index(request):
groups = list(Vocabulary.objects.values('group').distinct())
if request.user.is_authenticated:
settings = UserSettings.objects.get(user__exact=request.user)
context = {'groups': groups, 'user': request.user, 'settings': settings}
else:
context = {'groups': groups, 'user': None}
return render(request, 'jpdriller/index.html', context)
def login_view(request):
username = request.POST.get('login-username', None)
password = request.POST.get('login-password', None)
user = authenticate(username=username, password=password)
if user:
login(request, user)
return redirect('')
def logout_view(request):
if request.user.is_authenticated:
logout(request)
return redirect('')
def register_view(request):
username = request.POST.get('register-username', None)
password = request.POST.get('register-password', None)
if len(password) >= 8 and len(username) >= 4:
try:
user = User.objects.create_user(username=username, password=password)
if user:
user.save()
settings = UserSettings()
settings.user = user
settings.weight = 5
settings.cutoff = 10
settings.save()
login(request, user)
return redirect('')
except IntegrityError:
pass
return redirect('naughty')
def check_username(request):
try:
User.objects.get(username__exact=request.GET['username'])
response = 1
except User.DoesNotExist:
response = 0
return HttpResponse(response)
def get_vocabulary(request):
groups = request.GET['groups']
if groups == 'GETLAST':
vocab = UserSettings.objects.get(user__exact=request.user).last_vocab
else:
groups = groups.split(',')
vocab = Vocabulary.objects.filter(group__in=groups)
if request.user.is_authenticated and random.randint(1, 10) < 10:
settings = UserSettings.objects.get(user__exact=request.user)
if settings.cutoff > 0:
stats = UserVocabStats.objects.filter(user__exact=request.user, vocabulary__in=vocab)
try:
temp = vocab.exclude(id__in=stats.filter(streak__gt=settings.cutoff).values_list('vocabulary'))
if len(temp) > 0:
vocab = temp
except vocab.DoesNotExist:
pass
vocab = vocab[random.randint(0, len(vocab) - 1)]
if request.user.is_authenticated:
settings = UserSettings.objects.get(user__exact=request.user)
settings.last_vocab = vocab
settings.save()
if request.user.is_authenticated:
try:
stat = UserVocabStats.objects.get(user__exact=request.user, vocabulary__exact=vocab)
except UserVocabStats.DoesNotExist:
stat = UserVocabStats()
stat.id = UserVocabStats.objects.all().aggregate(Max('id'))['id__max'] + 1
stat.user = request.user
stat.vocabulary = vocab
stat.count = 0
stat.streak = 0
stat.save()
else:
stat = None
if str(vocab.group) not in ['Hiragana', 'Katakana']:
if request.user.is_authenticated:
settings = UserSettings.objects.get(user__exact=request.user)
response = '1' if random.randint(1, 10) <= settings.weight else '0'
else:
response = str(random.randint(0, 1))
else:
response = '0'
response += ',' + str(vocab.id) + ',' + str(vocab.vocabulary) + ',' + str(vocab.pronunciation) + ',' + str(
vocab.translation) + ',' + str(vocab.note) + ',' + str(vocab.group) + ','
if stat:
response += str(stat.streak)
else:
response += ''
return HttpResponse(response)
def stat_update(request):
if request.user.is_authenticated:
success = request.GET['success']
vocab_id = request.GET['vocabid']
vocab = Vocabulary.objects.get(id__exact=vocab_id)
stat = UserVocabStats.objects.get(user__exact=request.user, vocabulary__exact=vocab)
if int(success):
stat.count += 1
stat.streak += 1
else:
stat.streak = 0
stat.save()
return HttpResponse('')
def save_settings(request):
if request.user.is_authenticated:
weight = request.POST.get('weight', None)
cutoff = request.POST.get('cutoff', None)
settings = UserSettings.objects.get(user__exact=request.user)
settings.weight = weight
settings.cutoff = cutoff
settings.save()
return redirect('')
def save_groups(request):
if request.user.is_authenticated:
settings = UserSettings.objects.get(user__exact=request.user)
settings.selection = request.GET['groups']
settings.save()
return HttpResponse('')
def naughty(request):
response = '<body style="background-color: black; display: flex; justify-content: center; align-items: center;">'
response += '<br><b><span style="font-size: 72px; color: red;">ใพ( ๏ฝฅ`โยด๏ฝฅ)๏พ๏พ</span></b>'
response += '</body>'
return HttpResponse(response)
| {"/website/jpdriller/views.py": ["/website/jpdriller/models.py"]} |
72,579 | christhemart/jpdriller | refs/heads/master | /website/jpdriller/migrations/0002_katakana_vocabulary.py | # Generated by Django 2.0.4 on 2018-05-04 14:40
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('jpdriller', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Katakana',
fields=[
('id', models.IntegerField(primary_key=True, serialize=False, verbose_name='Identifier')),
('katakana', models.CharField(max_length=6, verbose_name='Katakana')),
('romanji', models.CharField(max_length=6, verbose_name='Romanji')),
],
),
migrations.CreateModel(
name='Vocabulary',
fields=[
('id', models.IntegerField(primary_key=True, serialize=False, verbose_name='Identifier')),
('group', models.CharField(max_length=20, verbose_name='Group')),
('vocabulary', models.CharField(max_length=20, verbose_name='Vocabulary')),
('pronounciation', models.CharField(max_length=20, verbose_name='Pronounciation')),
('translation', models.CharField(max_length=20, verbose_name='Translation')),
],
),
]
| {"/website/jpdriller/views.py": ["/website/jpdriller/models.py"]} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.