index int64 | repo_name string | branch_name string | path string | content string | import_graph string |
|---|---|---|---|---|---|
63,283 | IwanVonNeumann/FinAutMin | refs/heads/master | /minimization.py | def new_states_map(C):
Q_ = {}
i = 1
for c in C:
q_name = new_name(i)
Q_[q_name] = c
i += 1
return Q_
def new_name(i):
return "q{}~".format(i)
def new_output_rules(A, q_map, old_out):
new_out = {}
for q_new in q_map.keys():
q_old = list(q_map[q_new])[0]
new_out[q_new] = {a: old_out[q_old][a] for a in A}
return new_out
def new_transition_rules(A, q_map, old_trans):
new_trans = {}
q_map_inv = new_states_map_inv(q_map)
for q_new in q_map.keys():
q_old = list(q_map[q_new])[0]
new_trans[q_new] = {a: q_map_inv[old_trans[q_old][a]] for a in A}
return new_trans
def new_states_map_inv(q_map):
q_map_inv = {}
for k in q_map.keys():
for v in q_map[k]:
q_map_inv[v] = k
return q_map_inv
| {"/main.py": ["/equality.py", "/minimization.py"], "/solution.py": ["/equality.py", "/minimization.py", "/protocol.py"]} |
63,292 | ArJunGawali/Gym | refs/heads/master | /Gym/models.py | from django.db import models
from io import BytesIO
from PIL import Image
from django.core.files import File
def compress(image):
im = Image.open(image)
im_io = BytesIO()
im.save(im_io, 'JPEG', quality=60)
new_image = File(im_io, name=image.name)
return new_image
class img(models.Model):
title = models.TextField()
cover = models.FileField(upload_to='')
def save(self, *args, **kwargs):
new_image = compress(self.cover)
self.cover = new_image
super().save(*args, **kwargs)
def __str__(self):
return self.title
| {"/Gym/forms.py": ["/Gym/models.py"], "/Gym/views.py": ["/Gym/forms.py", "/Gym/models.py"], "/Gym/admin.py": ["/Gym/models.py"]} |
63,293 | ArJunGawali/Gym | refs/heads/master | /Gym/forms.py | from .models import img
from django import forms
class imgform(forms.ModelForm):
class Meta:
model = img
fields = ('title', 'cover',)
labels = {
'title' : ('Security Code'),
'cover' : ('Photo')
}
widgets = {
'title': forms.PasswordInput(
attrs={
'class': 'form-control',
'id': 'scode',
}
),
}
| {"/Gym/forms.py": ["/Gym/models.py"], "/Gym/views.py": ["/Gym/forms.py", "/Gym/models.py"], "/Gym/admin.py": ["/Gym/models.py"]} |
63,294 | ArJunGawali/Gym | refs/heads/master | /Gym/views.py | from django.shortcuts import render
from .forms import imgform
from django.shortcuts import redirect
from .models import img
from django.core.files.storage import FileSystemStorage
from .settings import MEDIA_URL
# Create your views here.
URL = 'http://127.0.0.1:8000/'
def index(request):
return render(request,'base.html')
def gallery(request):
if request.method =="GET":
form = imgform()
images = img.objects.all()
return render(request,'gallery.html',{'form': form , 'images': images ,'URL':URL , 'MEDIA_URL' : MEDIA_URL})
elif request.method=="POST":
form = imgform(request.POST,request.FILES)
scode=request.POST.get('title')
images = img.objects.all()
# myfile = request.FILES['img']
if scode=='G08H10C00':
fs=FileSystemStorage()
if form.is_valid():
form.save()
# imgv=img(request.GET,request.FILES)
# imgv.save()
return redirect('gallery')
else:
msg = 'Wrong Security Code.'
return render(request,'gallery.html',{'msg':msg,'images':images , 'form': form })
def deleteImg(request):
form = imgform(request.POST,request.FILES)
images = img.objects.all()
if request.method=="POST":
if request.POST.get('sc') == 'G08H10C00':
idk=request.GET.get('idk')
img.objects.filter(id=idk).delete()
return redirect('gallery')
else:
msg = 'Wrong Security Code.'
return render(request,'gallery.html',{'msg':msg,'images':images , 'form': form })
else:
return render(request,'gallery.html',{'images':images , 'form': form })
def about(request):
return render(request,'about-us.html')
def sample(request):
if request.method =="GET":
form = imgform()
images = img.object.all()
return render(request,'sample.html',{'form': form ,'images': images})
else:
form = imgform(request.POST,request.FILES)
# myfile = request.FILES['img']
fs=FileSystemStorage()
if form.is_valid():
form.save()
# imgv=img(request.GET,request.FILES)
# imgv.save()
return redirect('gallery')
| {"/Gym/forms.py": ["/Gym/models.py"], "/Gym/views.py": ["/Gym/forms.py", "/Gym/models.py"], "/Gym/admin.py": ["/Gym/models.py"]} |
63,295 | ArJunGawali/Gym | refs/heads/master | /Gym/admin.py | from django.contrib import admin
from .models import img
admin.site.register(img) | {"/Gym/forms.py": ["/Gym/models.py"], "/Gym/views.py": ["/Gym/forms.py", "/Gym/models.py"], "/Gym/admin.py": ["/Gym/models.py"]} |
63,363 | PaulPruliere/fredflaskapi | refs/heads/master | /fetchingBis.py | import numpy as np
import pandas as pd
from collections import Counter
from itertools import chain
import json
import requests
def import_data(spreadsheet):
"""Import data spreadsheet as dataframe and reshape it."""
df = pd.read_csv(spreadsheet,header=1,index_col="Unnamed: 1")
del df["Unnamed: 0"]
df = df.T
return df
def get_request_attributes(path):
"""Extract request attributes."""
attributes = path.split('/')
return attributes
def matches(path,df):
"""List each match attributes."""
attributes = get_request_attributes(path)
attributes = [a for a in attributes if a in df.columns.values] # keep valid attributes
matches = [df.loc[df["{}".format(a)] == "x"].index for a in attributes]
matches = [i for i in chain(*matches)] # flatten matches
return matches
def get_histo(personalities,matches):
"""Build histogram of personalities matches"""
histo = [0]*len(personalities)
for k in matches:
for i,j in enumerate(personalities):
if k == j: histo[i] += 1
return histo
def compute_error(histo):
"""Compute and spread 20 percent error on each attribute."""
attr_error = [ (x*0.2)/((len(histo)-1)*0.8) for x in histo]
error = [sum(attr_error)-attr for attr in attr_error]
histo_error = [x+y for x,y in zip(histo,error)]
return histo_error
def normalize(seq):
"""Normalize list."""
normalized = [float(x)/sum(seq) for x in seq]
return normalized
def threshold(matches,threshold=0.02):
"""Build an "others" category with small values."""
others = reduce(lambda x,y: x+y,[matches[i] for i in matches if matches[i] < threshold])
matches = {i:matches[i] for i in matches if matches[i] >= threshold}
matches['others'] = others
return matches
def jsonify_counter(counter):
"""Change counter to json array."""
jarray = json.dumps([{"personality":i,"probability":j} for i,j in counter.items()])
return jarray
def fetcher(path,spreadsheet):
"""Wrap all above functions."""
# IMPORT VARIABLES
df = import_data(spreadsheet)
personalities = list(df.index)
match = matches(path,df)
# CALCULATION
normalized = normalize(compute_error(get_histo(personalities,match)))
data = threshold(dict(zip(personalities,normalized)))
return jsonify_counter(data)
| {"/fredapp.py": ["/fetchingBis.py"]} |
63,364 | PaulPruliere/fredflaskapi | refs/heads/master | /fetching.py | import numpy as np
import pandas as pd
from collections import Counter
import json
import requests
def import_data(spreadsheet):
"""Import data spreadsheet as dataframe and reshape it."""
df = pd.read_csv(spreadsheet,header=1,index_col="Unnamed: 1")
del df["Unnamed: 0"]
df = df.T
return df
def get_request_attributes(path):
"""Extract request attributes."""
attributes = path.split('/')
return attributes
def count_matches(path,df):
"""Count how offen attributes match."""
attributes = get_request_attributes(path)
attributes = [a for a in attributes if a in df.columns.values] #keep valid attributes only
matches = []
for attr in attributes:
matches.extend(df.loc[df["{}".format(attr)]=="x"].index)
matches = dict(Counter(matches))
return matches
def normalize(counter):
"""Normalize counter values to add up up to 1."""
norm = sum(counter.values())
counter.update((x,float(y)/norm) for x,y in counter.items())
return counter
def jsonify_counter(counter):
"""Change counter to json array."""
jarray = json.dumps([{"personality":i,"probability":j} for i,j in counter.items()])
return jarray
def fetcher(path,spreadsheet):
"""Wrap up functions above return json array."""
df = import_data(spreadsheet)
probabilities = normalize(count_matches(path,df))
return jsonify_counter(probabilities) | {"/fredapp.py": ["/fetchingBis.py"]} |
63,365 | PaulPruliere/fredflaskapi | refs/heads/master | /fredapp.py | import os
from flask import Flask, render_template
from fetchingBis import fetcher
app = Flask(__name__)
app.debug = True
@app.route('/probabilities/<path:path>')
def probabilities(path):
spreadsheet = "dataset-code-challenge - personalities_data.csv"
data = fetcher(path,spreadsheet)
return render_template("probabilities.html",title="fredapp",data=data)
if __name__ == '__main__':
port = int(os.environ.get('PORT', 5000))
app.run(host='0.0.0.0', port=port) | {"/fredapp.py": ["/fetchingBis.py"]} |
63,367 | MoAlrubaie/SentimentAnalysis | refs/heads/master | /helper.py | from nltk.corpus import stopwords
from nltk.tokenize import TweetTokenizer
from nltk.stem import PorterStemmer
import string
import re
happy_emotion_icons_set = set([
':-)', ':)', ';)', ':o)', ':]', ':3', ':c)', ':>', '=]', '8)', '=)', ':}',
':^)', ':-D', ':D', '8-D', '8D', 'x-D', 'xD', 'X-D', 'XD', '=-D', '=D',
'=-3', '=3', ':-))', ":'-)", ":')", ':*', ':^*', '>:P', ':-P', ':P', 'X-P',
'x-p', 'xp', 'XP', ':-p', ':p', '=p', ':-b', ':b', '>:)', '>;)', '>:-)',
'<3'
])
sad_emotion_icons_set = set([
':L', ':-/', '>:/', ':S', '>:[', ':@', ':-(', ':[', ':-||', '=L', ':<',
':-[', ':-<', '=\\', '=/', '>:(', ':(', '>.<', ":'-(", ":'(", ':\\', ':-c',
':c', ':{', '>:\\', ';('
])
all_emotions_icons = happy_emotion_icons_set | sad_emotion_icons_set
class helperClass():
def __init__(self):
self.stopwords= stopwords.words('english')
self.stemmer = PorterStemmer()
def clean_tweet(self,tweet):
clean_tweets= []
#Remove hashtags
tweet = re.sub(r'#', '', tweet)
#Remove hyperlinks
tweet = re.sub(r'https?:\/\/.*[\r\n]*', '', tweet)
#Remove old style retweet text "RT"
tweet = re.sub(r'^RT[\s]+', '', tweet)
#remove all single characters
tweet = re.sub(r'\s+[a-zA-Z]\s+', ' ', tweet)
#Tokenize tweet
tokenizer = TweetTokenizer(preserve_case=False, strip_handles=True, reduce_len=True)
tweet_tokens = tokenizer.tokenize(tweet)
for word in tweet_tokens:
#remove stopwords
#remove emotion icons
#remove punctuation
#stemming word
if (word not in self.stopwords and word not in all_emotions_icons and word not in string.punctuation):
stem_word = self.stemmer.stem(word)
clean_tweets.append(stem_word)
return clean_tweets
def bag_of_words(self,tweet):
tweet_words = self.clean_tweet(tweet)
words_dict = dict([word, True] for word in tweet_words)
return words_dict
| {"/display.py": ["/twitterSentimentAnalysis.py", "/helper.py"], "/twitterSentimentAnalysis.py": ["/helper.py"]} |
63,368 | MoAlrubaie/SentimentAnalysis | refs/heads/master | /display.py | import tkinter as tk
import twitterSentimentAnalysis
from helper import helperClass
classifier = twitterSentimentAnalysis.get_classifier()
helper = helperClass()
root= tk.Tk()
canvas1 = tk.Canvas(root, width = 400, height = 400, relief = 'raised')
canvas1.pack()
lbl1 = tk.Label(root, text='Tweet Sentiment Analysis')
lbl1.config(font=('verdana', 14))
canvas1.create_window(200, 25, window=lbl1)
lbl2 = tk.Label(root, text='Type your Tweet:')
lbl2.config(font=('verdana', 10))
canvas1.create_window(200, 75, window=lbl2)
entry1 = tk.Entry(root, width=50)
canvas1.create_window(200, 100, window=entry1)
def entered_tweet_feature_set():
x1 = entry1.get()
custom_tweet_feature_set = helper.bag_of_words(x1)
return custom_tweet_feature_set
def get_probability_result():
prob_result = classifier.prob_classify(entered_tweet_feature_set())
return prob_result
def get_tweet_probability():
return get_probability_result().max()
def get_tweet_analysis():
lbl3 = tk.Label(root, text= 'The Probability Result for the entered Tweet is:',font=('verdana', 10))
canvas1.create_window(200, 200, window=lbl3)
lbl4 = tk.Label(root, text= get_tweet_probability(),font=('verdana', 12, 'bold'))
canvas1.create_window(200, 220, window=lbl4)
lbl5 = tk.Label(root, text= 'The Positive Probability is:',font=('verdana', 10))
canvas1.create_window(200, 240, window=lbl5)
lbl6 = tk.Label(root, text= str(round((get_probability_result().prob("pos") *100), 2)) + "%" ,font=('verdana', 12, 'bold'))
canvas1.create_window(200, 260, window=lbl6)
lbl7 = tk.Label(root, text= 'The Negative Probability is:',font=('verdana', 10))
canvas1.create_window(200, 280, window=lbl7)
lbl8 = tk.Label(root, text= str(round((get_probability_result().prob("neg") *100), 2)) + "%",font=('verdana', 12, 'bold'))
canvas1.create_window(200, 300, window=lbl8)
btn1 = tk.Button(text='Get Tweet Sentiment Analysis', command=get_tweet_analysis, bg='brown', fg='white', font=('verdana', 9, 'bold'))
canvas1.create_window(200, 140, window=btn1)
root.mainloop() | {"/display.py": ["/twitterSentimentAnalysis.py", "/helper.py"], "/twitterSentimentAnalysis.py": ["/helper.py"]} |
63,369 | MoAlrubaie/SentimentAnalysis | refs/heads/master | /twitterSentimentAnalysis.py | from nltk.corpus import twitter_samples
from nltk import classify
from nltk import NaiveBayesClassifier
from random import shuffle
from helper import helperClass
helper = helperClass()
#preview the data fields
print (twitter_samples.fileids())
#Split the data in groups
positive_tweets = twitter_samples.strings('positive_tweets.json')
negative_tweets = twitter_samples.strings('negative_tweets.json')
all_tweets = twitter_samples.strings('tweets.20150430-223406.json')
#View the length of each group
print ("Positive Tweets Length: " + str(len(positive_tweets)))
print ("Negative Tweets Length: " + str(len(negative_tweets)))
print ("All Tweets Length: " + str(len(all_tweets)))
#preview samples from each group of tweets
for strings in (positive_tweets[:5], negative_tweets[:5], all_tweets[:5]):
print(strings)
print(4*"------")
print("******************************************")
print("******************************************")
custom_tweet = "RT @Twitter @mohafad87 Hello World! Have a great day all. :) #good #morning http://moalrubaie.com"
#view the clean tweet from the custom
print(helper.clean_tweet(custom_tweet))
#use bag of words method
print (helper.bag_of_words(custom_tweet))
#positive & negative tweets feature set
positive_tweets_feature_set = []
negative_tweets_feature_set = []
for tweet in positive_tweets:
positive_tweets_feature_set.append((helper.bag_of_words(tweet), 'pos'))
for tweet in negative_tweets:
negative_tweets_feature_set.append((helper.bag_of_words(tweet), 'neg'))
#shuffle before set test and train data
shuffle(positive_tweets_feature_set)
shuffle(negative_tweets_feature_set)
test_set = positive_tweets_feature_set[:1000] + negative_tweets_feature_set[:1000]
train_set = positive_tweets_feature_set[1000:] + negative_tweets_feature_set[1000:]
#create the NaiveBayes Classifier
classifier = NaiveBayesClassifier.train(train_set)
#get the accuracy
classifier_accuracy = classify.accuracy(classifier, test_set)
print("The Accuracy is: " + str(round((classifier_accuracy *100), 2)) + "%" )
#show the most informative features
print (classifier.show_most_informative_features(5))
#Get the classifier to be used in the display class for custom tweets purpose only
def get_classifier():
return classifier | {"/display.py": ["/twitterSentimentAnalysis.py", "/helper.py"], "/twitterSentimentAnalysis.py": ["/helper.py"]} |
63,370 | ahyeek78/ReaToyRobot | refs/heads/master | /test-rea-robot.py | #!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################################################################################################################################################
## Start Date: 19-Feb-2019
## Last Modified: 23-Feb-2019
## Version: 1.5
##
## TDD - REA Robot Training Program
## 20-Feb-2019 Initial testing skelaton developed.
## 21-Feb-2019 Add test_rea_robot_object and test_rea_robot_command.
## 22-Feb-2019 Add in 4 corner edge movement ignore test case.
## 23-Feb-2019 Add in command file line test cases.
#####################################################################################################################################################################
import unittest
from rea_robot import *
class ReaRobotTests(unittest.TestCase):
rr = ReaRobot()
def test_rea_robot_object(self):
self.assertEqual(self.rr.report_name(), 'Rea Toy Robot !!!')
def test_rea_robot_command(self):
self.assertTrue(self.rr.chk_command("PLACE"))
self.assertTrue(self.rr.chk_command("MOVE"))
self.assertTrue(self.rr.chk_command("LEFT"))
self.assertTrue(self.rr.chk_command("RIGHT"))
self.assertFalse(self.rr.chk_command("BACK"))
self.assertFalse(self.rr.chk_command("TURN"))
def test_rea_robot_example(self):
## Default place to (0,0,NORTH)
self.rr.place()
self.assertEqual(self.rr.get_report(), "0,0,NORTH")
self.rr.place(0,0,"NORTH")
self.rr.move()
self.assertEqual(self.rr.get_report(), "0,1,NORTH")
self.rr.place(0,0,"NORTH")
self.rr.left()
self.assertEqual(self.rr.get_report(), "0,0,WEST")
self.rr.place(1,2,"EAST")
self.rr.move()
self.rr.move()
self.rr.left()
self.rr.move()
self.assertEqual(self.rr.get_report(), "3,3,NORTH")
def test_rea_robot_edge_lower_left_corner(self):
self.rr.place()
self.rr.left()
self.rr.move()
self.rr.move()
self.rr.move()
## Robot remain lower left corner. Moving will drop.
self.assertEqual(self.rr.get_report(), "0,0,WEST")
def test_rea_robot_edge_lower_right_corner(self):
self.rr.place(4, 0, "WEST")
self.rr.right()
self.rr.right()
self.rr.move()
self.rr.move()
self.rr.move()
## Robot remain lower right corner. Moving will drop.
self.assertEqual(self.rr.get_report(), "4,0,EAST")
def test_rea_robot_edge_upper_right(self):
self.rr.place(4,4,"NORTH")
self.rr.move()
self.rr.move()
self.rr.right()
self.rr.move()
self.rr.move()
self.rr.right()
## Robot remain upper right corner.
self.assertEqual(self.rr.get_report(), "4,4,SOUTH")
def test_rea_robot_edge_upper_left(self):
self.rr.place(0,4,"NORTH")
self.rr.move()
self.rr.move()
self.rr.left()
self.rr.move()
self.rr.move()
self.rr.left()
## Robot remain upper left corner.
self.assertEqual(self.rr.get_report(), "0,4,SOUTH")
def test_rea_robot_process_command_file_1(self):
self.rr.process_command_file("cmd_test_1.txt")
self.assertEqual(self.rr.get_report(), "2,2,NORTH")
def test_rea_robot_process_command_file_2(self):
self.rr.process_command_file("cmd_test_2.txt")
self.assertEqual(self.rr.get_report(), "0,0,WEST")
def test_rea_robot_process_command_file_3(self):
self.rr.process_command_file("cmd_test_3.txt")
self.assertEqual(self.rr.get_report(), "4,4,EAST")
if __name__ == '__main__':
unittest.main() | {"/test-rea-robot.py": ["/rea_robot.py"], "/rea_robot.py": ["/rea_robot_terminal.py"], "/rea_robot_terminal.py": ["/rea_robot.py"]} |
63,371 | ahyeek78/ReaToyRobot | refs/heads/master | /rea_robot.py | #!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################################################################################################################################################
## Start Date: 19-Feb-2019
## Last Modified: 23-Feb-2019
## Version: 1.5
##
## REA Robot Training Program
##
## Commnad Examples:
## python rea_robot.py -i <command file> | -c : Command line interface | -h : Help
##
## Version Tracking
## Ver 1.5.3
## 18-Feb-2019 Start 1st skelaton.
## 19-Feb-2019 Develop ReaRobot class using Singleton design pattern.
## 20-Feb-2019 Develop basic functions and checking functions.
## 21-Feb-2019 Complete all movement function and edge checking condition.
## 22-Feb-2019 Implement command line interactive mode for Rea Robot.
## 22-Feb-2019 Implement error checking for place position with respect to dimension.
## 23-Feb-2019 Implement file input command.
## 23-Feb-2019 Final testing and refactoring.
#####################################################################################################################################################################
### Imports packages
import sys, getopt, os
from rea_robot_terminal import *
############################################################################################################
## Class Defination
############################################################################################################
class ReaRobot:
"""Class level variables"""
__instance = None
## Define table top dimensions (in unit)
dim_x = 5
dim_y = 5
edge_x = dim_x - 1
edge_y = dim_y - 1
## Current Situation of Rea Toy Robot.
curr_x = 0
curr_y = 0
## 0:NORTH, 1:EAST, 2:SOUTH, 3:WEST
## Default to face NORTH.
curr_dir = 0
## Define direction directionary.
dict_dir = {'0':'NORTH', '1':'EAST', '2':'SOUTH', '3':'WEST'}
## Define available command list for checking.
lst_cmd = ['PLACE', 'MOVE', 'LEFT', 'RIGHT', 'REPORT']
## Command line file Processing mode
b_cmd_mode = False
@staticmethod
def get_instance():
""" Static access method. """
if ReaRobot.__instance == None:
ReaRobot()
return ReaRobot.__instance
def __init__(self):
""" Virtually private constructor. """
if ReaRobot.__instance != None:
raise Exception("ReaRobot has already created !")
else:
ReaRobot.__instance = self
def chk_command(self, str_cmd):
"""Check if valid command given"""
return (str_cmd in self.lst_cmd)
def report_name(self):
"""The robot report its name ..."""
return "Rea Toy Robot !!!"
def get_curr_dir(self):
"""Get current robot facing direction."""
return self.dict_dir[str(self.curr_dir)]
def get_curr_position(self):
"""The robot report its current position and facing direction ..."""
str_curr_pos = "My current position at ({},{}) facing {}.".format(self.curr_x, self.curr_y, self.get_curr_dir())
return str_curr_pos
def report_yourself(self):
"""The robot report its info details ..."""
print ("Hello, I am {} ...".format(self.report_name()))
print ("Dimension setting - Witdth:{}, Height:{}".format(self.dim_x, self.dim_y))
print (self.get_curr_position())
def get_report(self):
"""Return simple latest status report."""
return "{},{},{}".format(self.curr_x, self.curr_y, self.get_curr_dir())
def report(self):
print(self. get_report())
def get_dir(self, f):
"""Get facing direction number by given facing string."""
ff = f.upper()
for d, facing in self.dict_dir.items():
if (facing == ff):
dir = int(d)
break
return dir
def place(self, x=0, y=0, f="NORTH"):
"""
Setting a new position and direction for robot.
Robot will take new position and direction only when all parameters are correct.
"""
allow_update = False
if(x >= 0 and x < self.dim_x):
allow_update = True
else:
print("Position setting X = {} is invalid! X value must within range [{}, {}].".format(x, 0, self.edge_x))
return
if(y >= 0 and y < self.dim_y):
allow_update = True
else:
print("Position setting Y = {} is invalid! Y value must within range [{}, {}].".format(y, 0, self.edge_y))
return
ff = f.upper()
if (ff in self.dict_dir.values()):
allow_update = True
else:
print("{} is not a valid facing direction! Please input values: {}".format(f, self.dict_dir.values()))
return
if(allow_update):
self.curr_x = x
self.curr_y = y
self.curr_dir = self.get_dir(f)
def do_move(self):
## Direction facing NORTH
if (self.curr_dir == 0):
self.curr_y = self.curr_y + 1
## Direction facing EAST
elif (self.curr_dir == 1):
self.curr_x = self.curr_x + 1
## Direction facing SOUTH
elif (self.curr_dir == 2):
self.curr_y = self.curr_y - 1
## Direction facing WEST
elif (self.curr_dir == 3):
self.curr_x = self.curr_x - 1
def allow_move(self):
if (
## current X < Edge_X and Robot facing EAST
(self.curr_x < self.edge_x and self.curr_dir == 1) or
## current X > 0 and Robot facing WEST
(self.curr_x > 0 and self.curr_dir == 3) or
## current Y < Edge_Y and Robot facing NORTH
(self.curr_y < self.edge_y and self.curr_dir == 0) or
## current Y > 0 and Robot facing SOUTH
(self.curr_y > 0 and self.curr_dir == 2)
):
can_move = True
else:
can_move = False
return can_move
def turn_left(self):
if(self.curr_dir > 0):
self.curr_dir = self.curr_dir - 1
else:
self.curr_dir = 3
def turn_right(self):
if(self.curr_dir < 3):
self.curr_dir = self.curr_dir + 1
else:
self.curr_dir = 0
def move(self):
if self.allow_move():
self.do_move()
else:
## Surpress error message when file processing mode.
if(not self.b_cmd_mode):
print ("Robot at edge! Ignore move.")
def left(self):
self.turn_left()
def right(self):
self.turn_right()
def process_command_file(self, cmd_filename):
"""Process content in a command file by given a filename."""
self.b_cmd_mode = True
beginning_flag = True
with open(cmd_filename, "r") as file_handler:
for cmd_line in file_handler:
cmd = cmd_line.strip()
cmd = cmd.lower()
# Ignore input line start with '#' as comment.
if(not cmd.startswith("#")):
if(beginning_flag and ("place" not in cmd)):
## Skip other commands until 1st place found.
continue
else:
beginning_flag = False
self.process_command(cmd)
def process_command(self, cmd_line):
"""Process command line obtain from file."""
## Process PLACE command
if ("place" in cmd_line):
e = cmd_line.split()
p = e[1].split(",")
self.place(int(p[0]), int(p[1]), p[2])
elif ("move" in cmd_line):
self.move()
elif ("left" in cmd_line):
self.left()
elif ("right" in cmd_line):
self.right()
elif ("report" in cmd_line):
self.report()
else:
print("Command : {} not recognize! Ignoring ...".format(cmd_line))
############################################################################################################
## Function Defination
############################################################################################################
def main(argv):
inputfile = ''
try:
opts, args = getopt.getopt(argv,"chi:",["ifile=","command"])
except getopt.GetoptError:
print ('rea_robot.py -i <command file> | -c : Command line interface | -h : Help')
sys.exit(2)
## Initiate ReaToyRobot.
rr = ReaRobot()
for opt, arg in opts:
if opt == '-h':
print ('Help - Rea Toy Robot ver 1.0.0')
print ('Usage: rea_robot.py -i <command file>')
print ('To enter command line mode: rea_robot.py -c')
sys.exit()
elif opt in ("-i", "--ifile"):
inputfile = arg
## Output information
print ('Input command file : {}\n\n'.format(inputfile))
## Get robot to process command file.
rr.process_command_file(inputfile)
## Get robot to report itself after processing command file.
rr.report_yourself()
sys.exit()
elif opt in ("-c", "--command"):
print ("Rea Toy Robot in Command Line Mode ...\n")
shell = rea_robot_terminal()
shell.register_rea_robot(rr)
shell.prompt = "Rea-Robot >> "
shell.cmdloop()
sys.exit()
############################################################################################################
## Main program started.
############################################################################################################
## Clear console screen for operations
os.system('cls')
if __name__ == "__main__":
main(sys.argv[1:])
| {"/test-rea-robot.py": ["/rea_robot.py"], "/rea_robot.py": ["/rea_robot_terminal.py"], "/rea_robot_terminal.py": ["/rea_robot.py"]} |
63,372 | ahyeek78/ReaToyRobot | refs/heads/master | /rea_robot_terminal.py | #!/usr/bin/python
# -*- coding: utf-8 -*-
#####################################################################################################################################################################
## Start Date: 22-Feb-2019
## Last Modified: 23-Feb-2019
## Version: 1.1
##
## REA Robot Terminal Class
## 22-Feb-2019 Completed terminal shell implementation.
## 23-Feb-2019 Add in command case invariant.
##
#####################################################################################################################################################################
import cmd
from rea_robot import *
class rea_robot_terminal(cmd.Cmd):
def register_rea_robot(self, robot):
self.rr = robot
def preloop(self):
self.rr.report_yourself()
def precmd(self, line):
line = line.lower()
return line
def do_report(self, e):
"""
Report Rea Robot position: (X,Y) and Facing (NORTH, EAST, SOUTH, WEST)
Form: X,Y,FACING
"""
self.rr.report()
def do_left(self, e):
"""
Turn Rea Robot Facing to 90 deg counter clock-wise without changing the position.
"""
self.rr.left()
def do_right(self, e):
"""
Turn Rea Robot Facing to 90 deg clock-wise wthout changing the position.
"""
self.rr.right()
def do_move(self, e):
"""
Move Rea Robot 1 unit forward from current position in the direction that it's facing.
"""
self.rr.move()
def do_place(self, e):
"""
Place Rea Robot in the specific position and facing direction.
In general form: place X,Y,F
For example: place 1,1,NORTH
Place without any parameter, reset the robot position to 0,0,NORTH.
"""
if (e==""):
self.rr.place()
else:
p = e.split(",")
self.rr.place(int(p[0]), int(p[1]), p[2])
def do_exit(self, e):
"""
Exit Rea Robot Terminal ...
"""
return True | {"/test-rea-robot.py": ["/rea_robot.py"], "/rea_robot.py": ["/rea_robot_terminal.py"], "/rea_robot_terminal.py": ["/rea_robot.py"]} |
63,373 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/tests/test_dbn.py | import os
import numpy as np
from copper.ml.dbn.dbn import DBN
from copper.tests.utils import eq_
def get_iris():
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
Y = iris.target
return X, Y
def test_sklearn_api():
''' sklearn API: not functionality
'''
dbn = DBN([5])
X, y = get_iris()
dbn.fit(X, y)
dbn.predict_proba(X)
dbn.predict(X)
def test_instance():
from sklearn.base import BaseEstimator
dbn = DBN([5])
assert isinstance(dbn, BaseEstimator)
def test_reproducible():
X, y = get_iris()
dbn1 = DBN([5], random_state=123)
dbn1.fit(X, y)
pred1 = dbn1.predict(X)
prob1 = dbn1.predict_proba(X)
dbn2 = DBN([5], random_state=123)
dbn2.fit(X, y)
pred2 = dbn2.predict(X)
prob2 = dbn2.predict_proba(X)
eq_(dbn1.coef_, dbn2.coef_)
eq_(pred1, pred2)
eq_(prob1, prob2)
def test_coef_eq_layers_0():
dbn = DBN([5], pretrain_epochs=0, finetune_epochs=0, random_state=1234)
X, y = get_iris()
dbn.fit(X, y)
eq_(dbn.coef_[:5], dbn.layers[0].b)
eq_(dbn.coef_[5:25], dbn.layers[0].W.reshape(-1))
eq_(dbn.coef_[25:28], dbn.layers[1].b)
eq_(dbn.coef_[28:], dbn.layers[1].W.reshape(-1))
def test_coef_eq_layers_1():
dbn = DBN([5], pretrain_epochs=0, finetune_epochs=1, random_state=1234)
X, y = get_iris()
dbn.fit(X, y)
eq_(dbn.coef_[:5], dbn.layers[0].b)
eq_(dbn.coef_[5:25], dbn.layers[0].W.reshape(-1))
eq_(dbn.coef_[25:28], dbn.layers[1].b)
eq_(dbn.coef_[28:], dbn.layers[1].W.reshape(-1))
def test_coef_eq_layers_change():
# Test that the coef_ and layers weights are connected in memory
dbn = DBN([5], pretrain_epochs=0, finetune_epochs=0, random_state=1234)
X, y = get_iris()
dbn.fit(X, y)
eq_(dbn.layers[0].b, np.zeros(5))
eq_(dbn.layers[1].b, np.zeros(3))
dbn.coef_[:] = np.ones(len(dbn.coef_))
eq_(dbn.layers[0].b, np.ones(5))
eq_(dbn.layers[0].W, np.ones((4, 5)))
eq_(dbn.layers[1].b, np.ones(3))
eq_(dbn.layers[1].W, np.ones((5, 3)))
eq_(dbn.layers[0].b[0], 1)
dbn.coef_[0] = 2
eq_(dbn.layers[0].b[0], 2)
eq_(dbn.coef_[1], 1)
dbn.layers[0].b[1] = 3
eq_(dbn.coef_[1], 3)
def test_iris_accuracy():
dbn = DBN([25], pretrain_epochs=0, finetune_epochs=10, finetune_batch_size=10, random_state=1)
X, y = get_iris()
dbn.fit(X, y)
acc = (dbn.predict(X) == y).mean()
eq_(acc, 0.95333, 5)
def test_save_load_weights():
import tempfile
tempdir = tempfile.gettempdir()
tempfile = os.path.join(tempdir, 'w.json')
# tempfile = os.path.join('', 'w.json')
dbn1 = DBN([5], random_state=1234)
X, y = get_iris()
dbn1.fit(X, y)
pred1 = dbn1.predict(X)
prob1 = dbn1.predict_proba(X)
dbn1.save(tempfile)
dbn2 = DBN([5])
dbn2.load(tempfile)
pred2 = dbn2.predict(X)
prob2 = dbn2.predict_proba(X)
eq_(dbn1.coef_, dbn2.coef_)
for i, layer in enumerate(dbn1.layers):
eq_(dbn1.layers[i].W, dbn2.layers[i].W)
eq_(pred1, pred2)
eq_(prob1, prob2)
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,374 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/ml/metrics.py | import numpy as np
def rmsle(y_test, y_pred):
ans = np.log1p(y_pred) - np.log1p(y_test)
ans = np.power(ans, 2)
return np.sqrt(ans.mean())
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,375 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/ml/wrappers.py | # encoding: utf-8
import numpy as np
from sklearn.base import BaseEstimator
from sklearn.preprocessing import OneHotEncoder
class FeatureMixer(BaseEstimator):
def __init__(self, clfs, ignorefit=False):
self.clfs = clfs
self.ignorefit = ignorefit
def fit_transform(self, X, y=None):
if not self.ignorefit:
self.fit(X, y)
return self.transform(X)
def fit(self, X, y=None):
if not self.ignorefit:
for clf in self.clfs:
new = clf.fit_transform(X, y)
def transform(self, X):
ans = None
for clf in self.clfs:
new = clf.transform(X)
if ans is None:
ans = new
else:
ans = np.hstack((ans, new))
return ans
class TransformWrapper(BaseEstimator):
def __init__(self, clf, transformation, fit_transform=True):
self.clf = clf
self.fit_transform = fit_transform
self.transformation = transformation
def fit(self, X, y=None):
if self.fit_transform:
self.transformation.fit(X)
_X = self._pretransform(X)
if y is None:
self.clf.fit(_X)
else:
self.clf.fit(_X, y)
def predict(self, X):
_X = self._pretransform(X)
return self.clf.predict(_X)
def predict_proba(self, X):
_X = self._pretransform(X)
return self.clf.predict_proba(_X)
def transform(self, X):
_X = self._pretransform(X)
return self.clf.transform(_X)
def _pretransform(self, X):
return self.transformation.transform(X)
class GMMWrapper(TransformWrapper):
def fit(self, X, y=None):
if self.fit_transform:
self.transformation.fit(X)
t = self.transformation.predict(X)[np.newaxis].T
self.enc = OneHotEncoder()
self.enc.fit(t)
_X = self._pretransform(X)
if y is None:
self.clf.fit(_X)
else:
self.clf.fit(_X, y)
def _pretransform(self, X):
t = self.transformation.predict(X)[np.newaxis].T
return self.enc.transform(t).toarray()
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,376 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/__init__.py | import copper.transform as t
from copper.dataset import Dataset
from copper.ml.compare import ModelComparison | {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,377 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/tests/test_transforms.py | from __future__ import division
import math
import random
import copper
import numpy as np
import pandas as pd
from nose.tools import raises
from copper.tests.utils import eq_
def test_transform_int_regex():
eq_(copper.t.to_int('0.2'), 0)
eq_(copper.t.to_int('.8753'), 8753)
eq_(copper.t.to_int('3.2'), 3)
eq_(copper.t.to_int('1.2'), 1)
eq_(copper.t.to_int('1.0'), 1)
eq_(copper.t.to_int('NN1.0'), 1)
eq_(copper.t.to_int('NN3.4DD'), 3)
eq_(copper.t.to_int('(35.2)'), 35)
eq_(copper.t.to_int('FAKE') is np.nan, True)
eq_(copper.t.to_int('FAKE.') is np.nan, True)
eq_(copper.t.to_int('FAKE.321'), 321)
eq_(copper.t.to_int('FAKE.321.111'), 321)
def test_transform_float_regex():
eq_(copper.t.to_float('0.2'), 0.2)
eq_(copper.t.to_float('.8753'), 0.8753)
eq_(copper.t.to_float('3.2'), 3.2)
eq_(copper.t.to_float('1.2'), 1.2)
eq_(copper.t.to_float('1.0'), 1.0)
eq_(copper.t.to_float('NN1.0'), 1.0)
eq_(copper.t.to_float('NN3.4DD'), 3.4)
eq_(copper.t.to_float('(35.2)'), 35.2)
eq_(copper.t.to_float('FAKE') is np.nan, True)
eq_(copper.t.to_float('FAKE.') is np.nan, True)
eq_(copper.t.to_float('FAKE.321'), 0.321)
eq_(copper.t.to_float('FAKE.321.111'), 0.321)
def test_transform_int():
array = np.arange(10)
strings = []
for i, item in enumerate(array):
strings.append("STRING(%i)" % item)
ser = pd.Series(strings)
sol = pd.Series(array)
eq_(ser.apply(copper.t.to_int), sol)
def test_transform_float():
array = np.arange(10) / 10
strings = []
for i, item in enumerate(array):
strings.append("STRING(%f)" % item)
ser = pd.Series(strings)
sol = pd.Series(array)
eq_(ser.apply(copper.t.to_float), sol)
def test_cat_encode_simple():
strings = np.array(['1', '2', '1', '3', '5', '2', '1', '5'])
sol = np.array([[1., 0, 0, 0], [0, 1, 0, 0], [1, 0, 0, 0],
[0, 0, 1, 0], [0, 0, 0, 1], [0, 1, 0, 0],
[1, 0, 0, 0], [0, 0, 0, 1]])
eq_(copper.t.cat_encode(strings), sol)
def test_cat_encode_simple_list():
strings = ['1', '2', '1', '3', '5', '2', '1', '5']
sol = np.array([[1., 0, 0, 0], [0, 1, 0, 0], [1, 0, 0, 0],
[0, 0, 1, 0], [0, 0, 0, 1], [0, 1, 0, 0],
[1, 0, 0, 0], [0, 0, 0, 1]])
eq_(copper.t.cat_encode(strings), sol)
def test_cat_encode_big():
abc = 'abcdefghijklmnopqrstuvwxyz'
array = np.floor(np.random.rand(100000) * 26)
strings = np.array([abc[int(i)] for i in array])
ans = copper.t.cat_encode(strings)
eq_(len(ans), 100000)
eq_(ans.sum(axis=1), np.ones(100000))
eq_(ans.sum(), 100000)
def test_ml_inputs_simple():
df = pd.DataFrame(np.random.rand(8, 6))
strings = ['1', '2', '1', '3', '5', '2', '1', '5']
df[1] = np.array(strings)
df[3] = np.array(strings)
ds = copper.Dataset(df)
ds.type[[1, 3]] = ds.CATEGORY
ans = copper.t.ml_inputs(ds)
eq_(ans.shape, (8, 6 - 2 + 4 * 2))
eq_(ans[:, 0], df[0].values)
eq_(ans[:, [1, 2, 3, 4]], copper.t.cat_encode(df[1].values))
eq_(ans[:, 5], df[2].values)
eq_(ans[:, [6, 7, 8, 9]], copper.t.cat_encode(df[3].values))
eq_(ans[:, 10], df[4].values)
eq_(ans[:, 11], df[5].values)
def test_ml_inputs_simple_with_target():
df = pd.DataFrame(np.random.rand(8, 6))
strings = ['1', '2', '1', '3', '5', '2', '1', '5']
df[1] = np.array(strings)
df[3] = np.array(strings)
ds = copper.Dataset(df)
ds.type[[1, 3]] = ds.CATEGORY
ds.role[[2]] = ds.TARGET
ans = copper.t.ml_inputs(ds)
eq_(ans.shape, (8, 5 - 2 + 4 * 2))
eq_(ans[:, 0], df[0].values)
eq_(ans[:, [1, 2, 3, 4]], copper.t.cat_encode(df[1].values))
eq_(ans[:, [5, 6, 7, 8]], copper.t.cat_encode(df[3].values))
eq_(ans[:, 9], df[4].values)
eq_(ans[:, 10], df[5].values)
def test_ml_inputs_simple_with_ignore():
df = pd.DataFrame(np.random.rand(8, 6))
strings = ['1', '2', '1', '3', '5', '2', '1', '5']
df[1] = np.array(strings)
df[3] = np.array(strings)
ds = copper.Dataset(df)
ds.type[[1, 3]] = ds.CATEGORY
ds.role[[2]] = ds.IGNORE
ans = copper.t.ml_inputs(ds)
eq_(ans.shape, (8, 5 - 2 + 4 * 2))
eq_(ans[:, 0], df[0].values)
eq_(ans[:, [1, 2, 3, 4]], copper.t.cat_encode(df[1].values))
eq_(ans[:, [5, 6, 7, 8]], copper.t.cat_encode(df[3].values))
eq_(ans[:, 9], df[4].values)
eq_(ans[:, 10], df[5].values)
def test_ml_inputs_big():
abc = 'abcdefghijklmnopqrstuvwxyz'
m, n = 1000, 10
array = np.floor(np.random.rand(m) * 26)
strings = np.array([abc[int(i)] for i in array])
df = pd.DataFrame(np.random.rand(m, 100))
abc_cols = np.arange(n) * 10
for col in abc_cols:
df[col] = strings
ds = copper.Dataset(df)
ds.type[abc_cols.tolist()] = ds.CATEGORY
ans = copper.t.ml_inputs(ds)
eq_(ans.shape, (m, 100 - n + 26 * n))
encoded = copper.t.cat_encode(strings)
for i, abc_col in enumerate(abc_cols):
s = abc_col + 25 * i
f = abc_col + 25 * i + 26
eq_(ans[:, s:f], encoded)
@raises(Exception)
def test_ml_target_error():
df = pd.DataFrame(np.random.rand(8, 6))
ds = copper.Dataset(df)
copper.t.ml_target(ds)
def test_ml_target_number():
df = pd.DataFrame(np.random.rand(8, 6))
ds = copper.Dataset(df)
target_col = math.floor(random.random() * 6)
ds.role[target_col] = ds.TARGET
le, target = copper.t.ml_target(ds)
eq_(target, ds[target_col].values)
eq_(le, None)
def test_ml_target_string():
df = pd.DataFrame(np.random.rand(6, 6))
strings = ['z', 'h', 'z', 'c', 'h', 'c']
sol = [2, 1, 2, 0, 1, 0]
df['T'] = strings
ds = copper.Dataset(df)
ds.role['T'] = ds.TARGET
le, target = copper.t.ml_target(ds)
eq_(target, np.array(sol))
eq_(le.classes_.tolist(), ['c', 'h', 'z'])
def test_ml_target_more_than_one():
df = pd.DataFrame(np.random.rand(8, 6))
ds = copper.Dataset(df)
ds.role[3] = ds.TARGET
ds.role[5] = ds.TARGET
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore")
le, target = copper.t.ml_target(ds)
eq_(le, None)
eq_(target, ds[3].values)
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,378 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/ml/dbn/layers.py | # -*- coding: utf-8 -*-
import numpy as np
from utils import softmax, sigmoid
class Layer(object):
def __init__(self, n_in=None, n_out=None, W=None, b=None, random_state=None, activation=None):
if random_state is None:
self.rnd = np.random.RandomState()
elif isinstance(random_state, int):
self.rnd = np.random.RandomState(random_state)
else:
self.rnd = random_state
if W is None and b is None:
if n_in is not None and n_out is not None:
gap = 4 * np.sqrt(6. / (n_in + n_out))
self.b = np.zeros(n_out)
self.W = self.rnd.uniform(low=-gap, high=gap, size=(n_in, n_out))
self.n_in = self.W.shape[0]
self.n_out = self.W.shape[1]
else:
self.W = W
self.b = b
self.n_in = self.W.shape[0]
self.n_out = self.W.shape[1]
self.activation = activation
def output(self, input):
linear_output = np.dot(input, self.W) + self.b
return self.activation(linear_output)
def sample_h_given_v(self, input):
v_mean = self.output(input)
h_sample = self.rnd.binomial(size=v_mean.shape, n=1, p=v_mean)
return h_sample
class LogisticLayer(Layer):
def __init__(self, *args, **kwargs):
Layer.__init__(self, *args, activation=softmax, **kwargs)
class SigmoidLayer(Layer):
def __init__(self, *args, **kwargs):
Layer.__init__(self, *args, activation=sigmoid, **kwargs)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,379 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/utils/progress.py | # -*- coding: utf-8 -*-
from __future__ import division, print_function
import sys
import uuid
from IPython.display import HTML, Javascript, display
class ProgressBar(object):
''' IPython Notebook ready text progressbar
'''
def __init__(self, max, index=0, desc='', border='|', fill_char='#', width=50):
self.max = max
self.index = index
self.desc = desc
self.border = border
self.fill_char = fill_char
self.width = width
self.prog_bar = ''
self.update()
def next(self):
if self.index <= self.max:
self.index += 1
self.update()
def set(self, index):
self.index = index
self.update()
def update(self):
percent_done = self.index / self.max
all_full = self.width - 2
num_hashes = int(round(percent_done * all_full))
self.prog_bar = self.desc + ' ' + self.border
self.prog_bar += self.fill_char * num_hashes
self.prog_bar += ' ' * (all_full - num_hashes)
self.prog_bar += self.border
self.prog_bar += ' %.2f%%' % (percent_done * 100)
print('\r', self, end='')
sys.stdout.flush()
def complete(self, finish=True):
self.index = self.max
self.update()
if finish:
self.finish()
def finish(self):
print('\r', self)
def __str__(self):
return str(self.prog_bar)
class JSProgressbar(object):
''' IPython notebook ready Javascript ProgressBar
Uses JQuery UI.
Note: Depending on the number of iterations and number of bars on the
same notebooks makes the notebook goes slow.
Need to work on cleaning the javascript.
'''
def __init__(self, max=100, index=0):
self.divid = str(uuid.uuid4())
self.max = max
self.index = index
pb = HTML( """
<script src="http://code.jquery.com/ui/1.10.3/jquery-ui.js"></script>
<div id="{0}" class="progressbar"><div class="progress-label">...</div></div>
<style>
.ui-progressbar {{
position: relative;
height: 20px;
width: 70%;
}}
.progress-label {{
position: absolute;
left: 49.5%;
top: 2px;
font-weight: bold;
}}
</style>
""".format(self.divid))
display(pb)
self.update()
def next(self):
if self.index < self.max:
self.index += 1
self.update()
def animate(self, index):
self.index = index
def update(self):
display(Javascript("""$(function() {{
var progressbar = $("#{0}.progressbar");
var progressLabel = $("#{0} .progress-label");
progressbar.progressbar({{
value: {1}
}});
progressLabel.text({1} + "%" );
}});""".format(self.divid, 100 * self.percent())))
def percent(self):
return self.index / self.max
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,380 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/ml/compare.py | import copper
import numpy as np
import pandas as pd
from sklearn import cross_validation
# Metrics
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.metrics import roc_auc_score
from sklearn.metrics import average_precision_score
from sklearn.metrics import f1_score
from sklearn.metrics import fbeta_score
from sklearn.metrics import hinge_loss
from sklearn.metrics import matthews_corrcoef
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import zero_one_loss
class ModelComparison(dict):
""" Utility for easy model(algorithm) comparison.
Can use only numpy arrays or copper.Dataset to generate the training and
testing datasets.
Note: Designed to work with sklearn algorithms (extending BaseEstimator)
but not necesary if the algorithm matches the basic sklearn API:
algo.fit, algo.predict, algo.predict_proba
Parameters
----------
Examples
--------
>>> train = copper.Dataset(...)
>>> test = copper.Dataset(...)
>>> mc = copper.ModelComparison(...)
>>> from sklearn.linear_model import LogisticRegression
>>> mc['LR'] = LogisticRegression()
>>> mc['LR with p=l1'] = LogisticRegression(penalty='l1')
>>> mc.fit()
>>> mc.predict()
np.array([[...]])
"""
def __init__(self):
self.algorithms = {}
self.X_train = None
self.y_train = None
self.X_test = None
self.y_test = None
self.le = None
# -----------------------------------------------------------------------------
# Properties
def get_train(self):
return self.X_train, self.y_train
def set_train(self, dataset):
assert type(dataset) is copper.Dataset, "Should be a copper.Dataset"
self.X_train = copper.t.ml_inputs(dataset)
self.le, self.y_train = copper.t.ml_target(dataset)
def get_test(self):
return self.X_test, self.y_test
def set_test(self, dataset):
assert type(dataset) is copper.Dataset, "Should be a copper.Dataset"
self.X_test = copper.t.ml_inputs(dataset)
_, self.y_test = copper.t.ml_target(dataset)
train = property(get_train, set_train, None)
test = property(get_test, set_test, None)
def train_test_split(self, dataset, **args):
""" Random split of a copper.Datasetinto a training and testing
datasets
Arguments are the same as: sklearn.cross_validation.train_test_split
only test_size is necessary.
Parameters
----------
test_size: float percentage of the dataset used for testing
between 0 and 1.
"""
assert type(dataset) is copper.Dataset, "Should be a copper.Dataset"
inputs = copper.t.ml_inputs(dataset)
self.le, target = copper.t.ml_target(dataset)
self.X_train, self.X_test, self.y_train, self.y_test = \
cross_validation.train_test_split(inputs, target, **args)
def __getitem__(self, name):
return self.algorithms[name]
def __setitem__(self, name, value):
self.algorithms[name] = value
def __delitem__(self, name):
del self.algorithms[name]
def __len__(self):
return len(self.algorithms)
# -----------------------------------------------------------------------------
def parse_entries(self, X_test=None, y_test=None):
""" DRY: Small utility used inside of the class.
"""
if X_test is None and y_test is None:
X_test = self.X_test
y_test = self.y_test
elif isinstance(X_test, copper.Dataset):
X_test = copper.transforms.ml_inputs(X_test)
_, y_test = copper.transforms.ml_target(X_test)
assert X_test is not None, 'Nothing to predict'
return X_test, y_test
# -----------------------------------------------------------------------------
# Sklearn API
def fit(self):
for algorithm in self.algorithms:
self.algorithms[algorithm].fit(self.X_train, self.y_train)
def predict(self, X_test=None):
X_test, _ = self.parse_entries(X_test, None)
ans = pd.DataFrame(index=range(len(X_test)))
for alg_name in self.algorithms:
algo = self.algorithms[alg_name]
scores = algo.predict(X_test)
new = pd.Series(scores, index=ans.index, name=alg_name, dtype=int)
ans = ans.join(new)
return ans
def predict_proba(self, X_test=None):
X_test, _ = self.parse_entries(X_test, None)
ans = pd.DataFrame(index=range(len(X_test)))
for alg_name in self.algorithms:
algo = self.algorithms[alg_name]
probas = algo.predict_proba(X_test)
for val in range(probas.shape[1]):
new = pd.Series(probas[:, val], index=ans.index)
new.name = '%s [%d]' % (alg_name, val)
ans = ans.join(new)
return ans
# -----------------------------------------------------------------------------
# Sklearn metrics
def metric(self, func, X_test=None, y_test=None, name='', ascending=False, **args):
X_test, y_test = self.parse_entries(X_test, y_test)
ans_index = []
ans_value = []
for alg_name in self.algorithms:
algo = self.algorithms[alg_name]
y_pred = algo.predict(X_test)
scores = func(y_test, y_pred, **args)
if isinstance(scores, np.ndarray):
for i, score in enumerate(scores):
lbl = str(i) if self.le is None else self.le.inverse_transform(i)
ans_index.append('%s (%s)' % (alg_name, lbl))
ans_value.append(score)
else:
ans_index.append(alg_name)
ans_value.append(scores)
return pd.Series(ans_value, index=ans_index).order(ascending=ascending)
def accuracy_score(self, **args):
return self.metric(accuracy_score, name='Accuracy', **args)
def auc_score(self, **args):
return self.metric(roc_auc_score, name='AUC', **args)
def average_precision_score(self, **args):
return self.metric(average_precision_score, name='Avg Precision', **args)
def f1_score(self, **args):
return self.metric(f1_score, name='F1', **args)
def fbeta_score(self, beta=1, **args):
return self.metric(fbeta_score, name='Fbeta', beta=beta, **args)
def hinge_loss(self, **args):
return self.metric(hinge_loss, name='Hinge loss', **args)
def matthews_corrcoef(self, **args):
return self.metric(matthews_corrcoef, name='Matthews Coef', **args)
def precision_score(self, **args):
return self.metric(precision_score, name='Precision', **args)
def recall_score(self, **args):
return self.metric(recall_score, name='Recall', **args)
def zero_one_loss(self, **args):
return self.metric(zero_one_loss, name='Zero one loss', ascending=True, **args)
# -----------------------------------------------------------------------------
# Confusion matrix
def _cm(self, X_test=None, y_test=None):
'''
Calculates the confusion matrixes of the classifiers
Parameters
----------
clfs: list or str, of the classifiers to calculate the cm
Returns
-------
python dictionary
'''
X_test, y_test = self.parse_entries(X_test, y_test)
ans = {}
for alg_name in self.algorithms:
algo = self.algorithms[alg_name]
y_pred = algo.predict(self.X_test)
ans[alg_name] = confusion_matrix(y_test, y_pred)
return ans
def cm(self, clf, X_test=None, y_test=None):
'''
Return a pandas.DataFrame version of a confusion matrix
Parameters
----------
clf: str, classifier identifier
'''
cm = self._cm(X_test, y_test)[clf]
values = self.le.inverse_transform(np.unique(self.y_test))
return pd.DataFrame(cm, index=values, columns=values)
'''
import math
import random
import copper
import numpy as np
import pandas as pd
from sklearn import cross_validation
from sklearn.linear_model import LogisticRegression
from nose.tools import raises, ok_
from copper.tests.utils import eq_
def get_iris():
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
Y = iris.target
return X, Y
def get_iris_ds():
X, Y = get_iris()
df = pd.DataFrame(X)
df['Target'] = pd.Series(Y, name='Target')
ds = copper.Dataset(df)
ds.role['Target'] = ds.TARGET
return ds
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
'''
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,381 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/ml/gdbn/__init__.py | from .gdbn import DBN as DBN | {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,382 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/ml/dbn/utils.py | # -*- coding: utf-8 -*-
from __future__ import division
import numpy as np
def softmax(x):
e = np.exp(x - np.max(x)) # prevent overflow
if e.ndim == 1:
return e / np.sum(e, axis=0)
else:
return e / np.array([np.sum(e, axis=1)]).T # ndim = 2
def sigmoid(x):
return 1. / (1 + np.exp(-x))
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,383 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/utils/opti.py | # -*- coding: utf-8 -*-
from __future__ import division, print_function
import math
import numpy as np
from scipy import optimize
def minibatches(X, y=None, batch_size=50, batches=-1, random_state=None):
if random_state is None:
rnd = np.random.RandomState()
elif isinstance(random_state, int):
rnd = np.random.RandomState(random_state)
else:
rnd = random_state
m = X.shape[0]
batch_size = batch_size if batch_size >= 1 else int(math.floor(m * batch_size))
if batches == -1:
batches = int(math.ceil(m / batch_size))
random_indices = rnd.choice(np.arange(m), m, replace=False)
for i in range(batches):
batch_indices = np.arange(i * batch_size, (i + 1) * batch_size)
indices = random_indices[batch_indices]
if y is None:
yield X[indices]
else:
yield X[indices], y[indices]
def GD(fun, weights, grad, X, y, options, args=()):
return weights - options['learning_rate'] * grad(weights, X, y, *args)
def GD_momentum(fun, weights, grad, X, y, options, args=()):
bigjump = options['momentum'] * options['step']
weights -= bigjump
correction = options['learning_rate'] * grad(weights, X, y, *args)
step = bigjump + correction
options['step'] = step
return weights - step
def RMSPROP(fun, weights, grad, X, y, options, args=()):
gradient = grad(weights, X, y, *args)
options['moving_mean_squared'] = options['decay'] * options['moving_mean_squared'] \
+ (1 - options['decay']) * gradient ** 2
return weights - gradient / np.sqrt(options['moving_mean_squared'] + 1e-8)
def CG(fun, weights, grad, X, y, options, args=()):
ans = optimize.minimize(fun, weights, jac=grad, method='CG', args=(X, y) + args, options={'maxiter': options['mb_maxiter']})
return ans.x
def LBFGSB(fun, weights, grad, X, y, options, args=()):
ans = optimize.minimize(fun, weights, jac=grad, method='L-BFGS-B', args=(X, y) + args, options={'maxiter': options['mb_maxiter']})
return ans.x
def minimize(weights0, X, y, fun, grad, weights, method,
epochs=10, batches_per_epoch=None, batch_size=50,
random_state=None,
options=None, args=None, callback=None):
update = None
update_params = None
if method == 'GD':
if 'learning_rate' not in options:
options['learning_rate'] = 0.3
if 'learning_rate_decay' not in options:
options['learning_rate_decay'] = 0.9
if 'momentum' in options:
if 'momentum_decay' not in options:
options['momentum_decay'] = 0.9
options['step'] = 0
update = GD_momentum
def update_params():
options['learning_rate'] = options['learning_rate'] * options['learning_rate_decay']
options['momentum'] = options['momentum'] * options['momentum_decay']
else:
def update_params():
options['learning_rate'] = options['learning_rate'] * options['learning_rate_decay']
update = GD
elif method == 'RMSPROP':
if 'decay' not in options:
options['decay'] = 0.9
options['moving_mean_squared'] = 1
update = RMSPROP
elif method == 'CG':
if 'mb_maxiter' not in options:
options['mb_maxiter'] = 10
update = CG
elif method == 'L-BFGS-B':
if 'mb_maxiter' not in options:
options['mb_maxiter'] = 10
update = LBFGSB
else:
raise Exception('Optimization method not found')
if random_state is None:
rnd = np.random.RandomState()
elif isinstance(random_state, int):
rnd = np.random.RandomState(random_state)
else:
rnd = random_state
for epoch in range(epochs):
batches = minibatches(X, y, batch_size=batch_size,
batches=batches_per_epoch,
random_state=rnd)
if update_params is not None:
update_params()
i = 0
for _X, _y in batches:
weights[:] = update(fun, weights, grad, _X, _y, options, args=args)
if callback is not None:
stop = callback(epoch + 1, i + 1)
if stop == True:
break
i += 1
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,384 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/transform.py | import re
import numpy as np
from sklearn.preprocessing import LabelEncoder
intRE = re.compile('[-+]?[0-9]+')
floatRE = re.compile('[-+]?[0-9]*\.?[0-9]+')
def to_int(x):
""" Convert from string to int. Usefull when used inside pandas.apply
Regular expression: ``[-+]?[0-9]+``
Examples
--------
>>> data = pd.Series(['1', 'a2', '(-3)', '___4___', '$31', '15%'])
>>> data
0 1
1 a2
2 (-3)
3 ___4___
4 $31
5 15%
dtype: object
>>> data.apply(copper.t.to_int)
0 1
1 2
2 -3
3 4
4 31
5 15
dtype: int64
"""
match = intRE.search(x)
return np.nan if match is None else int(match.group())
def to_float(x):
""" Convert from string to floats. Usefull when used inside pandas.apply
Regular expression: ``[-+]?[0-9]*\.?[0-9]+``
Examples
--------
>>> df = pd.Series(['1', 'a2', '(-3.5)', '___4.00001______', '$31.312', '15%'])
>>> df
0 1
1 a2
2 (-3.5)
3 ___4.00001___
4 $31.312
5 15%
>>> df.apply(copper.t.to_int)
0 1.00000
1 2.00000
2 -3.50000
3 4.00001
4 31.31200
5 15.00000
dtype: float64
"""
match = floatRE.search(x)
return np.nan if match is None else float(match.group())
def cat_encode(values):
""" Encodes a category into multiple columns ready for machine learning
Parameters
----------
values: np.array or list
Returns
-------
np.array
Examples
--------
>>> cat_encode(np.array(['z', 'a', 'h', 'z', 'h']))
[[ 0. 0. 1.]
[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]
[ 0. 1. 0.]]
"""
if type(values) is list:
values = np.array(values)
labels = np.unique(values)
ans = np.zeros((len(values), len(labels)))
for i, label in enumerate(labels):
ans[:, i][values == label] = 1
return ans
def ml_inputs(dataset):
""" Takes a dataset and retuns the inputs in a numpy.array ready for
machine learning.
Mainly transforms non-numerical variables(columns) to numbers.
Parameters
----------
copper.Dataset
Returns
-------
np.array
"""
columns = dataset.filter_cols(role=dataset.INPUT)
assert len(columns) > 0, 'No input variables on Dataset'
ans = np.zeros((len(dataset), 1))
for column in columns:
if dataset.type[column] == dataset.NUMBER:
ans = np.hstack((ans, dataset[[column]].values))
elif dataset.type[column] == dataset.CATEGORY:
ans = np.hstack((ans, cat_encode(dataset[column])))
ans = np.delete(ans, 0, axis=1)
return ans
def ml_target(dataset):
""" Takes a dataset and retuns the target in a numpy.array ready for
machine learning.
Mainly transforms non-numerical variables(columns) to numbers.
Parameters
----------
copper.Dataset
Returns
-------
(label_encoder, np.array)
Notes
-----
If dataset has more than one variable with role=TARGET then the first one
is selected.
"""
cols = dataset.filter_cols(role=dataset.TARGET)
assert len(cols) > 0, 'No target variables on Dataset'
if len(cols) > 1:
import warnings
warnings.warn("Dataset contains more than one target, %s was choosed" % cols[0])
if dataset[cols[0]].dtype in (np.int, np.float):
return None, dataset[cols[0]].values
else:
le = LabelEncoder()
encoded = le.fit_transform(dataset[cols[0]].values)
return le, encoded
'''
import copper
import pandas as pd
from copper.tests.utils import eq_
# from copper.utils import transforms
from nose.tools import raises
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
'''
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,385 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/tests/test_compare_metrics_manual.py | from __future__ import division
import copper
import numpy as np
import pandas as pd
from copper.tests.utils import eq_
def get_train():
X = np.ones((12, 3))
y = ['b', 'z', 'b', 'g', 'g', 'z', 'b', 'z', 'g', 'b', 'g', 'z']
# [ 0, 2, 0, 1, 1, 2, 0, 2, 1, 0, 1, 0]
df = pd.DataFrame(X)
df['target'] = y
ds = copper.Dataset(df)
ds.role['target'] = ds.TARGET
return ds
class BaseFake():
def fit(self, X, t):
pass
def predict(self, X):
return np.array(self.encode)
class FakePerfect(BaseFake):
labels = ['b', 'z', 'b', 'g', 'g', 'z', 'b', 'z', 'g', 'b', 'g', 'z']
encode = [0, 2, 0, 1, 1, 2, 0, 2, 1, 0, 1, 2]
class Fake1(BaseFake):
labels = ['g', 'z', 'b', 'z', 'g', 'z', 'b', 'b', 'g', 'b', 'g', 'z']
encode = [1, 2, 0, 2, 1, 2, 0, 0, 1, 0, 1, 2]
class Fake2(BaseFake):
labels = ['g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g', 'g']
encode = [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1]
def get_mc():
mc = copper.ModelComparison()
mc.train = get_train()
mc.test = get_train()
mc['perf'] = FakePerfect()
mc['f1'] = Fake1()
mc['f2'] = Fake2()
mc.fit()
return mc
# -----------------------------------------------------------------------------
def test_classes():
mc = get_mc()
eq_(mc.le.classes_, np.array(['b', 'g', 'z']))
def test_target_values():
mc = get_mc()
eq_(mc.y_train, np.array([0, 2, 0, 1, 1, 2, 0, 2, 1, 0, 1, 2]))
def test_accuracy():
mc = get_mc()
scores = mc.accuracy_score()
eq_(scores['perf'], 1.0)
eq_(scores['f1'], 0.75)
eq_(scores['f2'], 0.25)
def test_f1_score_avg_none():
mc = get_mc()
scores = mc.f1_score(average=None)
eq_(scores['perf (b)'], 1.0)
eq_(scores['perf (g)'], 1.0)
eq_(scores['perf (z)'], 1.0)
eq_(scores['f1 (b)'], 0.75)
eq_(scores['f1 (g)'], 0.75)
eq_(scores['f1 (z)'], 0.75)
eq_(scores['f2 (b)'], 0)
eq_(scores['f2 (g)'], 0.4, 1)
eq_(scores['f2 (z)'], 0)
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,386 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/data1.py | from bs4 import BeautifulSoup
from urllib2 import urlopen
BASE_URL = "http://espn.go.com/college-football/rankings"
def get_team_links(section_url):
html = urlopen(section_url).read()
soup = make_soup(url)
align_left_team = soup.find("tr", "")
team_links = [BASE_URL + td.a["href"] for td in align_left_team.findAll("td")]
return category_links
def get_regular_season(category_url):
html = urlopen(category_url).read()
soup = make_soup(url)
category = soup.find("a", "&lpos=college-football:schedule:full").string
first_match = [h2.string for h2 in soup.findAll("a", "&lpos=college-football:schedule:regular")]
return {"category": category,
"category_url": category_url,
"first_match": first_match}
def make_soup(url):
html = urlopen(url).read()
return BeautifulSoup(html, "lxml") | {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,387 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/tests/test_compare.py | from __future__ import division
import math
import random
import copper
import numpy as np
import pandas as pd
from sklearn import cross_validation
from sklearn.linear_model import LogisticRegression
from nose.tools import raises, ok_
from copper.tests.utils import eq_
def get_iris():
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
Y = iris.target
return X, Y
def get_iris_ds():
X, Y = get_iris()
df = pd.DataFrame(X)
df['Target'] = pd.Series(Y, name='Target')
ds = copper.Dataset(df)
ds.role['Target'] = ds.TARGET
return ds
# -----------------------------------------------------------------------------
# Train and test values
def test_get_set_train_test_directly():
X, Y = get_iris()
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, Y, test_size=0.2)
mc = copper.ModelComparison()
mc.X_train = X_train
mc.y_train = y_train
mc.X_test = X_test
mc.y_test = y_test
eq_(mc.X_train.shape, (150 * 0.8, 4))
eq_(mc.y_train.shape, (150 * 0.8, ))
eq_(mc.X_test.shape, (150 * 0.2, 4))
eq_(mc.y_test.shape, (150 * 0.2, ))
eq_(mc.X_train, X_train)
eq_(mc.y_train, y_train)
eq_(mc.X_test, X_test)
eq_(mc.y_test, y_test)
def test_get_set_train_test_dataset_property():
X, Y = get_iris()
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, Y, test_size=0.6)
train = np.hstack((X_train, y_train[np.newaxis].T))
train = pd.DataFrame(train)
train = copper.Dataset(train)
train.role[4] = train.TARGET
test = np.hstack((X_test, y_test[np.newaxis].T))
test = pd.DataFrame(test)
test = copper.Dataset(test)
test.role[4] = test.TARGET
# --
mc = copper.ModelComparison()
mc.train = train
mc.test = test
eq_(mc.X_train.shape, (150 * 0.4, 4))
eq_(mc.y_train.shape, (150 * 0.4, ))
eq_(mc.X_test.shape, (150 * 0.6, 4))
eq_(mc.y_test.shape, (150 * 0.6, ))
eq_(mc.X_train, X_train)
eq_(mc.y_train, y_train)
eq_(mc.X_test, X_test)
eq_(mc.y_test, y_test)
def test_train_test_split():
ds = get_iris_ds()
mc = copper.ModelComparison()
state = int(math.floor(random.random() * 1000))
mc.train_test_split(ds, test_size=0.4, random_state=state)
eq_(mc.X_train.shape, (150 * 0.6, 4))
eq_(mc.y_train.shape, (150 * 0.6, ))
eq_(mc.X_test.shape, (150 * 0.4, 4))
eq_(mc.y_test.shape, (150 * 0.4, ))
eq_((mc.X_train, mc.y_train), mc.train)
eq_((mc.X_test, mc.y_test), mc.test)
eq_(mc.le, None)
# --
X, Y = get_iris()
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, Y, test_size=0.4, random_state=state)
eq_(mc.X_train, X_train)
eq_(mc.y_train, y_train)
eq_(mc.X_test, X_test)
eq_(mc.y_test, y_test)
# -----------------------------------------------------------------------------
# Algorithms list/dictionary
def test_get_set_algorithms():
mc = copper.ModelComparison()
lr = LogisticRegression()
mc['LR'] = lr
eq_(mc['LR'], lr)
lr2 = LogisticRegression(penalty='l1')
mc['LR l1'] = lr2
eq_(mc['LR l1'], lr2)
eq_(len(mc), 2)
def test_del_algorithm_len():
mc = copper.ModelComparison()
lr = LogisticRegression()
mc['LR'] = lr
eq_(mc['LR'], lr)
lr2 = LogisticRegression(penalty='l1')
mc['LR l1'] = lr2
eq_(mc['LR l1'], lr2)
eq_(len(mc), 2)
del mc['LR']
eq_(mc['LR l1'], lr2)
eq_(len(mc), 1)
del mc['LR l1']
eq_(len(mc), 0)
@raises(KeyError)
def test_deleted_algorithm():
mc = copper.ModelComparison()
lr = LogisticRegression()
mc['LR'] = lr
eq_(mc['LR'], lr)
lr2 = LogisticRegression(penalty='l1')
mc['LR l1'] = lr2
eq_(mc['LR l1'], lr2)
del mc['LR']
eq_(mc['LR l1'], lr2) # Not deleted
mc['LR'] # deleted
# -----------------------------------------------------------------------------
@raises(AttributeError)
def test_no_auto_fit():
mc = copper.ModelComparison()
lr = LogisticRegression()
mc['LR'] = lr
mc['LR'].coef_ # Doesn't exist yet
def test_fit():
ds = get_iris_ds()
mc = copper.ModelComparison()
mc.train_test_split(ds, test_size=0.4)
lr = LogisticRegression()
lr2 = LogisticRegression(penalty='l1')
mc['LR'] = lr
mc['LR l1'] = lr2
mc.fit()
ok_(mc['LR'].coef_ is not None)
ok_(mc['LR l1'].coef_ is not None)
ok_(mc['LR'] != mc['LR l1'])
# -----------------------------------------------------------------------------
# With target as string
def get_iris_ds_string():
ds = get_iris_ds()
ds.type['Target'] = ds.CATEGORY
ds['Target'] = ds['Target'].apply(lambda x: str(x))
ds['Target'][ds['Target'] == '0'] = 'Iris-A'
ds['Target'][ds['Target'] == '1'] = 'Iris-B'
ds['Target'][ds['Target'] == '2'] = 'Iris-C'
eq_(ds.metadata['dtype']['Target'], object)
return ds
def test_train_test_split_string():
ds = get_iris_ds_string()
mc = copper.ModelComparison()
state = int(math.floor(random.random() * 1000))
mc.train_test_split(ds, test_size=0.4, random_state=state)
eq_(mc.X_train.shape, (150 * 0.6, 4))
eq_(mc.y_train.shape, (150 * 0.6, ))
eq_(mc.X_test.shape, (150 * 0.4, 4))
eq_(mc.y_test.shape, (150 * 0.4, ))
eq_((mc.X_train, mc.y_train), mc.train)
eq_((mc.X_test, mc.y_test), mc.test)
eq_(mc.le.classes_.tolist(), ['Iris-A', 'Iris-B', 'Iris-C'])
# --
X, Y = get_iris()
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, Y, test_size=0.4, random_state=state)
eq_(mc.X_train, X_train)
eq_(mc.y_train, y_train)
eq_(mc.X_test, X_test)
eq_(mc.y_test, y_test)
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,388 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/tests/test_dataset.py | from __future__ import division
import os
import math
import random
import tempfile
import copper
import numpy as np
import pandas as pd
from nose.tools import raises
from copper.tests.utils import eq_
# -----------------------------------------------------------------------------
# Properties
def test_create_empty():
# Checks empty Dataframes
ds = copper.Dataset()
eq_(ds.role, pd.Series())
eq_(ds.type, pd.Series())
eq_(ds.frame.empty, True)
eq_(ds.metadata.empty, True)
def test_create_noempty():
df = pd.DataFrame(np.random.rand(10, 5))
ds = copper.Dataset(df)
eq_(ds.frame, df)
eq_(len(ds), 10)
eq_(len(ds), len(df))
eq_(len(ds.role), 5)
eq_(len(ds.type), 5)
eq_(len(ds.metadata), 5)
eq_(ds.metadata['Role'], ds.role)
eq_(ds.metadata['Type'], ds.type)
eq_(ds.index, df.index)
eq_(ds.columns, df.columns)
eq_(str(ds), str(ds.metadata))
def test_create_empty_and_set():
df = pd.DataFrame(np.random.rand(10, 5))
ds = copper.Dataset()
eq_(ds.role, pd.Series())
eq_(ds.type, pd.Series())
eq_(ds.metadata.empty, True)
eq_(ds.frame.empty, True)
ds.frame = df.copy()
eq_(ds.frame, df)
eq_(len(ds), 10)
eq_(len(ds), len(df))
eq_(len(ds.role), 5)
eq_(len(ds.type), 5)
eq_(len(ds.metadata), 5)
eq_(ds.metadata['Role'], ds.role)
eq_(ds.metadata['Type'], ds.type)
eq_(ds.index, df.index)
eq_(ds.columns, df.columns)
eq_(str(ds), str(ds.metadata))
eq_(unicode(ds), unicode(ds.metadata))
def test_set_frame_different_length_same_cols():
# Tests that the metadata is mantained if columns are the same
df1 = pd.DataFrame(np.random.rand(5, 5))
ds = copper.Dataset(df1.copy())
ds.role[[2, 4]] = ds.TARGET
ds.type[[1, 2]] = ds.CATEGORY
meta_old = ds.metadata.copy()
df2 = pd.DataFrame(np.random.rand(10, 5))
ds.frame = df2
eq_(ds.metadata, meta_old)
@raises(AssertionError)
def test_set_frame_different_length_same_cols_fail():
# By failing is testing that the default metadata is not in place
df1 = pd.DataFrame(np.random.rand(5, 5))
ds = copper.Dataset(df1.copy())
default_meta = ds.metadata.copy()
ds.role[[2, 4]] = ds.TARGET
ds.type[[1, 2]] = ds.CATEGORY
df2 = pd.DataFrame(np.random.rand(10, 5))
ds.frame = df2
eq_(ds.metadata, default_meta)
def test_set_frame_different_cols():
# Checks default metadata is placed
df1 = pd.DataFrame(np.random.rand(5, 5))
ds = copper.Dataset(df1)
ds.role[[2, 4]] = ds.TARGET
ds.type[[1, 2]] = ds.CATEGORY
df2 = pd.DataFrame(np.random.rand(10, 10))
ds.frame = df2
eq_(ds.role[2], ds.INPUT)
eq_(ds.role[4], ds.INPUT)
eq_(ds.type[1], ds.NUMBER)
eq_(ds.type[2], ds.NUMBER)
@raises(AssertionError)
def test_set_frame_different_cols_fail():
# By failing it checks that the metadata is different == was recreated
df1 = pd.DataFrame(np.random.rand(5, 5))
ds = copper.Dataset(df1)
meta_old = ds.metadata.copy()
df2 = pd.DataFrame(np.random.rand(10, 10))
ds.frame = df2
eq_(ds.metadata, meta_old)
def test_default_type():
df = pd.DataFrame(np.random.rand(5, 20))
rand_col = math.floor(random.random() * 20)
rand_col2 = math.floor(random.random() * 20)
df[rand_col] = df[rand_col].apply(lambda x: str(x))
df[rand_col2] = df[rand_col].apply(lambda x: str(x))
ds = copper.Dataset(df)
eq_(ds.type[rand_col], ds.CATEGORY)
for col in ds.columns:
if col not in (rand_col, rand_col2):
eq_(ds.type[col], ds.NUMBER)
def test_set_metadata():
df = pd.DataFrame(np.random.rand(5, 5))
ds = copper.Dataset(df)
rand_col = math.floor(random.random() * 5)
meta = ds.metadata.copy()
meta['Role'][rand_col] = ds.TARGET
eq_(ds.role[rand_col], ds.INPUT) # Not changes until reasigment
ds.metadata = meta
eq_(ds.role[rand_col], ds.TARGET) # Change
for i in range(5):
rand_col = math.floor(random.random() * 5)
meta = ds.metadata.copy()
meta['Role'][rand_col] = ds.TARGET
ds.metadata = meta
eq_(ds.role[rand_col], ds.TARGET)
rand_col = math.floor(random.random() * 5)
meta = ds.metadata.copy()
meta['Type'][rand_col] = ds.CATEGORY
eq_(ds.type[rand_col], ds.NUMBER) # Not changes until reasigment
ds.metadata = meta
eq_(ds.type[rand_col], ds.CATEGORY) # Change
for i in range(5):
rand_col = math.floor(random.random() * 5)
meta = ds.metadata.copy()
meta['Type'][rand_col] = ds.CATEGORY
ds.metadata = meta
eq_(ds.type[rand_col], ds.CATEGORY)
@raises(AssertionError)
def test_set_metadata_fail_length():
df = pd.DataFrame(np.random.rand(5, 5))
ds = copper.Dataset(df)
meta = ds.metadata.copy()
meta = meta.drop(0)
ds.metadata = meta
@raises(AssertionError)
def test_set_metadata_fail_index():
df = pd.DataFrame(np.random.rand(5, 5))
ds = copper.Dataset(df)
meta = ds.metadata.copy()
meta = meta.reindex([11, 1, 2, 3, 4])
ds.metadata = meta
def test_save_load_metadata():
tempdir = tempfile.gettempdir()
# Save
df = pd.DataFrame(np.random.rand(5, 10))
ds = copper.Dataset(df)
ds.role[2] = ds.TARGET
ds.role[7] = ds.IGNORE
ds.type[1] = ds.CATEGORY
ds.type[5] = ds.CATEGORY
ds.metadata.to_csv(os.path.join(tempdir, 'metadata.csv'))
# Load
ds2 = copper.Dataset(df)
loaded_meta = pd.read_csv(os.path.join(tempdir, 'metadata.csv'))
loaded_meta = loaded_meta.set_index('Columns')
ds2.metadata = loaded_meta
eq_(ds2.role[2], ds.TARGET)
eq_(ds2.role[7], ds.IGNORE)
eq_(ds2.type[1], ds.CATEGORY)
eq_(ds2.type[5], ds.CATEGORY)
def test_copy_metadata():
cols = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
df1 = pd.DataFrame(np.random.rand(5, 10), columns=cols)
ds1 = copper.Dataset(df1)
ds1.role[['c', 'd', 'h', 'i']] = ds1.TARGET
ds1.type[['b', 'c', 'g', 'i']] = ds1.CATEGORY
# meta_old = ds1.metadata.copy()
df2 = pd.DataFrame(np.random.rand(5, 10), columns=cols)
ds2 = copper.Dataset(df2)
ds2.copy_metadata(ds1.metadata)
eq_(ds2.metadata, ds1.metadata)
def test_copy_metadata_ignore_true():
cols = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
df1 = pd.DataFrame(np.random.rand(5, 10), columns=cols)
ds1 = copper.Dataset(df1)
ds1.role[['a', 'd', 'h', 'i']] = ds1.TARGET
ds1.type[['b', 'd', 'g', 'i']] = ds1.CATEGORY
cols = ['z', 'y', 'f', 'a', 'b', 'd', 'e']
df2 = pd.DataFrame(np.random.rand(5, 7), columns=cols)
ds2 = copper.Dataset(df2)
ds2.copy_metadata(ds1.metadata)
eq_(ds2.role['z'], ds1.INPUT)
eq_(ds2.role['y'], ds1.INPUT)
eq_(ds2.role['a'], ds1.TARGET)
eq_(ds2.role['b'], ds1.INPUT)
eq_(ds2.role['d'], ds1.TARGET)
eq_(ds2.role['e'], ds1.INPUT)
eq_(ds2.type['z'], ds1.NUMBER)
eq_(ds2.type['y'], ds1.NUMBER)
eq_(ds2.type['a'], ds1.NUMBER)
eq_(ds2.type['b'], ds1.CATEGORY)
eq_(ds2.type['d'], ds1.CATEGORY)
eq_(ds2.type['e'], ds1.NUMBER)
def test_copy_metadata_ignore_false():
cols = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
df1 = pd.DataFrame(np.random.rand(5, 10), columns=cols)
ds1 = copper.Dataset(df1)
ds1.role[['a', 'd', 'h', 'i']] = ds1.TARGET
ds1.type[['b', 'd', 'g', 'i']] = ds1.CATEGORY
cols = ['z', 'y', 'f', 'a', 'b', 'd', 'e']
df2 = pd.DataFrame(np.random.rand(5, 7), columns=cols)
ds2 = copper.Dataset(df2)
ds2.copy_metadata(ds1.metadata, ignoreMissing=False)
eq_(ds2.role['z'], ds1.IGNORE)
eq_(ds2.role['y'], ds1.IGNORE)
eq_(ds2.role['a'], ds1.TARGET)
eq_(ds2.role['b'], ds1.INPUT)
eq_(ds2.role['d'], ds1.TARGET)
eq_(ds2.role['e'], ds1.INPUT)
eq_(ds2.type['z'], ds1.NUMBER)
eq_(ds2.type['y'], ds1.NUMBER)
eq_(ds2.type['a'], ds1.NUMBER)
eq_(ds2.type['b'], ds1.CATEGORY)
eq_(ds2.type['d'], ds1.CATEGORY)
eq_(ds2.type['e'], ds1.NUMBER)
# -----------------------------------------------------------------------------
# Functions
def test_update_cat_to_num_int():
sol = np.arange(100)
strings = np.array(['a(%f)' % d for d in sol])
df = pd.DataFrame(strings)
ds = copper.Dataset(df)
ds.type[0] = ds.NUMBER
ds.update()
eq_(sol, ds[0].values)
def test_update_cat_to_num_float():
sol = np.arange(100) / 100
strings = np.array(['a(%f)' % d for d in sol])
df = pd.DataFrame(strings)
ds = copper.Dataset(df)
ds.type[0] = ds.NUMBER
ds.update()
eq_(sol, ds[0].values)
def test_filter_role():
df = pd.DataFrame(np.random.rand(5, 10))
ds = copper.Dataset(df)
ds.role[[0, 2, 4, 5, 9]] = ds.IGNORE
eq_(ds.filter(role=ds.INPUT), ds[[1, 3, 6, 7, 8]])
ds.role[:] = ds.IGNORE
ds.role[[1, 3, 4, 6, 8]] = ds.INPUT
eq_(ds.filter(role=ds.INPUT), ds[[1, 3, 4, 6, 8]])
ds.role[[2, 9]] = ds.TARGET
eq_(ds.filter(role=ds.TARGET), ds[[2, 9]])
eq_(ds.filter(role=[ds.INPUT, ds.TARGET]), ds[[1, 2, 3, 4, 6, 8, 9]])
eq_(ds.filter(), df)
def test_filter_type():
df = pd.DataFrame(np.random.rand(5, 10))
ds = copper.Dataset(df)
ds.type[[0, 2, 4, 5, 9]] = ds.CATEGORY
eq_(ds.filter(type=ds.CATEGORY), ds[[0, 2, 4, 5, 9]])
ds.type[:] = ds.CATEGORY
ds.type[[1, 3, 6, 7, 9]] = ds.NUMBER
eq_(ds.filter(type=ds.NUMBER), ds[[1, 3, 6, 7, 9]])
eq_(ds.filter(type=[ds.NUMBER, ds.CATEGORY]), df)
eq_(ds.filter(), df)
def test_filter_role_and_type():
df = pd.DataFrame(np.random.rand(5, 5))
ds = copper.Dataset(df)
ds.role[:] = ds.IGNORE
ds.role[2] = ds.INPUT
ds.type[2] = ds.CATEGORY
eq_(ds.filter(role=ds.INPUT, type=ds.CATEGORY), df[[2]])
ds.role[4] = ds.INPUT
ds.type[4] = ds.CATEGORY
eq_(ds.filter(role=ds.INPUT, type=ds.CATEGORY), df[[2, 4]])
eq_(ds.filter(role=ds.IGNORE, type=ds.NUMBER), df[[0, 1, 3]])
ds.role[4] = ds.IGNORE
eq_(ds.filter(role=ds.INPUT, type=ds.CATEGORY), df[[2]])
eq_(ds.filter(), df)
# -----------------------------------------------------------------------------
# Pandas API
def test_get_column():
df = pd.DataFrame(np.random.rand(5, 10))
ds = copper.Dataset(df)
eq_(ds[0], df[0])
eq_(ds[5], df[5])
eq_(ds[9], df[9])
def test_set_column():
df = pd.DataFrame(np.random.rand(5, 10))
ds = copper.Dataset(df)
new_col = np.random.rand(5, 1)
eq_(ds[3].values, df[3].values)
ds[3] = new_col
eq_(ds[[3]].values, new_col)
def test_head():
df = pd.DataFrame(np.random.rand(5, 10))
ds = copper.Dataset(df.copy())
l = math.floor(random.random() * 10)
eq_(ds.head(l), df.head(l))
def test_tail():
df = pd.DataFrame(np.random.rand(5, 10))
ds = copper.Dataset(df.copy())
l = math.floor(random.random() * 10)
eq_(ds.head(l), df.head(l))
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,389 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/ml/dbn/rbm.py | # -*- coding: utf-8 -*-
from __future__ import division
import numpy as np
class RBM(object):
'''
Note: this class was taken from yusugomori RBM
https://github.com/yusugomori/DeepLearning/blob/master/python/RBM.py
I modified the class to match my requirements but basicly is the same thing.
'''
def __init__(self, input_layer, learning_rate=0.1, random_state=None):
self.input_layer = input_layer
self.learning_rate = learning_rate
self.activation = input_layer.activation
if random_state is None:
self.np_rng = np.random.RandomState()
else:
self.np_rng = random_state
self.n_visible = input_layer.W.shape[0]
self.n_hidden = input_layer.W.shape[1]
self.W = input_layer.W
self.hbias = input_layer.b
self.vbias = np.zeros(self.n_visible)
def contrastive_divergence(self, input, lr=0.3, k=1):
ph_mean, ph_sample = self.sample_h_given_v(input)
for step in xrange(k):
if step == 0:
nv_means, nv_samples, nh_means, nh_samples = self.gibbs_hvh(ph_sample)
else:
nv_means, nv_samples, nh_means, nh_samples = self.gibbs_hvh(nh_samples)
self.W += lr * (np.dot(input.T, ph_sample) -
np.dot(nv_samples.T, nh_means)) / input.shape[0]
self.vbias += lr * np.mean(input - nv_samples, axis=0)
self.hbias += lr * np.mean(ph_sample - nh_means, axis=0)
def sample_h_given_v(self, v0_sample):
h1_mean = self.propup(v0_sample)
h1_sample = self.np_rng.binomial(size=h1_mean.shape, n=1, p=h1_mean)
return [h1_mean, h1_sample]
def sample_v_given_h(self, h0_sample):
v1_mean = self.propdown(h0_sample)
v1_sample = self.np_rng.binomial(size=v1_mean.shape, n=1, p=v1_mean)
return [v1_mean, v1_sample]
def propup(self, v):
pre_activation = np.dot(v, self.W) + self.hbias
return self.activation(pre_activation)
def propdown(self, h):
pre_sigmoid_activation = np.dot(h, self.W.T) + self.vbias
return self.activation(pre_sigmoid_activation)
def gibbs_hvh(self, h0_sample):
v1_mean, v1_sample = self.sample_v_given_h(h0_sample)
h1_mean, h1_sample = self.sample_h_given_v(v1_sample)
return v1_mean, v1_sample, h1_mean, h1_sample
def get_reconstruction_cross_entropy(self, input):
pre_activation_h = np.dot(input, self.W) + self.hbias
sigmoid_activation_h = self.activation(pre_activation_h)
pre_sigmoid_activation_v = np.dot(sigmoid_activation_h, self.W.T) + self.vbias
sigmoid_activation_v = self.activation(pre_sigmoid_activation_v)
return - np.mean(np.sum(input * np.log(sigmoid_activation_v) +
(1 - input) * np.log(1 - sigmoid_activation_v),
axis=1))
def reconstruct(self, v):
h = sigmoid(np.dot(v, self.W) + self.hbias)
reconstructed_v = sigmoid(np.dot(h, self.W.T) + self.vbias)
return reconstructed_v
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,390 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/tests/utils.py | import numpy as np
import pandas as pd
import numpy.testing as np_test
import pandas.util.testing as pd_test
from nose.tools import eq_ as nose_eq
def eq_(ans, sol, digits=0):
if type(ans) == np.ndarray and type(sol) == np.ndarray:
array_eq(ans, sol, digits)
elif type(ans) == pd.Series and type(sol) == pd.Series:
series_eq(ans, sol)
elif type(ans) == pd.TimeSeries and type(sol) == pd.TimeSeries:
series_eq(ans, sol, digits)
elif type(ans) == pd.DataFrame and type(sol) == pd.DataFrame:
frame_eq(ans, sol, digits)
elif isinstance(ans, pd.Index) and isinstance(sol, pd.Index):
array_eq(ans.values, sol.values, digits)
elif digits != 0:
nose_eq(round(ans-sol, digits), 0)
else:
nose_eq(ans, sol, digits)
def array_eq(ans, sol, digits=0):
if digits == 0:
np_test.assert_array_equal(ans, sol)
else:
np_test.assert_array_almost_equal(ans, sol, digits)
def series_eq(ans, sol, digits=0):
if digits == 0:
pd_test.assert_series_equal(ans, sol, digits)
else:
nose_eq(ans.name, sol.name)
np_test.assert_array_almost_equal(ans.values, sol.values, digits)
def frame_eq(ans, sol, digits=0):
if digits == 0:
pd_test.assert_frame_equal(ans, sol)
else:
nose_eq(ans.index.name, sol.index.name)
nose_eq(ans.columns.name, sol.columns.name)
np_test.assert_array_almost_equal(ans.values, sol.values, digits)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,391 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/tests/test_compare_metrics_iris.py | from __future__ import division
import copper
import pandas as pd
from nose.tools import raises
from copper.tests.utils import eq_
def get_iris():
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
Y = iris.target
return X, Y
def get_iris_ds():
X, Y = get_iris()
df = pd.DataFrame(X)
df['Target'] = pd.Series(Y, name='Target')
ds = copper.Dataset(df)
ds.role['Target'] = ds.TARGET
return ds
def get_mc():
ds = get_iris_ds()
mc = copper.ModelComparison()
mc.train_test_split(ds, random_state=0)
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
mc['LR'] = LogisticRegression()
mc['SVM'] = SVC(probability=True)
mc.fit()
return mc
# -----------------------------------------------------------------------------
def test_accuracy_score(mc=None):
mc = get_mc() if mc is None else mc
# print mc.accuracy_score()
score = mc.accuracy_score()
eq_(score['SVM'], 0.973684, 6)
eq_(score['LR'], 0.868421, 6)
@raises(ValueError) # Not binary classification
def test_auc_score(mc=None):
mc = get_mc() if mc is None else mc
mc.auc_score()
@raises(ValueError) # Not binary classification
def test_average_precision_score(mc=None):
mc = get_mc() if mc is None else mc
mc.average_precision_score()
def test_f1_score(mc=None):
mc = get_mc() if mc is None else mc
score = mc.f1_score()
eq_(score['SVM'], 0.973952, 6)
eq_(score['LR'], 0.870540, 6)
def test_fbeta_score(mc=None):
mc = get_mc() if mc is None else mc
score = mc.fbeta_score(beta=0.1)
eq_(score['SVM'], 0.976249, 6)
eq_(score['LR'], 0.914067, 6)
score = mc.fbeta_score()
eq_(score['SVM'], 0.973952, 6)
eq_(score['LR'], 0.870540, 6)
def test_hinge_loss(mc=None):
mc = get_mc() if mc is None else mc
score = mc.hinge_loss()
eq_(score['SVM'], 1.921052, 4)
eq_(score['LR'], 2.026315, 4)
def test_matthews_corrcoef(mc=None):
pass
''' Multiclass not supported for this metric
mc = get_mc() if mc is None else mc
score = mc.matthews_corrcoef()
eq_(score['SVM'], 0.978391)
eq_(score['LR'], 0.916242)
'''
def test_precision_score(mc=None):
mc = get_mc() if mc is None else mc
score = mc.precision_score()
eq_(score['SVM'], 0.976316, 6)
eq_(score['LR'], 0.915414, 6)
def test_recall_score(mc=None):
mc = get_mc() if mc is None else mc
score = mc.recall_score()
eq_(score['SVM'], 0.973684, 6)
eq_(score['LR'], 0.868421, 6)
def test_recall_score_average_none(mc=None):
mc = get_mc() if mc is None else mc
score = mc.recall_score(average=None)
eq_(score['LR (2)'], 1, 6)
eq_(score['LR (0)'], 1, 6)
eq_(score['SVM (2)'], 1, 6)
eq_(score['SVM (0)'], 1, 6)
eq_(score['SVM (1)'], 0.9375, 4)
eq_(score['LR (1)'], 0.6875, 4)
def test_zero_one_loss(mc=None):
mc = get_mc() if mc is None else mc
score = mc.zero_one_loss()
eq_(score['SVM'], 0.026316, 6)
eq_(score['LR'], 0.131579, 6)
# -----------------------------------------------------------------------------
# With target as string
def get_mc_string():
ds = get_iris_ds()
ds.type['Target'] = ds.CATEGORY
ds['Target'] = ds['Target'].apply(lambda x: str(x))
ds['Target'][ds['Target'] == '0'] = 'Iris-setosa'
ds['Target'][ds['Target'] == '1'] = 'Iris-versicolor'
ds['Target'][ds['Target'] == '2'] = 'Iris-virginica'
eq_(ds.metadata['dtype']['Target'], object)
mc = copper.ModelComparison()
mc.train_test_split(ds, random_state=0)
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
mc['LR'] = LogisticRegression()
mc['SVM'] = SVC(probability=True)
mc.fit()
return mc
def test_repeat_tests_with_target_string():
mc = get_mc_string()
test_accuracy_score(mc)
test_f1_score(mc)
test_fbeta_score(mc)
test_hinge_loss(mc)
test_matthews_corrcoef(mc)
test_precision_score(mc)
test_recall_score(mc)
# test_recall_score_average_none(mc)
test_zero_one_loss(mc)
def test_recall_score_average_none_string(mc=None):
mc = get_mc_string() if mc is None else mc
score = mc.recall_score(average=None)
eq_(score['LR (Iris-virginica)'], 1, 6)
eq_(score['LR (Iris-setosa)'], 1, 6)
eq_(score['SVM (Iris-virginica)'], 1, 6)
eq_(score['SVM (Iris-setosa)'], 1, 6)
eq_(score['SVM (Iris-versicolor)'], 0.9375, 4)
eq_(score['LR (Iris-versicolor)'], 0.6875, 4)
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,392 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/tests/test_gdbn.py | from __future__ import division
from copper.ml.gdbn.gdbn import DBN
def get_iris():
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
Y = iris.target
return X, Y
def test_basic():
''' sklearn API: not functionality
'''
dbn = DBN()
X, y = get_iris()
dbn.fit(X, y)
dbn.predict_proba(X)
dbn.predict(X)
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,393 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/ml/dbn/__init__.py | from .dbn import DBN as DBN | {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,394 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/data1infile.py |
from bs4 import BeautifulSoup
from urllib2 import urlopen
import csv
base_url = ("http://espn.go.com/college-football/rankings")
soup = BeautifulSoup(urlopen(base_url).read())
teams = soup.find_all("td", "align-left team")
team_urls = [td.a["href"] for td in teams]
with open("data/src-ESPN_NCAAF_teams.tsv", "w") as f:
fieldnames = ("rank", "team", "record", "points", "trend")
output = csv.writer(f, delimiter="\t")
output.writerow(fieldnames)
for url in team_urls:
url = url.replace("http://espn.go.com", "") # inconsistent URL
page = urlopen("http://espn.go.com{0}".format(url))
team1 = BeautifulSoup(page.read()).find("td", {"id": "team"})
rank = team1.find("td", {"id": "rank"}).encode_contents().strip()
team2 = team1.h1.encode_contents().strip().split("<br/>")[0]
restaurant = team1.h1.span.encode_contents()
description = team1.p.encode_contents().strip()
output.writerow([rank, team, record, points, trend])
print "Done writing file" | {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,395 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/dataset.py | from __future__ import division
import copper
import pandas as pd
class Dataset(dict):
""" Wrapper around pandas.DataFrame introducing metadata to the different
variables/columns making easier to interate in manual machine learning
feature learning. Also provides access to basic data transformation such as
string to numbers.
Finally provides a convinient interface to the copper.ModelComparison
utilities.
Parameters
----------
data : pandas.DataFrame
Examples
--------
>>> df = pandas.read_cvs('a_csv_file.csv')
>>> ds = copper.Dataset(df)
>>> df = pd.DataFrame(np.random.rand(3, 3))
>>> ds = copper.Dataset(df)
>>> ds.frame
0 1 2
0 0.9 0.1 0.6
1 0.7 0.6 0.8
2 0.4 0.4 0.6
>>> ds.metadata
Role Type dtype
Columns
0 Input Number float64
1 Input Number float64
2 Input Number float64
"""
IGNORE = 'Ignore'
INPUT = 'Input'
TARGET = 'Target'
NUMBER = 'Number'
CATEGORY = 'Category'
def __init__(self, data=None):
self.role = pd.Series()
self.type = pd.Series()
self._frame = pd.DataFrame()
if data is not None:
self.frame = data
# -----------------------------------------------------------------------------
# Properties
def get_frame(self):
""" Return the pandas.DataFrame
Examples
--------
>>> ds.frame
0 1 2 3 4 5
0 0.9 0.1 0.6 0.9 0.4 0.8
1 0.7 0.6 0.8 0.1 0.1 0.0
2 0.4 0.4 0.6 0.8 0.2 0.7
3 0.7 0.2 0.9 0.9 0.8 0.6
4 0.5 0.7 0.6 0.0 0.2 0.0
"""
return self._frame
def set_frame(self, frame):
""" Set the data of the dataset.
When used recreates the metadata.
Examples
--------
>>> ds.frame = pd.DataFrame(...)
"""
assert type(frame) is pd.DataFrame, 'should be a pandas.DataFrame'
recreate = True
if len(self._frame.columns) > 0:
if len(frame.columns) == len(self._frame.columns):
if (frame.columns == self._frame.columns).all():
recreate = False
if recreate:
columns = frame.columns
self.role = pd.Series(name='Role', index=columns, dtype=object)
self.type = pd.Series(name='Type', index=columns, dtype=object)
if not frame.empty:
self.role[:] = self.INPUT
self.type[:] = self.NUMBER
self.type[frame.dtypes == object] = self.CATEGORY
self._frame = frame
def get_metadata(self):
""" Return the pandas.DataFrame
Returns
-------
pandas.DataFrame
Examples
--------
>>> ds.metadata
Role Type dtype
Columns
0 Input Category object
1 Input Number float64
2 Input Number float64
3 Input Category object
4 Input Number float64
5 Input Number float64
"""
metadata = pd.DataFrame(index=self._frame.columns)
metadata.index.name = 'Columns'
metadata['Role'] = self.role
metadata['Type'] = self.type
metadata['dtype'] = [] if len(metadata) == 0 else self._frame.dtypes.values
return metadata
def set_metadata(self, metadata):
""" Sets metadata
Notes
-----
The new metadata index needs to match previous metadata index
(columns of the DataFrame) in order to work
See Also
--------
copper.Dataset.match
"""
assert type(metadata) is pd.DataFrame, 'should be a pandas.DataFrame'
assert len(self.metadata) == len(metadata), \
'Length is not consistent, try Dataset.copy_metadata instead'
assert (self.metadata.index.values == metadata.index.values).all(), \
'Index is not consistent, try Dataset.copy_metadata instead'
self.role = metadata['Role']
self.type = metadata['Type']
def copy_metadata(self, metadata, ignoreMissing=True):
""" Copies the metadata from another dataset or dataframe
Parameters
----------
ignoreMissing: boolean
If True (deafult) is going to ignore (do not modify)
the variables that are not on the new metadata.
if False is going to make role of variables not present on the
new metadata "IGNORE"
Returns
-------
"""
if isinstance(metadata, Dataset):
metadata = metadata.metadata # Brain damage
if not ignoreMissing:
self.role[:] = self.IGNORE
for col in self.columns:
if col in metadata.index:
self.role[col] = metadata['Role'][col]
self.type[col] = metadata['Type'][col]
def get_columns(self):
""" Returns the columns of the frame
Examples
--------
>>> ds.columns == df.frame.columns
True
"""
return self._frame.columns
def get_index(self):
""" Returns the index of the frame
Examples
--------
>>> ds.index == df.frame.index
True
"""
return self._frame.index
frame = property(get_frame, set_frame, None, 'pandas.DataFrame')
metadata = property(get_metadata, set_metadata, None, 'pandas.DataFrame')
columns = property(get_columns, None, None)
index = property(get_index, None, None)
def __getitem__(self, name):
return self._frame[name]
def __setitem__(self, name, value):
self._frame[name] = value
def __len__(self):
return len(self._frame)
def __str__(self):
return self.metadata.__str__()
def __unicode__(self):
return self.metadata.__unicode__()
# -----------------------------------------------------------------------------
# Functions
def update(self):
""" Updates the DataFrame based on the metadata.
Transforms strings to numbers using regular expression.
"""
for col in self._frame.columns:
if self.type[col] == self.NUMBER and self._frame[col].dtype == object:
self._frame[col] = self._frame[col].apply(copper.t.to_float)
def filter_cols(self, role=None, type=None):
""" Returns a list of the columns that matches the criterias.
Parameters
----------
role : list or string
type : list or string
Returns
-------
list with the columns names
Examples
--------
>>> ds.filter_cols(role=ds.INPUT)
... list ...
>>> ds.filter_cols(role=ds.INPUT, type=ds.CATEGORY)
... list ...
"""
def _type(obj):
return obj.__class__
if role is None:
role = [self.INPUT, self.TARGET, self.IGNORE]
elif _type(role) == str:
role = [role]
if type is None:
type = [self.NUMBER, self.CATEGORY]
elif _type(type) == str:
type = [type]
return [col for col in self._frame.columns.tolist()
if self.role[col] in role and self.type[col] in type]
def filter(self, role=None, type=None):
""" Returns a pandas.DataFrame with the variables that match the
criterias.
Parameters
----------
role : list or string
type : list or string
Returns
-------
pandas.DataFrame
Examples
--------
>>> ds.filter() == ds.frame
True
>>> ds.filter(role=ds.INPUT)
... pd.DataFrame ...
>>> ds.filter(role=ds.INPUT, type=ds.CATEGORY)
... pd.DataFrame ...
"""
return self._frame[self.filter_cols(role, type)]
# -----------------------------------------------------------------------------
# Pandas API
def head(self, *args, **kwargs):
return self._frame.head(*args, **kwargs)
def tail(self, *args, **kwargs):
return self._frame.tail(*args, **kwargs)
'''
import math
import random
import copper
import numpy as np
import pandas as pd
from nose.tools import raises
from copper.tests.utils import eq_
if __name__ == '__main__':
import nose
nose.runmodule(argv=[__file__, '-vs', '--nologcapture'], exit=False)
'''
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,396 | haiweiosu/WebScraping | refs/heads/master | /ESPNdata/copper/ml/dbn/dbn.py | from __future__ import division
import math
import json
import numpy as np
from sklearn.base import BaseEstimator
from rbm import RBM
from layers import SigmoidLayer
from copper.utils import opti as MBOpti
from utils import sigmoid
from sklearn.neural_network import BernoulliRBM
from copper.utils.progress import ProgressBar # import last
def cost(weights, X, y, layers, num_labels):
output = layers[0].output(X)
for layer in layers[1:]:
output = layer.output(output)
Y = np.eye(num_labels)[y]
h = output
costPositive = -Y * np.log(h)
costNegative = (1 - Y) * np.log(1 - h)
return np.sum(costPositive - costNegative) / X.shape[0]
def cost_prime(weights, X, y, layers, num_labels):
Y = np.eye(num_labels)[y]
Deltas = [np.zeros((l.n_in + 1, l.n_out)) for l in layers]
for i, row in enumerate(X):
# Forward
output = row
activations = (output, )
for layer in layers:
output = layer.output(output)
activations = activations + (output, )
# Backprop
prev_delta = activations[-1] - Y[i, :].T
deltas = (prev_delta, )
for act, layer in zip(reversed(activations[1:-1]), reversed(layers)):
delta = np.dot(layer.W, prev_delta) * (act * (1 - act)).T
deltas = (delta, ) + deltas
prev_delta = delta
# Accumulate errors
for delta, act, i in zip(deltas, activations[:-1], range(len(Deltas))):
act = np.append(1, act) # Bias unit = 1
Deltas[i] = Deltas[i] + np.dot(delta[np.newaxis].T, act[np.newaxis]).T
for i in range(len(Deltas)):
Deltas[i] = Deltas[i] / X.shape[0]
return np.concatenate(tuple([D.reshape(-1) for D in Deltas]))
class DBN(BaseEstimator):
def __init__(self, hidden_layers, coef0=None, random_state=None,
progress_bars=False,
pretrain_batch_size=100,
pretrain_epochs=0, pretrain_batches_per_epoch=-1,
pretrain_callback=None,
finetune_method='GD', finetune_batch_size=50,
finetune_epochs=1, finetune_batches_per_epoch=-1,
finetune_options=None, finetune_callback=None):
self.hidden_layers = hidden_layers
self.coef_ = None if coef0 is None else np.copy(coef0)
if random_state is None:
self.rnd = np.random.RandomState()
elif isinstance(random_state, int):
self.rnd = np.random.RandomState(random_state)
else:
self.rnd = random_state
self.progress_bars = progress_bars
self.pretrain_batch_size = pretrain_batch_size
self.pretrain_epochs = pretrain_epochs
self.pretrain_batches_per_epoch = pretrain_batches_per_epoch
self.pretrain_callback = pretrain_callback
self.finetune_method = finetune_method
self.finetune_batch_size = finetune_batch_size
self.finetune_epochs = finetune_epochs
self.finetune_batches_per_epoch = finetune_batches_per_epoch
self.finetune_options = {} if finetune_options is None else finetune_options
self.finetune_callback = finetune_callback
def build_net(self, n_in, n_out):
layers = [n_in]
layers.extend(self.hidden_layers)
layers.append(n_out)
self.weights_info = [(layers[i], layers[i + 1]) for i in range(len(layers) - 1)]
self.layers = list()
for w_info in self.weights_info:
n_in = w_info[0]
n_out = w_info[1]
self.layers.append(SigmoidLayer(n_in=n_in, n_out=n_out, random_state=self.rnd))
def assign_weights(self):
start_pos = 0
for layer in self.layers:
n_in = layer.W.shape[0]
n_out = layer.W.shape[1]
end_pos = start_pos + n_out
layer.b = self.coef_[start_pos:end_pos]
start_pos = end_pos
end_pos = start_pos + n_in * n_out
layer.W = self.coef_[start_pos:end_pos].reshape((n_in, n_out))
start_pos = end_pos
def save(self, filepath):
info = {}
info['metadata'] = self.weights_info
info['weights'] = self.coef_.tolist()
with open(filepath, 'w') as outfile:
json.dump(info, outfile)
def load(self, filepath):
with open(filepath, 'r') as infile:
info = json.load(infile)
weight_info = info['metadata']
n_in = weight_info[0][0]
n_out = weight_info[-1][1]
self.build_net(n_in, n_out)
self.coef_ = np.array(info['weights'])
self.assign_weights()
def fit(self, X, y):
self.build_net(X.shape[1], len(np.unique(y)))
# Assign weights of layers as views of the big weights
if self.coef_ is None:
ws = list()
for layer in self.layers:
ws.append(layer.b.reshape(-1))
ws.append(layer.W.reshape(-1))
self.coef_ = np.concatenate(tuple(ws))
self.assign_weights()
# Pretrain
if self.pretrain_epochs > 0:
if self.progress_bars:
if self.pretrain_batches_per_epoch == -1:
batches_per_epoch = int(X.shape[0] / self.pretrain_batch_size)
else:
batches_per_epoch = self.pretrain_batches_per_epoch
maxiters = self.pretrain_epochs * batches_per_epoch * len(self.layers)
pt_bar = ProgressBar(max=maxiters, desc='Pretrain')
if self.pretrain_batch_size == -1:
# Use full-batch
self.pretrain_batch_size = X.shape[0]
# Create RBM layers using the same weights
self.rbm_layers = []
for i, layer in enumerate(self.layers):
n_hid = layer.W.shape[1]
new = RBM(layer)
self.rbm_layers.append(new)
# Actual pretrain
for i, rbm_layer in enumerate(self.rbm_layers):
for epoch in range(self.pretrain_epochs):
mb = MBOpti.minibatches(X, batch_size=self.pretrain_batch_size,
batches=self.pretrain_batches_per_epoch,
random_state=self.rnd)
for j, batch in enumerate(mb):
if i == 0:
input = batch
else:
# input = self.layers[i - 1].output(batcn)
try:
input = self.layers[i - 1].sample_h_given_v(input)
except:
print input.shape, self.layers[i-1].W.shape
raise Exception('1')
rbm_layer.contrastive_divergence(input)
if self.progress_bars:
pt_bar.next()
if self.pretrain_callback is not None:
stop = self.pretrain_callback(self, layer, epoch + 1, j + 1)
if stop == True:
break
if self.progress_bars:
pt_bar.complete()
# Finetune
if self.finetune_epochs > 0:
if self.progress_bars:
if self.finetune_batches_per_epoch == -1:
batches_per_epoch = int(X.shape[0] / self.finetune_batch_size)
else:
batches_per_epoch = self.finetune_batches_per_epoch
maxiters = self.finetune_epochs * batches_per_epoch
ft_bar = ProgressBar(max=maxiters, desc='Finetune')
def _callback(epoch, i):
if self.progress_bars:
ft_bar.next()
if self.finetune_callback is not None:
return self.finetune_callback(self, epoch, i)
self.finetune_options = self.finetune_options.copy()
args = (self.layers, len(np.unique(y)))
MBOpti.minimize(self.coef_, X, y, fun=cost, grad=cost_prime, weights=self.coef_,
method=self.finetune_method,
epochs=self.finetune_epochs, batch_size=self.finetune_batch_size,
batches_per_epoch=self.finetune_batches_per_epoch,
options=self.finetune_options, args=args, callback=_callback,
random_state=self.rnd)
if self.progress_bars:
ft_bar.complete()
def predict_proba(self, X):
output = self.layers[0].output(X)
for layer in self.layers[1:]:
output = layer.output(output)
return output
def predict(self, X):
return self.predict_proba(X).argmax(1)
| {"/ESPNdata/copper/ml/dbn/__init__.py": ["/ESPNdata/copper/ml/dbn/dbn.py"]} |
63,397 | dani6666/TabuSearchSolvingTSP | refs/heads/master | /TSP.py | import random
import time
class TSP:
@staticmethod
def find_way(matrix, time_to_run):
TSP.tabu_size = len(matrix) ** 2
deadline = time.time() + time_to_run
n = len(matrix)
permutation = [0] + random.sample(range(1, n), n - 1)
best = permutation
tabu_list = [permutation]
while time.time() < deadline:
neighbours = list(TSP.get_neighbours(permutation))
best_neighbour = neighbours[0]
for perm in neighbours:
if perm not in tabu_list and \
TSP.calculate_route(perm, n, matrix) < TSP.calculate_route(best_neighbour, n, matrix):
best_neighbour = perm
permutation = best_neighbour
tabu_list.append(best_neighbour)
if TSP.calculate_route(best, n, matrix) > TSP.calculate_route(best_neighbour, n, matrix):
best = best_neighbour
if len(tabu_list) == TSP.tabu_size:
tabu_list.__delitem__(0)
return best, TSP.calculate_route(best, n, matrix)
@staticmethod
def get_neighbours(permutation):
for i in range(1, len(permutation) - 1):
result = []
j = 0
while j < len(permutation):
if i == j:
result += [permutation[j + 1], permutation[j]]
j += 2
if j < len(permutation):
result.append(permutation[j])
j += 1
yield result
@staticmethod
def calculate_route(permutation, n, matrix):
result = 0
for i in range(1, n):
result += matrix[permutation[i - 1]][permutation[i]]
result += matrix[permutation[n - 1]][0]
return result
| {"/main.py": ["/TSP.py"]} |
63,398 | dani6666/TabuSearchSolvingTSP | refs/heads/master | /main.py | import sys
from TSP import TSP
t_n_string = input().split(" ", 2)
t = int(t_n_string[0])
n = int(t_n_string[1])
matrix = []
for i in range(n):
matrix.append([int(mat) for mat in input().split(" ", n)])
result = TSP.find_way(matrix, t)
print(result[1])
output = ""
for i in range(n):
output += str(result[0][i] + 1) + " "
output += "1"
print(output)
| {"/main.py": ["/TSP.py"]} |
63,399 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /app/migrations/0003_auto_20210502_0017.py | # Generated by Django 2.2.8 on 2021-05-01 18:47
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('app', '0002_student_trigger'),
]
operations = [
migrations.RemoveField(
model_name='student',
name='regno',
),
migrations.RemoveField(
model_name='student',
name='trigger',
),
]
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,400 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /app/migrations/0005_question.py | # Generated by Django 3.2.1 on 2021-05-06 12:49
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('app', '0004_trigger_lang'),
]
operations = [
migrations.CreateModel(
name='Question',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('course', models.CharField(max_length=100)),
('number', models.CharField(max_length=100)),
('content', models.CharField(blank=True, max_length=100)),
('answer', models.CharField(blank=True, max_length=100)),
],
),
]
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,401 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /app/views.py | import xlwt
from app.models import *
from django.shortcuts import render
from django.http import HttpResponse
def export_users_xls(request):
response = HttpResponse(content_type='application/ms-excel')
response['Content-Disposition'] = 'attachment; filename="attendance.xls"'
wb = xlwt.Workbook(encoding='utf-8')
ws = wb.add_sheet('Attendance')
row_num = 0
font_style = xlwt.XFStyle()
font_style.font.bold = True
columns = ['RegNo', 'Score']
for col_num in range(len(columns)):
ws.write(row_num, col_num, columns[col_num], font_style)
font_style = xlwt.XFStyle()
rows = Student.objects.all().values_list('regno','score')
for row in rows:
row_num += 1
for col_num in range(len(row)):
ws.write(row_num, col_num, row[col_num], font_style)
wb.save(response)
return response
def teacher(request):
if request.method=="POST":
return export_users_xls(request)
return render(request,'teacher.html')
def student(request):
if request.method=="POST":
question=Question.objects.get(number=request.POST["qno"],course=request.POST["course"])
if question.answer==request.POST["chosenoption"]:
student=Student.objects.all()[0]
student.score+=1
student.save()
return HttpResponse(student.score)
return HttpResponse("wrong")
student=Student.objects.all()[0]
return render(request,'student.html',{"student":student})
def startdn(request):
trigger=Trigger(name=request.POST["course"],lang=request.POST["lang"])
trigger.save()
return HttpResponse("Started DistracNot")
def stopdn(request):
trigger=Trigger.objects.get(name=request.POST["course"])
trigger.delete()
return HttpResponse("Stopped DistracNot")
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,402 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /app/models.py | from django.db import models
class Trigger(models.Model):
name = models.CharField(blank=False,max_length=100)
lang = models.CharField(blank=False,max_length=100)
class Question(models.Model):
course = models.CharField(blank=False,max_length=100)
number = models.CharField(blank=False,max_length=100)
content = models.CharField(blank=True,max_length=100)
answer = models.CharField(blank=True,max_length=100)
class Student(models.Model):
regno = models.CharField(blank=False,max_length=100)
score = models.PositiveIntegerField(blank=False, null=False)
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,403 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /app/migrations/0004_trigger_lang.py | # Generated by Django 2.2.8 on 2021-05-02 06:04
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('app', '0003_auto_20210502_0017'),
]
operations = [
migrations.AddField(
model_name='trigger',
name='lang',
field=models.CharField(default=1, max_length=100),
preserve_default=False,
),
]
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,404 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /HocusFocus/urls.py | from django.contrib import admin
from django.urls import path
from app import views
from django.views.decorators.csrf import csrf_exempt
urlpatterns = [
path('admin/', admin.site.urls),
path('teacher', views.teacher),
path('student', csrf_exempt(views.student)),
path('start', csrf_exempt(views.startdn)),
path('stop', csrf_exempt(views.stopdn))
]
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,405 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /HocusFocus/routing.py | from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
from app.consumer import StudentConsumer
from django.urls import path
application = ProtocolTypeRouter({
"http":get_asgi_application(),
"websocket": URLRouter([
path("ws/", StudentConsumer.as_asgi()),
])
})
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,406 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /app/admin.py | from django.contrib import admin
from app.models import *
admin.site.register(Trigger)
admin.site.register(Student)
admin.site.register(Question)
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,407 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /app/consumer.py | import asyncio
from app.models import *
from app import prototype
from asgiref.sync import sync_to_async
from channels.generic.websocket import AsyncJsonWebsocketConsumer
def save_question(event):
try:
total=len(list(Question.objects.filter(course=event["name"])))+1
except:
total=1
question=Question(course=event["name"],number=total)
question.content,options,question.answer=prototype.speech_to_question(event["lang"])
question.save()
return (question,options)
class StudentConsumer(AsyncJsonWebsocketConsumer):
async def connect(self):
await self.accept()
await self.channel_layer.group_add("DistracNot", self.channel_name)
async def disconnect(self, close_code):
await self.channel_layer.group_discard("DistracNot", self.channel_name)
async def send_options(self, event):
while True:
try:
trigger=Trigger.objects.get(name=event["name"])
qn,options=save_question(event)
await self.send_json({"type":"start","qno":qn.number,"options":options,"qn":qn.content})
await asyncio.sleep(10)
except:
await self.send_json({"type":"stop"})
break
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,408 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /app/migrations/0002_student_trigger.py | # Generated by Django 2.2.8 on 2021-05-01 06:49
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('app', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='student',
name='trigger',
field=models.ForeignKey(default=1, on_delete=django.db.models.deletion.CASCADE, to='app.Trigger'),
preserve_default=False,
),
]
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,409 | ashvathnarayanan/Hocus-Focus | refs/heads/main | /app/migrations/0006_student_regno.py | # Generated by Django 3.2.2 on 2021-05-07 10:42
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('app', '0005_question'),
]
operations = [
migrations.AddField(
model_name='student',
name='regno',
field=models.CharField(default=0, max_length=100),
preserve_default=False,
),
]
| {"/app/views.py": ["/app/models.py"], "/HocusFocus/routing.py": ["/app/consumer.py"], "/app/admin.py": ["/app/models.py"], "/app/consumer.py": ["/app/models.py"]} |
63,414 | maniatikorn/nuevoblog | refs/heads/master | /nuevoBlog/apps.py | from __future__ import unicode_literals
from django.apps import AppConfig
class NuevoblogConfig(AppConfig):
name = 'nuevoBlog'
| {"/nuevoBlog/views.py": ["/nuevoBlog/models.py"]} |
63,415 | maniatikorn/nuevoblog | refs/heads/master | /nuevoBlog/views.py | from django.shortcuts import render
from .models import Articulo
from django.views.generic import ListView, DetailView
# Create your views here.
class IndexView(ListView):
template_name = 'index.html'
model = Articulo
class ArticuloDetailView(DetailView):
template_name = 'detalle.html'
model = Articulo | {"/nuevoBlog/views.py": ["/nuevoBlog/models.py"]} |
63,416 | maniatikorn/nuevoblog | refs/heads/master | /nuevoBlog/models.py | from __future__ import unicode_literals
from django.db import models
from django.template.defaultfilters import slugify
# Create your models here.
class Articulo(models.Model):
titulo = models.CharField(max_length=200)
contenido = models.TextField()
imagen = models.ImageField(upload_to="nuevoBlog/static/images-articles/")
slug = models.SlugField(editable=False)
fecha = models.DateTimeField()
class Meta:
ordering = ["-fecha"]
def __unicode__(self):
return self.titulo
def save(self, *args, **kwargs):
if not self.id:
self.slug = slugify(self.titulo)
super(Articulo, self).save(*args, **kwargs) | {"/nuevoBlog/views.py": ["/nuevoBlog/models.py"]} |
63,417 | maniatikorn/nuevoblog | refs/heads/master | /nuevoBlog/migrations/0004_auto_20160216_2057.py | # -*- coding: utf-8 -*-
# Generated by Django 1.9.2 on 2016-02-16 20:57
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('nuevoBlog', '0003_auto_20160216_2052'),
]
operations = [
migrations.AlterField(
model_name='articulo',
name='imagen',
field=models.ImageField(upload_to='nuevoBlog/static/images-articles/'),
),
]
| {"/nuevoBlog/views.py": ["/nuevoBlog/models.py"]} |
63,423 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/bank/bradesco.py | # -*- coding: utf-8
from pyboleto.data import BoletoData, custom_property
import os.path
### CAUTION - NÃO TESTADO ###
class BoletoBradesco( BoletoData ):
'''
Gera Dados necessários para criação de boleto para o banco Bradesco
'''
def __init__(self, *args, **kwargs):
super(BoletoBradesco , self).__init__(*args, **kwargs)
self.codigo_banco = "237"
self.logo_image_path = os.path.dirname(__file__) + \
"/../media/logo_bancobradesco.jpg"
def format_nosso_numero(self):
return "%s/%s-%s" % (
self.carteira,
self.nosso_numero,
self.dv_nosso_numero
)
# Nosso numero (sem dv) sao 11 digitos
nosso_numero = custom_property('nosso_numero', 11)
@property
def dv_nosso_numero(self):
resto2 = self.modulo11(self.nosso_numero,7,1)
digito = 11 - resto2
if digito == 10:
dv = 'P'
elif digito == 11:
dv = 0
else:
dv = digito
return dv
agencia_cedente = custom_property('agencia_cedente', 4)
conta_cedente = custom_property('conta_cedente', 7)
# Numero para o codigo de barras com 44 digitos
@property
def barcode(self):
num = "%3s%1s%1s%4s%10s%4s%2s%11s%7s%1s" % (
self.codigo_banco,
self.moeda,
'X',
self.fator_vencimento,
self.formata_valor(self.valor_documento,10),
self.agencia_cedente.split('-')[0],
self.carteira,
self.nosso_numero,
self.conta_cedente.split('-')[0],
'0'
)
dv = self.calculate_dv_barcode(num.replace('X', '', 1))
num = num.replace('X', str(dv), 1)
return num
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,424 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/tests/test_banco_bradesco.py | # -*- coding: utf-8 -*-
import unittest
import datetime
from pyboleto.bank.bradesco import BoletoBradesco
class TestBancoBradesco(unittest.TestCase):
def setUp(self):
d = BoletoBradesco()
d.carteira = '06'
d.agencia_cedente = '278-0'
d.conta_cedente = '039232-4'
d.data_vencimento = datetime.date(2011, 2, 5)
d.data_documento = datetime.date(2011, 1, 18)
d.data_processamento = datetime.date(201, 1, 18)
d.valor_documento = 8280.00
d.nosso_numero = '2125525'
d.numero_documento = '2125525'
self.dados = d
def test_linha_digitavel(self):
self.assertEqual(self.dados.linha_digitavel,
'23790.27804 60000.212559 25003.923205 4 48690000828000'
)
def test_codigo_de_barras(self):
self.assertEqual(self.dados.barcode,
'23794486900008280000278060000212552500392320'
)
def test_agencia(self):
self.assertEqual(self.dados.agencia_cedente, '0278-0')
def test_conta(self):
self.assertEqual(self.dados.conta_cedente, '0039232-4')
if __name__ == '__main__':
unittest.main()
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,425 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/__init__.py | VERSION = (0, 1, 10)
__version__ = '.'.join(map(str, VERSION))
__all__ = [
'data',
'pdf',
'bank',
]
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,426 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/scripts/print_sample_data.py | # -*- coding: utf-8 -*-
from pyboleto.bank.real import BoletoReal
from pyboleto.bank.bradesco import BoletoBradesco
from pyboleto.bank.caixa import BoletoCaixa
from pyboleto.bank.bancodobrasil import BoletoBB
from pyboleto.pdf import BoletoPDF
import datetime
def print_bb():
listaDados = []
for i in range(2):
d = BoletoBB(7,2)
d.nosso_numero = '87654'
d.numero_documento = '27.030195.10'
d.convenio = '7777777'
d.especie_documento = 'DM'
d.carteira = '18'
d.cedente = 'Empresa Empresa Empresa Empresa Empresa LTDA'
d.agencia_cedente = '9999'
d.conta_cedente = '99999'
d.data_vencimento = datetime.date(2010, 3, 27)
d.data_documento = datetime.date(2010, 02, 12)
d.data_processamento = datetime.date(2010, 02, 12)
d.instrucoes = [
"- Linha 1",
"- Sr Caixa, cobrar multa de 2% após o vencimento",
"- Receber até 10 dias após o vencimento",
]
d.demonstrativo = [
"- Serviço Teste R$ 5,00",
"- Total R$ 5,00",
]
d.valor_documento = 255.00
d.sacado = [
"Cliente Teste %d" % (i+1),
"Rua Desconhecida, 00/0000 - Não Sei - Cidade - Cep. 00000-000",
""
]
listaDados.append( d )
print "Normal"
boleto = BoletoPDF( 'boleto-bb-formato-normal-teste.pdf' )
for i in range(len(listaDados)):
print i
boleto.drawBoleto(listaDados[i])
boleto.nextPage()
boleto.save()
def print_test():
listaDadosReal = []
for i in range(2):
d = BoletoReal()
d.carteira = '57' # Contrato firmado com o Banco Real
d.cedente = 'Empresa Empresa Empresa Empresa Empresa LTDA'
d.agencia_cedente = '0531'
d.conta_cedente = '5705853'
d.data_vencimento = datetime.date(2010, 3, 27)
d.data_documento = datetime.date(2010, 02, 12)
d.data_processamento = datetime.date(2010, 02, 12)
d.instrucoes = [
"- Linha 1",
"- Sr Caixa, cobrar multa de 2% após o vencimento",
"- Receber até 10 dias após o vencimento",
]
d.demonstrativo = [
"- Serviço Teste R$ 5,00",
"- Total R$ 5,00",
]
d.valor_documento = 5.00
d.nosso_numero = "%d" % (i+2)
d.numero_documento = "%d" % (i+2)
d.sacado = [
"Cliente Teste %d" % (i+1),
"Rua Desconhecida, 00/0000 - Não Sei - Cidade - Cep. 00000-000",
""
]
listaDadosReal.append( d )
listaDadosBradesco = []
for i in range(2):
d = BoletoBradesco()
d.carteira = '06' # Contrato firmado com o Banco Bradesco
d.cedente = 'Empresa Empresa Empresa Empresa Empresa LTDA'
d.agencia_cedente = '0278-0'
d.conta_cedente = '43905-3'
d.data_vencimento = datetime.date(2011, 1, 25)
d.data_documento = datetime.date(2010, 02, 12)
d.data_processamento = datetime.date(2010, 02, 12)
d.instrucoes = [
"- Linha 1",
"- Sr Caixa, cobrar multa de 2% após o vencimento",
"- Receber até 10 dias após o vencimento",
]
d.demonstrativo = [
"- Serviço Teste R$ 5,00",
"- Total R$ 5,00",
]
d.valor_documento = 2158.41
d.nosso_numero = "1112011668"
d.numero_documento = "1112011668"
d.sacado = [
"Cliente Teste %d" % (i+1),
"Rua Desconhecida, 00/0000 - Não Sei - Cidade - Cep. 00000-000",
""
]
listaDadosBradesco.append( d )
listaDadosCaixa = []
for i in range(2):
d = BoletoCaixa()
d.carteira = 'SR' # Contrato firmado com o Banco Bradesco
d.cedente = 'Empresa Empresa Empresa Empresa Empresa LTDA'
d.agencia_cedente = '1565'
d.conta_cedente = '414-3'
d.data_vencimento = datetime.date(2010, 3, 27)
d.data_documento = datetime.date(2010, 02, 12)
d.data_processamento = datetime.date(2010, 02, 12)
d.instrucoes = [
"- Linha 1",
"- Sr Caixa, cobrar multa de 2% após o vencimento",
"- Receber até 10 dias após o vencimento",
]
d.demonstrativo = [
"- Serviço Teste R$ 5,00",
"- Total R$ 5,00",
]
d.valor_documento = 255.00
d.nosso_numero = "%d" % (i+2)
d.numero_documento = "%d" % (i+2)
d.sacado = [
"Cliente Teste %d" % (i+1),
"Rua Desconhecida, 00/0000 - Não Sei - Cidade - Cep. 00000-000",
""
]
listaDadosCaixa.append( d )
# Bradesco Formato carne - duas paginas por folha A4
print "Carne"
boleto = BoletoPDF( 'boleto-bradesco-formato-carne-teste.pdf', True )
for i in range(0,len(listaDadosBradesco),2):
print i, i+1
boleto.drawBoletoCarneDuplo(
listaDadosBradesco[i],
listaDadosBradesco[i+1]
)
boleto.nextPage()
boleto.save()
# Bradesco Formato normal - uma pagina por folha A4
print "Normal"
boleto = BoletoPDF( 'boleto-bradesco-formato-normal-teste.pdf' )
for i in range(len(listaDadosBradesco)):
print i
boleto.drawBoleto(listaDadosBradesco[i])
boleto.nextPage()
boleto.save()
# Real Formato normal - uma pagina por folha A4
print "Normal"
boleto = BoletoPDF( 'boleto-real-formato-normal-teste.pdf' )
for i in range(len(listaDadosReal)):
print i
boleto.drawBoleto(listaDadosReal[i])
boleto.nextPage()
boleto.save()
# Caixa Formato normal - uma pagina por folha A4
print "Carne"
boleto = BoletoPDF( 'boleto-caixa-formato-carne-teste.pdf', True )
for i in range(0,len(listaDadosCaixa),2):
print i, i+1
boleto.drawBoletoCarneDuplo(
listaDadosCaixa[i],
listaDadosCaixa[i+1]
)
boleto.nextPage()
boleto.save()
# Caixa Formato normal - uma pagina por folha A4
print "Normal"
boleto = BoletoPDF( 'boleto-caixa-formato-normal-teste.pdf' )
for i in range(len(listaDadosCaixa)):
print i
boleto.drawBoleto(listaDadosCaixa[i])
boleto.nextPage()
boleto.save()
print "Ok"
if __name__ == "__main__":
print_test()
print_bb()
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,427 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/tests/test_banco_real.py | # -*- coding: utf-8 -*-
import unittest
import datetime
from pyboleto.bank.real import BoletoReal
class TestBancoBradesco(unittest.TestCase):
def setUp(self):
d = BoletoReal()
d.carteira = '06'
d.agencia_cedente = '0531'
d.conta_cedente = '5705853'
d.data_vencimento = datetime.date(2011, 2, 5)
d.data_documento = datetime.date(2011, 1, 18)
d.data_processamento = datetime.date(201, 1, 18)
d.valor_documento = 355.00
d.nosso_numero = '123'
d.numero_documento = '123'
self.dados = d
def test_linha_digitavel(self):
self.assertEqual(self.dados.linha_digitavel,
'35690.53154 70585.390001 00000.001230 8 48690000035500'
)
def test_codigo_de_barras(self):
self.assertEqual(self.dados.barcode,
'35698486900000355000531570585390000000000123'
)
if __name__ == '__main__':
unittest.main()
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,428 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/tests/test_banco_caixa.py | # -*- coding: utf-8 -*-
import unittest
import datetime
from pyboleto.bank.caixa import BoletoCaixa
class TestBancoCaixa(unittest.TestCase):
def setUp(self):
d = BoletoCaixa()
d.carteira = 'SR'
d.inicio_nosso_numero = '24'
d.agencia_cedente = '1565'
d.conta_cedente = '414-3'
d.data_vencimento = datetime.date(2011, 2, 5)
d.data_documento = datetime.date(2011, 1, 18)
d.data_processamento = datetime.date(201, 1, 18)
d.valor_documento = 355.00
d.nosso_numero = '19525086'
d.numero_documento = '19525086'
self.dados = d
def test_linha_digitavel(self):
self.assertEqual(self.dados.linha_digitavel,
'10490.00415 43000.200048 01952.508669 6 48690000035500'
)
def test_tamanho_codigo_de_barras(self):
self.assertEqual(len(self.dados.barcode), 44)
def test_codigo_de_barras(self):
self.assertEqual(self.dados.barcode,
'10496486900000355000004143000200040195250866'
)
class TestBancoCaixaSIGCB(unittest.TestCase):
def setUp(self):
d = BoletoCaixa()
d.carteira = 'SR'
d.inicio_nosso_numero = '24'
d.agencia_cedente = '1565'
d.conta_cedente = '414-3'
d.data_vencimento = datetime.date(2011, 2, 5)
d.data_documento = datetime.date(2011, 1, 18)
d.data_processamento = datetime.date(201, 1, 18)
d.valor_documento = 355.00
d.nosso_numero = '19525086'
d.numero_documento = '19525086'
self.dados = d
self.barcode = self.dados.barcode
self.linhadig = self.dados.linha_digitavel.replace('.', '').replace(' ', '')
self.campolivre = self.dados.campo_livre
self.nossonumero = self.dados.nosso_numero
## CODIGO DE BARRAS
def test_barcode_codigobanco(self):
self.assertEquals(len(self.barcode[0:3]), 3)
self.assertEquals(self.barcode[0:3], self.dados.codigo_banco)
self.assertEquals(self.barcode[0:3], '104') ## CAIXA ECONOMICA
def test_barcode_codigomoeda(self):
self.assertEquals(len(self.barcode[3]), 1)
self.assertEquals(self.barcode[3], self.dados.moeda)
self.assertEquals(self.barcode[3], '9') ## BRL (R$)
def test_barcode_digitoverificadorgeral(self):
self.assertEquals(len(self.barcode[4]), 1)
bc = self.barcode[:4] + self.barcode[5:]
self.assertEquals(self.barcode[4], str(self.dados.calculate_dv_barcode(bc)))
self.assertEquals(self.barcode[4], '6')
def test_barcode_fatorvencimento(self):
self.assertEquals(len(self.barcode[5:9]), 4)
self.assertEquals(self.barcode[5:9], str(self.dados.fator_vencimento))
self.assertEquals(self.barcode[5:9], '4869')
def test_barcode_valordocumento(self):
self.assertEquals(len(self.barcode[9:19]), 10)
valor_documento = '%010d' % (float(self.dados.valor_documento) * 100)
self.assertEquals(self.barcode[9:19], valor_documento)
self.assertEquals(self.barcode[9:19], '0000035500') ## R$355.00
def test_barcode_campolivre(self):
self.assertEquals(len(self.barcode[19:44]), 25)
self.assertEquals(self.barcode[19:44], self.campolivre)
self.assertEquals(self.barcode[19:44], '0004143000200040195250866')
def test_barcode_campolivre_codigocedente(self):
self.assertEquals(len(self.campolivre[0:6]), 6)
self.assertEquals(self.barcode[19:25], self.campolivre[0:6])
self.assertEquals(self.barcode[19:25], self.dados.conta_cedente.split('-')[0].lstrip('0').zfill(6))
self.assertEquals(self.barcode[19:25], '000414')
def test_barcode_campolivre_digitoverificadorcodigocedente(self):
self.assertEquals(len(self.campolivre[6]), 1)
self.assertEquals(self.barcode[25], self.campolivre[6])
self.assertEquals(self.barcode[25], self.dados.conta_cedente.split('-')[1])
self.assertEquals(self.barcode[25], '3')
def test_barcode_campolivre_sequencia1(self):
self.assertEquals(len(self.campolivre[7:10]), 3)
self.assertEquals(self.barcode[26:29], self.campolivre[7:10])
self.assertEquals(self.barcode[26:29], self.nossonumero[2:5])
self.assertEquals(self.barcode[26:29], '000')
def test_barcode_campolivre_constante1(self):
self.assertEquals(len(self.campolivre[10]), 1)
self.assertEquals(self.barcode[29], self.campolivre[10])
self.assertEquals(self.barcode[29], self.nossonumero[0])
self.assertEquals(self.barcode[29], '2') ## SR (SEM REGISTRO)
def test_barcode_campolivre_sequencia2(self):
self.assertEquals(len(self.campolivre[11:14]), 3)
self.assertEquals(self.barcode[30:33], self.campolivre[11:14])
self.assertEquals(self.barcode[30:33], self.nossonumero[5:8])
self.assertEquals(self.barcode[30:33], '000')
def test_barcode_campolivre_constante2(self):
self.assertEquals(len(self.campolivre[14]), 1)
self.assertEquals(self.barcode[33], self.campolivre[14])
self.assertEquals(self.barcode[33], self.nossonumero[1])
self.assertEquals(self.barcode[33], '4') ## EMISSAO CEDENTE
def test_barcode_campolivre_sequencia3(self):
self.assertEquals(len(self.campolivre[15:24]), 9)
self.assertEquals(self.barcode[34:43], self.campolivre[15:24])
self.assertEquals(self.barcode[34:43], self.nossonumero[8:17])
self.assertEquals(self.barcode[34:43], self.dados.numero_documento.zfill(9))
self.assertEquals(self.barcode[34:43], '019525086')
def test_barcode_campolivre_digitoverificadorcampolivre(self):
self.assertEquals(len(self.campolivre[24]), 1)
self.assertEquals(self.barcode[43], str(self.dados.modulo11(self.barcode[19:43])))
self.assertEquals(self.barcode[43], self.campolivre[24])
self.assertEquals(self.barcode[43], '6')
def test_barcode_nossonumero(self):
self.assertEquals(len(self.nossonumero), 17)
def test_barcode_nossonumero_constante1(self):
self.assertEquals(len(self.nossonumero[0]), 1)
self.assertEquals(self.nossonumero[0], '2') ## SR (SEM REGISTRO)
def test_barcode_nossonumero_constante2(self):
self.assertEquals(len(self.nossonumero[1]), 1)
self.assertEquals(self.nossonumero[1], '4') ## EMISSAO CEDENTE
def test_barcode_nossonumero_sequencia(self):
self.assertEquals(len(self.nossonumero[2:]), 15)
self.assertEquals(self.nossonumero[2:], '%015d' % int(self.dados.numero_documento))
## LINHA DIGITAVEL
def test_linhadig_campo1(self):
campo1 = self.barcode[0:4] + self.barcode[19:24]
self.assertEquals(len(campo1), 9)
self.assertEquals(self.linhadig[0:9], campo1)
def test_linhadig_dvcampo1(self):
campo1 = self.barcode[0:4] + self.barcode[19:24]
dvcampo1 = self.dados.modulo10(campo1)
self.assertEquals(self.linhadig[9], str(dvcampo1))
def test_linhadig_campo2(self):
campo2 = self.barcode[24:34]
self.assertEquals(len(campo2), 10)
self.assertEquals(self.linhadig[10:20], campo2)
def test_linhadig_dvcampo2(self):
campo2 = self.barcode[24:34]
dvcampo2 = self.dados.modulo10(campo2)
self.assertEquals(self.linhadig[20], str(dvcampo2))
def test_linhadig_campo3(self):
campo3 = self.barcode[34:44]
self.assertEquals(len(campo3), 10)
self.assertEquals(self.linhadig[21:31], campo3)
def test_linhadig_dvcampo3(self):
campo3 = self.barcode[34:44]
dvcampo3 = self.dados.modulo10(campo3)
self.assertEquals(self.linhadig[31], str(dvcampo3))
def test_linhadig_campo4(self): ## digito verificador geral
self.assertEquals(self.linhadig[32], self.barcode[4])
def test_linhadig_campo5_parte1(self):
campo5 = self.barcode[5:9]
self.assertEquals(len(campo5), 4)
self.assertEquals(self.linhadig[33:37], campo5)
def test_linhadig_campo5_parte1(self):
campo5 = self.barcode[9:19]
self.assertEquals(len(campo5), 10)
self.assertEquals(self.linhadig[37:47], campo5)
if __name__ == '__main__':
unittest.main()
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,429 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/bank/caixa.py | #-*- coding: utf-8 -*-
from pyboleto.data import BoletoData, custom_property
import os.path
### CAUTION - NÃO TESTADO ###
class BoletoCaixa( BoletoData ):
'''
Gera Dados necessários para criação de boleto para o banco Caixa
Economica Federal
'''
def __init__(self, *args, **kwargs):
super(BoletoCaixa , self).__init__(*args, **kwargs)
self.codigo_banco = "104"
self.moeda = "9"
self.local_pagamento = "Preferencialmente nas Casas Lotéricas e Agências da Caixa"
self.logo_image_path = os.path.dirname(__file__) + \
"/../media/logo_bancocaixa.jpg"
'''
Carteira SR: 80, 81 ou 82 -
Carteira CR: 90 (Confirmar com gerente qual usar)
'''
self.inicio_nosso_numero = '80'
# Nosso numero (sem dv) sao 17 digitos
def _nosso_numero_get(self):
return self._nosso_numero
'''
Nosso Número sem DV, máximo 8 chars
'''
def _nosso_numero_set(self, val):
try:
self._nosso_numero = self.inicio_nosso_numero + \
str(self.formata_numero(val, 15))
except AttributeError:
pass
nosso_numero = property(_nosso_numero_get, _nosso_numero_set)
@property
def dv_nosso_numero(self):
resto2 = self.modulo11(self.nosso_numero.split('-')[0],9,1)
digito = 11 - resto2
if digito == 10 or digito == 11:
dv = 0
else:
dv = digito
return dv
'''
agencia do cedente sem DV
'''
agencia_cedente = custom_property('agencia_cedente', 4)
conta_cedente = custom_property('conta_cedente', 11)
# Numero para o codigo de barras com 44 digitos
@property
def barcode(self):
num = "%3s%1s%1s%4s%10s%25s" % (
self.codigo_banco,
self.moeda,
'X',
self.fator_vencimento,
self.formata_valor(self.valor_documento,10),
self.campo_livre
)
dv = self.calculate_dv_barcode(num.replace('X', '', 1))
num = num.replace('X', str(dv), 1)
return num
@property
def campo_livre(self):
num = '%7s%3s%1s%3s%1s%9s' % (
self.conta_cedente.replace('-', '')[-7:],
self.nosso_numero[3:6],
self.nosso_numero[0],
self.nosso_numero[6:9],
self.nosso_numero[1],
self.nosso_numero[8:18]
)
num += str(self.modulo11(num))
return num
@property
def linha_digitavel(self):
'''
Monta a linha que o cliente pode utilizar para digitar se o código
de barras não puder ser lido
CAMPO 1:
========
1 a 3 Número do banco (1 a 3 do barcode)
4 Código da Moeda - 9 para Real (4 do barcode)
5 a 9 5 primeiras posições do campo livre (20 a 24 do barcode)
10 Dígito verificador deste campo
CAMPO 2:
========
11 a 20 Posições 6 a 15 do campo livre (25 a 34 do barcode)
21 Dígito verificador deste campo
CAMPO 3:
========
32 a 43 Posições 16 a 25 do campo livre (35 a 44 do barcode)
44 Dígito verificador deste campo
CAMPO 4:
========
45 Dígito Verificador geral do código de barras (5 do barcode)
CAMPO 5:
========
46 a 50 Fator de vencimento (6 a 9 do barcode)
51 a 60 Valor Nominal do título (10 a 19 do barcode)
'''
linha = self.barcode
if not linha:
BoletoException("Boleto doesn't have a barcode")
## campo1
campo1 = linha[0:3] + linha[3] + linha[19:24]
campo1 += str(self.modulo10(campo1))
campo1 = '%s.%s' % (campo1[:5], campo1[5:])
## campo2
campo2 = linha[24:34]
campo2 += str(self.modulo10(campo2))
campo2 = '%s.%s' % (campo2[:5], campo2[5:])
## campo3
campo3 = linha[34:44]
campo3 += str(self.modulo10(campo3))
campo3 = '%s.%s' % (campo3[:5], campo3[5:])
## campo4
campo4 = linha[4]
## campo5
campo5 = linha[5:9] + linha[9:19]
return "%s %s %s %s %s" % (campo1, campo2, campo3, campo4, campo5)
def format_nosso_numero(self):
return self._nosso_numero + '-' + str(self.dv_nosso_numero)
@property
def agencia_conta_cedente(self):
val = self.conta_cedente.split('-')
val[0] = val[0][-6:]
return "%s/%s" % (self.agencia_cedente, '-'.join(val))
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,430 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/pdf.py | # -*- coding: utf-8 -*-
from reportlab.pdfgen import canvas
from reportlab.lib.units import mm, cm
from reportlab.lib.colors import black, white
from reportlab.graphics.barcode.common import I2of5
import reportlab.lib.pagesizes
import datetime
class BoletoPDF:
def __init__(self, file_descr, landscape = False ):
self.width = 190*mm
self.widthCanhoto = 70*mm
self.heightLine = 6.5*mm
self.space = 2
self.fontSizeTitle = 6
self.fontSizeValue = 9
self.deltaTitle = self.heightLine - (self.fontSizeTitle + 1)
self.deltaFont = self.fontSizeValue + 1;
if landscape:
pagesize = reportlab.lib.pagesizes.landscape(
reportlab.lib.pagesizes.A4
)
else:
pagesize = reportlab.lib.pagesizes.A4
self.pdfCanvas = canvas.Canvas( file_descr, pagesize = pagesize )
self.pdfCanvas.setStrokeColor( black )
def drawReciboSacadoCanhoto(self, boletoDados, x, y ):
self.pdfCanvas.saveState();
self.pdfCanvas.translate( x, y );
linhaInicial = 12
# Horizontal Lines
self.pdfCanvas.setLineWidth(2)
self.__horizontalLine( 0, 0, self.widthCanhoto )
self.pdfCanvas.setLineWidth(1)
self.__horizontalLine( 0, (linhaInicial + 0)*self.heightLine,
self.widthCanhoto )
self.__horizontalLine( 0, (linhaInicial + 1)*self.heightLine,
self.widthCanhoto )
self.pdfCanvas.setLineWidth(2)
self.__horizontalLine( 0, (linhaInicial + 2)*self.heightLine,
self.widthCanhoto )
# Vertical Lines
self.pdfCanvas.setLineWidth(1)
self.__verticalLine( self.widthCanhoto - (35*mm),
(linhaInicial + 0) * self.heightLine, self.heightLine )
self.__verticalLine( self.widthCanhoto - (35*mm),
(linhaInicial + 1) * self.heightLine, self.heightLine )
self.pdfCanvas.setFont( 'Helvetica-Bold', 6 )
self.pdfCanvas.drawRightString( self.widthCanhoto,
0 * self.heightLine + 3,
'Recibo do Sacado'
)
# Titles
self.pdfCanvas.setFont('Helvetica', 6 )
self.deltaTitle = self.heightLine - (6 + 1)
self.pdfCanvas.drawString(
self.space,
(((linhaInicial + 0)*self.heightLine)) + self.deltaTitle,
'Nosso Número'
)
self.pdfCanvas.drawString(
self.widthCanhoto - (35*mm) + self.space,
(((linhaInicial + 0)*self.heightLine)) + self.deltaTitle,
'Vencimento'
)
self.pdfCanvas.drawString(
self.space,
(((linhaInicial + 1)*self.heightLine)) + self.deltaTitle,
'Agência/Código Cedente'
)
self.pdfCanvas.drawString(
self.widthCanhoto - (35*mm) + self.space,
(((linhaInicial + 1)*self.heightLine)) + self.deltaTitle,
'Valor Documento'
)
# Values
self.pdfCanvas.setFont('Helvetica', 9 )
heighFont = 9 + 1;
valorDocumento = self._formataValorParaExibir(
boletoDados.valor_documento
)
self.pdfCanvas.drawString(
self.space,
(((linhaInicial + 0)*self.heightLine)) + self.space,
boletoDados.format_nosso_numero()
)
self.pdfCanvas.drawString(
self.widthCanhoto - (35*mm) + self.space,
(((linhaInicial + 0)*self.heightLine)) + self.space,
boletoDados.data_vencimento.strftime('%d/%m/%Y')
)
self.pdfCanvas.drawString(
self.space,
(((linhaInicial + 1)*self.heightLine)) + self.space,
boletoDados.agencia_conta_cedente
)
self.pdfCanvas.drawString(
self.widthCanhoto - (35*mm) + self.space,
(((linhaInicial + 1)*self.heightLine)) + self.space,
valorDocumento
)
demonstrativo = boletoDados.demonstrativo[0:12]
for i in range(len(demonstrativo)):
self.pdfCanvas.drawString(
2*self.space,
(((linhaInicial - 1)*self.heightLine)) - (i * heighFont),
demonstrativo[i][0:55]
)
self.pdfCanvas.restoreState();
return ( self.widthCanhoto,
((linhaInicial+2)*self.heightLine) )
def drawReciboSacado(self, boletoDados, x, y ):
self.pdfCanvas.saveState();
self.pdfCanvas.translate( x, y );
linhaInicial = 16
# Horizontal Lines
self.pdfCanvas.setLineWidth(1)
self.__horizontalLine( 0,
linhaInicial * self.heightLine, self.width )
self.__horizontalLine( 0,
(linhaInicial + 1) * self.heightLine, self.width )
self.pdfCanvas.setLineWidth(2)
self.__horizontalLine( 0,
(linhaInicial + 2) * self.heightLine, self.width )
# Vertical Lines
self.pdfCanvas.setLineWidth(1)
self.__verticalLine(
self.width - (35*mm),
(linhaInicial + 0) * self.heightLine,
2 * self.heightLine
)
self.__verticalLine(
self.width - (35*mm) - (30*mm),
(linhaInicial + 0) * self.heightLine,
2 * self.heightLine
)
self.__verticalLine(
self.width - (35*mm) - (30*mm) - (40*mm),
(linhaInicial + 0) * self.heightLine,
2 * self.heightLine
)
# Head
self.pdfCanvas.setLineWidth(2)
self.__verticalLine( 40*mm,
(linhaInicial + 2) * self.heightLine, self.heightLine )
self.__verticalLine( 60*mm,
(linhaInicial + 2) * self.heightLine, self.heightLine )
if boletoDados.logo_image_path:
self.pdfCanvas.drawImage(
boletoDados.logo_image_path,
0, (linhaInicial + 2) * self.heightLine + 3,
40*mm,
self.heightLine,
preserveAspectRatio=True,
anchor='sw'
)
self.pdfCanvas.setFont( 'Helvetica-Bold', 18 )
self.pdfCanvas.drawCentredString(
50*mm,
(linhaInicial + 2) * self.heightLine + 3,
boletoDados.codigo_dv_banco
)
self.pdfCanvas.setFont( 'Helvetica-Bold', 10 )
self.pdfCanvas.drawRightString(
self.width,
(linhaInicial + 2) * self.heightLine + 3,
'Recibo do Sacado'
)
# Titles
self.pdfCanvas.setFont('Helvetica', 6 )
self.deltaTitle = self.heightLine - (6 + 1)
self.pdfCanvas.drawRightString(
self.width,
self.heightLine,
'Autenticação Mecânica'
)
self.pdfCanvas.drawString(
0,
(((linhaInicial + 1)*self.heightLine)) + self.deltaTitle,
'Cedente'
)
self.pdfCanvas.drawString(
self.width - (35*mm) - (30*mm) - (40*mm) + self.space,
(((linhaInicial + 1)*self.heightLine)) + self.deltaTitle,
'Agência/Código Cedente'
)
self.pdfCanvas.drawString(
self.width - (35*mm) - (30*mm) + self.space,
(((linhaInicial + 1)*self.heightLine)) + self.deltaTitle,
'Data Documento'
)
self.pdfCanvas.drawString(
self.width - (35*mm) + self.space,
(((linhaInicial + 1)*self.heightLine)) + self.deltaTitle,
'Vencimento'
)
self.pdfCanvas.drawString(
0,
(((linhaInicial + 0)*self.heightLine)) + self.deltaTitle,
'Sacado'
)
self.pdfCanvas.drawString(
self.width - (35*mm) - (30*mm) - (40*mm) + self.space,
(((linhaInicial + 0)*self.heightLine)) + self.deltaTitle,
'Nosso Número'
)
self.pdfCanvas.drawString(
self.width - (35*mm) - (30*mm) + self.space,
(((linhaInicial + 0)*self.heightLine)) + self.deltaTitle,
'N. do documento'
)
self.pdfCanvas.drawString(
self.width - (35*mm) + self.space,
(((linhaInicial + 0)*self.heightLine)) + self.deltaTitle,
'Valor Documento'
)
self.pdfCanvas.drawString(
0,
(((linhaInicial - 1)*self.heightLine-3*cm)) + self.deltaTitle,
'Demonstrativo'
)
# Values
self.pdfCanvas.setFont('Helvetica', 9 )
heighFont = 9 + 1;
self.pdfCanvas.drawString(
0 + self.space,
(((linhaInicial + 1)*self.heightLine)) + self.space,
boletoDados.cedente
)
self.pdfCanvas.drawString(
self.width - (35*mm) - (30*mm) - (40*mm) + self.space,
(((linhaInicial + 1)*self.heightLine)) + self.space,
boletoDados.agencia_conta_cedente
)
self.pdfCanvas.drawString(
self.width - (35*mm) - (30*mm) + self.space,
(((linhaInicial + 1)*self.heightLine)) + self.space,
boletoDados.data_documento.strftime('%d/%m/%Y')
)
self.pdfCanvas.drawString(
self.width - (35*mm) + self.space,
(((linhaInicial + 1)*self.heightLine)) + self.space,
boletoDados.data_vencimento.strftime('%d/%m/%Y')
)
valorDocumento = self._formataValorParaExibir(
boletoDados.valor_documento
)
self.pdfCanvas.drawString(
0 + self.space,
(((linhaInicial + 0)*self.heightLine)) + self.space,
boletoDados.sacado[0]
)
self.pdfCanvas.drawString(
self.width - (35*mm) - (30*mm) - (40*mm) + self.space,
(((linhaInicial + 0)*self.heightLine)) + self.space,
boletoDados.format_nosso_numero()
)
self.pdfCanvas.drawString(
self.width - (35*mm) - (30*mm) + self.space,
(((linhaInicial + 0)*self.heightLine)) + self.space,
boletoDados.numero_documento
)
self.pdfCanvas.drawString(
self.width - (35*mm) + self.space,
(((linhaInicial + 0)*self.heightLine)) + self.space,
valorDocumento
)
self.pdfCanvas.setFont('Helvetica', 9 )
demonstrativo = boletoDados.demonstrativo[0:25]
for i in range(len(demonstrativo)):
self.pdfCanvas.drawString(
2*self.space,
(-3*cm+((linhaInicial - 1)*self.heightLine)) - (i * heighFont),
demonstrativo[i]
)
self.pdfCanvas.setFont('Helvetica', 9 )
self.pdfCanvas.restoreState();
return (self.width, ((linhaInicial+2)*self.heightLine));
def drawHorizontalCorteLine(self, x, y, width ):
self.pdfCanvas.saveState();
self.pdfCanvas.translate( x, y );
self.pdfCanvas.setLineWidth(1)
self.pdfCanvas.setDash(1,2)
self.__horizontalLine(0, 0, width)
self.pdfCanvas.restoreState();
def drawVerticalCorteLine(self, x, y, height ):
self.pdfCanvas.saveState();
self.pdfCanvas.translate( x, y );
self.pdfCanvas.setLineWidth(1)
self.pdfCanvas.setDash(1,2)
self.__verticalLine(0, 0, height)
self.pdfCanvas.restoreState();
def drawReciboCaixa(self, boletoDados, x, y ):
self.pdfCanvas.saveState();
self.pdfCanvas.translate( x, y );
# De baixo para cima posicao 0,0 esta no canto inferior esquerdo
self.pdfCanvas.setFont('Helvetica', self.fontSizeTitle )
y = 1.5*self.heightLine;
self.pdfCanvas.drawRightString(
self.width,
(1.5*self.heightLine)+self.deltaTitle-1,
'Autenticação Mecânica / Ficha de Compensação'
)
# Primeira linha depois do codigo de barra
y += self.heightLine;
self.pdfCanvas.setLineWidth(2)
self.__horizontalLine( 0, y, self.width )
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y+self.space, 'Código de baixa'
)
self.pdfCanvas.drawString(0, y + self.space, 'Sacador / Avalista' )
y += self.heightLine
self.pdfCanvas.drawString(0, y + self.deltaTitle, 'Sacado' )
sacado = boletoDados.sacado
# Linha grossa dividindo o Sacado
y += self.heightLine
self.pdfCanvas.setLineWidth(2)
self.__horizontalLine( 0, y, self.width )
self.pdfCanvas.setFont('Helvetica', self.fontSizeValue )
for i in range(len(sacado)):
self.pdfCanvas.drawString(
15*mm,
(y - 10) - (i * self.deltaFont),
sacado[i]
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeTitle )
# Linha vertical limitando todos os campos da direita
self.pdfCanvas.setLineWidth(1)
self.__verticalLine( self.width - (45*mm), y, 9 * self.heightLine )
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y + self.deltaTitle,
'(=) Valor cobrado'
)
# Campos da direita
y += self.heightLine
self.__horizontalLine( self.width - (45*mm), y, 45*mm )
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y + self.deltaTitle,
'(+) Outros acréscimos'
)
y += self.heightLine
self.__horizontalLine( self.width - (45*mm), y, 45*mm )
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y + self.deltaTitle,
'(+) Mora/Multa'
)
y += self.heightLine
self.__horizontalLine( self.width - (45*mm), y, 45*mm )
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y + self.deltaTitle,
'(-) Outras deduções'
)
y += self.heightLine
self.__horizontalLine( self.width - (45*mm), y, 45*mm )
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y + self.deltaTitle,
'(-) Descontos/Abatimentos'
)
self.pdfCanvas.drawString(
0,
y + self.deltaTitle,
'Instruções (texto de responsabilidade do cedente)'
)
self.pdfCanvas.setFont('Helvetica', 9)
instrucoes = boletoDados.instrucoes
for i in range(len(instrucoes)):
self.pdfCanvas.drawString(
2*self.space,
y - (i * self.deltaFont),
instrucoes[i]
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeTitle )
# Linha horizontal com primeiro campo Uso do Banco
y += self.heightLine
self.__horizontalLine( 0, y, self.width )
self.pdfCanvas.drawString(0, y + self.deltaTitle, 'Uso do banco' )
self.__verticalLine((30)*mm, y, 2*self.heightLine)
self.pdfCanvas.drawString(
(30*mm)+self.space,
y + self.deltaTitle,
'Carteira'
)
self.__verticalLine((30+20)*mm, y, self.heightLine)
self.pdfCanvas.drawString(
((30+20)*mm)+self.space,
y + self.deltaTitle,
'Espécie'
)
self.__verticalLine(
(30+20+20)*mm,
y,
2*self.heightLine
)
self.pdfCanvas.drawString(
((30+40)*mm)+self.space,
y + self.deltaTitle,
'Quantidade'
)
self.__verticalLine(
(30+20+20+20+20)*mm, y, 2*self.heightLine)
self.pdfCanvas.drawString(
((30+40+40)*mm)+self.space, y + self.deltaTitle, 'Valor' )
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y + self.deltaTitle,
'(=) Valor documento'
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeValue )
self.pdfCanvas.drawString(
(30*mm)+self.space,
y + self.space,
boletoDados.carteira
)
self.pdfCanvas.drawString(
((30+20)*mm)+self.space,
y + self.space,
boletoDados.especie
)
self.pdfCanvas.drawString(
((30+20+20)*mm)+self.space,
y + self.space,
boletoDados.quantidade
)
valor = self._formataValorParaExibir(boletoDados.valor)
self.pdfCanvas.drawString(
((30+20+20+20+20)*mm)+self.space,
y + self.space,
valor
)
valorDocumento = self._formataValorParaExibir(
boletoDados.valor_documento
)
self.pdfCanvas.drawRightString(
self.width - 2*self.space,
y + self.space,
valorDocumento
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeTitle )
# Linha horizontal com primeiro campo Data documento
y += self.heightLine
self.__horizontalLine( 0, y, self.width )
self.pdfCanvas.drawString(
0,
y + self.deltaTitle,
'Data do documento'
)
self.pdfCanvas.drawString(
(30*mm)+self.space,
y + self.deltaTitle,
'N. do documento'
)
self.pdfCanvas.drawString(
((30+40)*mm)+self.space,
y + self.deltaTitle,
'Espécie doc'
)
self.__verticalLine(
(30+20+20+20)*mm,
y,
self.heightLine
)
self.pdfCanvas.drawString(
((30+40+20)*mm)+self.space,
y + self.deltaTitle,
'Aceite'
)
self.pdfCanvas.drawString(
((30+40+40)*mm)+self.space,
y + self.deltaTitle,
'Data processamento'
)
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y + self.deltaTitle,
'Nosso número'
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeValue )
self.pdfCanvas.drawString(
0,
y + self.space,
boletoDados.data_documento.strftime('%d/%m/%Y')
)
self.pdfCanvas.drawString(
(30*mm)+self.space,
y + self.space,
boletoDados.numero_documento
)
self.pdfCanvas.drawString(
((30+40)*mm)+self.space,
y + self.space,
boletoDados.especie_documento
)
self.pdfCanvas.drawString(
((30+40+20)*mm)+self.space,
y + self.space,
boletoDados.aceite
)
self.pdfCanvas.drawString(
((30+40+40)*mm)+self.space,
y + self.space,
boletoDados.data_processamento.strftime('%d/%m/%Y')
)
self.pdfCanvas.drawRightString(
self.width - 2*self.space,
y + self.space,
boletoDados.format_nosso_numero()
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeTitle )
# Linha horizontal com primeiro campo Cedente
y += self.heightLine
self.__horizontalLine( 0, y, self.width )
self.pdfCanvas.drawString(0, y + self.deltaTitle, 'Cedente' )
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y + self.deltaTitle,
'Agência/Código cedente'
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeValue )
self.pdfCanvas.drawString(0, y + self.space, boletoDados.cedente )
self.pdfCanvas.drawRightString(
self.width - 2*self.space,
y + self.space,
boletoDados.agencia_conta_cedente
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeTitle )
# Linha horizontal com primeiro campo Local de Pagamento
y += self.heightLine
self.__horizontalLine( 0, y, self.width )
self.pdfCanvas.drawString(
0,
y + self.deltaTitle,
'Local de pagamento'
)
self.pdfCanvas.drawString(
self.width - (45*mm) + self.space,
y + self.deltaTitle,
'Vencimento'
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeValue )
self.pdfCanvas.drawString(
0,
y + self.space,
boletoDados.local_pagamento
)
self.pdfCanvas.drawRightString(
self.width - 2*self.space,
y + self.space,
boletoDados.data_vencimento.strftime('%d/%m/%Y')
)
self.pdfCanvas.setFont('Helvetica', self.fontSizeTitle )
# Linha grossa com primeiro campo logo tipo do banco
self.pdfCanvas.setLineWidth(3)
y += self.heightLine
self.__horizontalLine( 0, y, self.width )
self.pdfCanvas.setLineWidth(2)
self.__verticalLine(40*mm, y, self.heightLine) # Logo Tipo
self.__verticalLine(60*mm, y, self.heightLine) # Numero do Banco
if boletoDados.logo_image_path:
self.pdfCanvas.drawImage(
boletoDados.logo_image_path,
0,
y + self.space + 1,
40*mm,
self.heightLine,
preserveAspectRatio=True,
anchor='sw'
)
self.pdfCanvas.setFont('Helvetica-Bold', 18 )
self.pdfCanvas.drawCentredString(
50*mm,
y + 2*self.space,
boletoDados.codigo_dv_banco
)
self.pdfCanvas.setFont('Helvetica-Bold', 11)
self.pdfCanvas.drawRightString(
self.width,
y + 2*self.space,
boletoDados.linha_digitavel
)
# Codigo de barras
self._codigoBarraI25(boletoDados.barcode, 2*self.space, 0)
self.pdfCanvas.restoreState();
return (self.width, (y+self.heightLine) )
def drawBoletoCarneDuplo(self, boletoDados1, boletoDados2 ):
y = 5*mm
d = self.drawBoletoCarne(boletoDados1, y)
y += d[1] + 6*mm
#self.drawHorizontalCorteLine(0, y, d[0])
y += 7*mm
if( boletoDados2):
self.drawBoletoCarne(boletoDados2, y)
def drawBoletoCarne(self, boletoDados, y ):
x = 15*mm
d = self.drawReciboSacadoCanhoto(boletoDados, x, y)
x += d[0] + 8*mm
self.drawVerticalCorteLine(x, y, d[1])
x += 8*mm
d = self.drawReciboCaixa(boletoDados, x, y)
x += d[0]
return (x,d[1])
def drawBoleto(self, boletoDados ):
x = 3.5*mm
y = 0
#y += 2*mm
#self.drawHorizontalCorteLine(x, y, self.width)
y += 1*mm
d = self.drawReciboCaixa(boletoDados, x, y)
y += d[1] + (25*mm)
self.drawHorizontalCorteLine(x, y, self.width)
y += 20*mm
d = self.drawReciboSacado(boletoDados, x, y)
y += d[1]
return (self.width,y)
def nextPage(self):
self.pdfCanvas.showPage()
def save(self):
self.pdfCanvas.save()
def __horizontalLine( self, x, y, width ):
self.pdfCanvas.line( x, y, x+width, y )
def __verticalLine( self, x, y, width ):
self.pdfCanvas.line( x, y, x, y+width )
def __centreText(self, x, y, text ):
self.pdfCanvas.drawCentredString( self.refX+x, self.refY+y, text )
def __rightText(self, x, y, text ):
self.pdfCanvas.drawRightString( self.refX+x, self.refY+y, text )
def _formataValorParaExibir(self, nfloat):
if nfloat:
txt = nfloat
txt = txt.replace( '.', ',' )
else:
txt = ""
return txt
def _codigoBarraI25(self, num, x, y ):
# http://en.wikipedia.org/wiki/Interleaved_2_of_5
altura = 13 * mm
comprimento = 103 * mm
#tracoFino = 0.254320987654 * mm #Tamanho correto aproximado
tracoFino = 0.3 * mm #Tamanho correto aproximado
bc = I2of5(num,
barWidth = tracoFino,
ratio = 3,
barHeight = altura,
bearers = 0,
quiet = 0,
checksum = 0
)
# Recalcula o tamanho do tracoFino para que o cod de barras tenha o
# comprimento correto
tracoFino = (tracoFino * comprimento)/bc.width
bc.__init__(num,
barWidth = tracoFino
)
bc.drawOn(self.pdfCanvas, x, y)
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,431 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/bank/real.py | from pyboleto.data import BoletoData
import os.path
class BoletoReal( BoletoData ):
def __init__(self, *args, **kwargs):
super(BoletoReal , self).__init__(*args, **kwargs)
self.codigo_banco = "356"
self.logo_image_path = os.path.dirname(__file__) + \
"/../media/logo_bancoreal.jpg"
@property
def agencia_conta_cedente(self):
dv = self.digitao_cobranca
s = "%s/%s-%s" % (self.agencia_cedente, self.conta_cedente, dv)
return s
@property
def digitao_cobranca(self):
num = "%s%s%s" % (
self.nosso_numero,
self.agencia_cedente,
self.conta_cedente
)
dv = self.modulo10(num)
return dv
def calculate_dv_barcode(self, line):
dv = self.modulo11(line)
return dv
@property
def barcode(self):
num = "%3s%1s%1s%4s%10s%4s%7s%1s%13s" % ( \
self.codigo_banco, \
self.moeda,
'X',
self.fator_vencimento,
self.formata_valor(self.valor_documento,10),
self.agencia_cedente,
self.conta_cedente,
self.digitao_cobranca,
self.nosso_numero,
)
dv = self.calculate_dv_barcode(num.replace('X', '', 1))
num = num.replace('X', str(dv), 1)
return num
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,432 | arthurfurlan/pyboleto | refs/heads/master | /setup.py | # -*- coding: utf-8 -*-
from setuptools import setup, find_packages
setup(
name = 'pyboleto',
version = __import__('pyboleto').__version__,
author = 'Eduardo Cereto Carvalho',
author_email = 'eduardocereto@gmail.com',
url = 'https://bitbucket.org/eduardo.cereto/pyboleto/',
packages = find_packages(),
include_package_data = True,
zip_safe = False,
#install_requires = [
# 'reportlab>=2.5',
#],
provides = [
'pyboleto'
],
license = 'BSD',
description = 'Python Library to create boletos',
long_description = open('README.rst', 'r').read(),
download_url = 'http://pypi.python.org/pypi/pyboleto',
entry_points = {
'console_scripts':[
'print_boleto_data = pyboleto.scripts.print_sample_data:print_test',
],
},
classifiers = [
'Development Status :: 2 - Pre-Alpha',
'Operating System :: OS Independent',
'Framework :: Django',
'Intended Audience :: Developers',
'Intended Audience :: Financial and Insurance Industry',
'License :: OSI Approved :: BSD License',
'Natural Language :: Portuguese (Brazilian)',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Topic :: Office/Business :: Financial',
'Topic :: Software Development :: Libraries :: Python Modules',
],
)
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,433 | arthurfurlan/pyboleto | refs/heads/master | /pyboleto/data.py | # -*- coding: utf-8 -*-
import datetime
import re
from decimal import Decimal
class BoletoException(Exception):
def __init__(self, message ):
Exception.__init__(self, message)
def custom_property(name, num_length):
'''
Function to create properties on boleto
It accepts a number with or without a DV and zerofills it
'''
internal_attr = '_%s'%name
def _set_attr(self,val):
val = val.split('-')
if len(val) is 1:
val[0] = str(val[0]).zfill(num_length)
setattr(self, internal_attr, ''.join(val))
elif len(val) is 2:
val[0] = str(val[0]).zfill(num_length)
setattr(self, internal_attr, '-'.join(val))
else:
raise BoletoException('Wrong value format')
return property(
lambda self: getattr(self, internal_attr),
_set_attr,
lambda self: delattr(self, internal_attr),
name
)
class BoletoData(object):
def __init__(self, *args, **kwargs):
self.aceite = "N"
self.agencia_cedente = ""
self.carteira = ""
self.cedente = ""
self.codigo_banco = ""
self.conta_cedente = ""
self.data_documento = ""
self.data_processamento = datetime.date.today()
self.data_vencimento = ""
self.demonstrativo = []
self.especie = "R$"
self.especie_documento = ""
self.instrucoes = []
self.local_pagamento = "Pagável em qualquer banco até o vencimento"
self.logo_image_path = ""
self.moeda = "9"
self.numero_documento = ""
self.quantidade = ""
self.sacado_nome = ""
self.sacado_cidade = ""
self.sacado_uf = ""
self.sacado_endereco = ""
self.sacado_bairro = ""
self.sacado_cep = ""
@property
def barcode(self):
'''
Returns string used to generate barcodes
It should be implemented by derived class
'''
raise NotImplementedError(
'This method has not been implemented by this class'
)
@property
def dv_nosso_numero(self):
'''
Returns nosso número DV
It should be implemented by derived class
'''
raise NotImplementedError(
'This method has not been implemented by this class'
)
def calculate_dv_barcode(self, line):
'''
Calculates de DV for barcode
It should be implemented by derived class
'''
resto2 = self.modulo11(line,9,1)
if resto2 in [0, 1, 10]:
dv = 1
else:
dv = 11 - resto2
return dv
def format_nosso_numero(self):
'''
Return Formatted Nosso Número
It should be implemented by derived class
'''
return self.nosso_numero
nosso_numero = custom_property('nosso_numero', 13)
agencia_cedente = custom_property('agencia_cedente', 4)
conta_cedente = custom_property('conta_cedente', 7)
def _get_valor(self):
try:
return "%.2f" % self._valor
except AttributeError:
pass
def _set_valor(self, val):
if type(val) is Decimal:
self._valor = val
else:
self._valor = Decimal(str(val), 2)
valor = property(_get_valor, _set_valor)
def _get_valor_documento(self):
try:
return "%.2f" % self._valor_documento
except AttributeError:
pass
def _set_valor_documento(self, val):
if type(val) is Decimal:
self._valor_documento = val
else:
self._valor_documento = Decimal(str(val), 2)
valor_documento = property(
_get_valor_documento,
_set_valor_documento
)
def _instrucoes_get(self):
try:
return self._instrucoes
except AttributeError:
pass
def _instrucoes_set(self, list_inst):
if len(list_inst) > 7:
raise BoletoException(
u'Número de linhas de instruções maior que 7')
for line in list_inst:
if len(line) > 90:
raise BoletoException(
u'Linha de instruções possui mais que 90 caracteres')
self._instrucoes = list_inst
instrucoes = property(_instrucoes_get, _instrucoes_set)
def _demonstrativo_get(self):
try:
return self._demonstrativo
except AttributeError:
pass
def _demonstrativo_set(self,list_dem):
if len(list_dem) > 12:
raise BoletoException(
u'Número de linhas de demonstrativo maior que 12')
for line in list_dem:
if len(line) > 90:
raise BoletoException(
u'Linha de demonstrativo possui mais que 90 caracteres')
self._demonstrativo = list_dem
demonstrativo = property(_demonstrativo_get, _demonstrativo_set)
def _sacado_get(self):
if not hasattr(self, '_sacado'):
self.sacado = [
self.sacado_nome,
self.sacado_endereco,
'%s - %s - %s - %s' % (
self.sacado_bairro,
self.sacado_cidade,
self.sacado_uf,
self.sacado_cep
)
]
return self._sacado
def _sacado_set(self, list_sacado):
if len(list_sacado) > 3:
raise BoletoException(u'Número de linhas do sacado maior que 3')
for line in list_sacado:
if len(line) > 80:
raise BoletoException(
u'Linha de sacado possui mais que 80 caracteres')
self._sacado = list_sacado
sacado = property(_sacado_get, _sacado_set)
@property
def fator_vencimento(self):
date_ref = datetime.date(2000,7,3) # Fator = 1000
delta = self.data_vencimento - date_ref
fator = delta.days + 1000
return fator
@property
def agencia_conta_cedente(self):
return "%s/%s" % (self.agencia_cedente, self.conta_cedente)
@property
def codigo_dv_banco(self):
cod = "%s-%s" % (self.codigo_banco, self.modulo11(self.codigo_banco))
return cod
@property
def linha_digitavel(self):
'''
Monta a linha que o cliente pode utilizar para digitar se o código
de barras não puder ser lido
Posição Conteúdo
1 a 3 Número do banco
4 Código da Moeda - 9 para Real
5 Digito verificador do Código de Barras
6 a 19 Valor (12 inteiros e 2 decimais)
20 a 44 Campo Livre definido por cada banco
'''
linha = self.barcode
if not linha:
BoletoException("Boleto doesn't have a barcode")
p1 = linha[0:4]
p2 = linha[19:24]
p3 = self.modulo10("%s%s"%(p1,p2))
p4 = "%s%s%s" %(p1,p2,p3)
p5 = p4[0:5]
p6 = p4[5:]
campo1 = "%s.%s" %(p5,p6)
p1 = linha[24:34]
p2 = self.modulo10(p1)
p3 = "%s%s" %(p1,p2)
p4 = p3[0:5]
p5 = p3[5:]
campo2 = "%s.%s" %(p4,p5)
p1 = linha[34:44]
p2 = self.modulo10(p1)
p3 = "%s%s" %(p1,p2)
p4 = p3[0:5]
p5 = p3[5:]
campo3 = "%s.%s" %(p4,p5)
campo4 = linha[4]
campo5 = linha[5:19]
return "%s %s %s %s %s" %(campo1,campo2,campo3,campo4,campo5)
@staticmethod
def formata_numero(numero, tamanho):
if len(numero) > tamanho:
raise BoletoException(
u'Tamanho em caracteres do número está maior que o permitido' )
return numero.zfill(tamanho)
@staticmethod
def formata_texto(texto, tamanho):
if len(texto) > tamanho:
raise BoletoException(
u'Tamanho em caracteres do texto está maior que o permitido' )
return texto.ljust(tamanho)
def formata_valor(self,nfloat, tamanho):
try:
txt = nfloat.replace( '.', '' )
txt = self.formata_numero(txt, tamanho)
return txt
except AttributeError:
pass
@staticmethod
def modulo10(num):
soma = 0
peso = 2
for i in range(len(num)-1,-1,-1):
parcial = int(num[i]) * peso
if parcial > 9:
s = "%d" % parcial
parcial = int(s[0])+int(s[1])
soma += parcial
if peso == 2:
peso = 1
else:
peso = 2
resto10 = soma % 10
if resto10 == 0:
modulo10 = 0
else:
modulo10 = 10 - resto10
return modulo10
@staticmethod
def modulo11(num,base=9,r=0):
soma=0
fator=2
for i in range(len(str(num))).__reversed__():
parcial10 = int(num[i]) * fator
soma += parcial10
if fator == base:
fator = 1
fator += 1
if r == 0:
soma = soma * 10
digito = soma % 11
if digito == 10:
digito = 0
return digito
if r == 1:
resto = soma % 11
return resto
| {"/pyboleto/bank/bradesco.py": ["/pyboleto/data.py"], "/pyboleto/tests/test_banco_bradesco.py": ["/pyboleto/bank/bradesco.py"], "/pyboleto/tests/test_banco_real.py": ["/pyboleto/bank/real.py"], "/pyboleto/tests/test_banco_caixa.py": ["/pyboleto/bank/caixa.py"], "/pyboleto/bank/caixa.py": ["/pyboleto/data.py"], "/pyboleto/bank/real.py": ["/pyboleto/data.py"]} |
63,446 | xkapil/redis-flask-demo | refs/heads/master | /api/restaurant/restaurant.py | import uuid
from flask_injector import inject
from services.redis import Redis
class Restaurant(object):
@inject
def post(self, restaurant: dict, lookup:Redis=None) -> dict:
""" Store in Redis service """
# Generates a unique ID for the restaurant
id_str = str(uuid.uuid4())
restaurant["id"] = id_str
lookup.create(id_str, restaurant)
return restaurant, 201
@inject
def get(self, id: str, lookup:Redis=None) -> dict:
""" Lookup in Redis service """
restaurant = lookup.get(id)
return restaurant, 200
class_instance = Restaurant() | {"/api/restaurant/restaurant.py": ["/services/redis.py"], "/app.py": ["/services/redis.py"]} |
63,447 | xkapil/redis-flask-demo | refs/heads/master | /app.py | import os
import connexion
from services.redis import Redis
from injector import Binder
from flask_injector import FlaskInjector
from connexion.resolver import RestyResolver
def configure(binder: Binder) -> Binder:
binder.bind(Redis, Redis(os.environ['REDIS_HOST'], os.environ['REDIS_PORT']))
return binder
if __name__ == '__main__':
app = connexion.App(__name__, specification_dir='swagger/')
app.add_api('rest.yaml', resolver=RestyResolver('api'))
FlaskInjector(app=app.app, modules=[configure])
app.run(port=9090)
| {"/api/restaurant/restaurant.py": ["/services/redis.py"], "/app.py": ["/services/redis.py"]} |
63,448 | xkapil/redis-flask-demo | refs/heads/master | /services/redis.py | import redis
class Redis(object):
def __init__(self, host: str, port: int):
self.host = host
self.port = port
self.client = None
def get_client(self) -> redis.StrictRedis:
if self.client is None:
self.client = redis.StrictRedis(self.host, self.port, db=0)
return self.client
def create(self, key, value):
redis_client = self.get_client()
if not redis_client.exists(key):
redis_client.set(key, value)
return True
def get(self, key):
redis_client = self.get_client()
if redis_client.exists(key):
return redis_client.get(key)
return None
| {"/api/restaurant/restaurant.py": ["/services/redis.py"], "/app.py": ["/services/redis.py"]} |
63,449 | luaroncrew/university_agenda_to_apple_calendar | refs/heads/main | /main.py | import logging
import os
from dotenv import load_dotenv
from openpyxl import load_workbook
from mail_exporter import send_calendar
from settings import SETTINGS
from extractor import read_agenda
load_dotenv()
# settings
SENDER = os.getenv('EMAIL_LOGIN')
DESTINATION = os.getenv('DESTINATION')
PASSWORD = os.getenv('EMAIL_PASSWORD')
def get_setup() -> str:
"""
reading agenda setup and returns it as string
"""
logging.info('getting setup')
setup_file = open('vcalendar_setup.ics', mode='r')
setup = setup_file.read() + '\n'
setup_file.close()
return setup
def get_events(sheet) -> list:
logging.info('getting events')
# if user's choice is extracting events from excel file, reading events from excel
if SETTINGS['EXTRACTING_FROM_FILE']:
return read_agenda(sheet)
# if we want to add events manually, this part of function is used
events = []
count = int(input('enter the amount of events you want to add'))
for k in range(count):
event = dict()
event['title'] = str(input('enter the name of new event'))
event['date'] = str(input('enter the date of event like this <YYYYMMDD> 20210925'))
event['start_time'] = str(input('enter the start time like this <HHMMSS> 093000'))
event['end_time'] = str(input('enter the start time like this <HHMMSS> 153000'))
events.append(event)
logging.info('events extracted')
logging.info(f'events:{events}')
return events
def write_events(events: list, calendar):
"""
takes list of events and calendar file then writes every event in appropriate way to file
"""
for event in events:
location = event["location"]
vevent_string = str()
vevent_string += 'BEGIN:VEVENT\n'
vevent_string += 'DTSTAMP:20210904T194914Z\n' # here we have to add a custom date
vevent_string += f'DTSTART;TZID=Europe/Paris:{event["date"]}T{event["start_time"]}\n'
vevent_string += f'DTEND;TZID=Europe/Paris:{event["date"]}T{event["end_time"]}\n'
vevent_string += f'SUMMARY:{event["title"]}\n'
if location is not None:
vevent_string += f'LOCATION:{location}\n'
vevent_string += 'END:VEVENT\n'
calendar.write(vevent_string)
logging.info(f'event {event["title"]} successfully writen')
def create_calendar(setup, calendar_name, events):
logging.info(f'creating calendar {calendar_name}')
# creating new calendar file
calendar = open(calendar_name + '.ics', mode='w')
# write setup to calendar
calendar.write(setup)
# writing events
write_events(events, calendar)
# writing closing calendar tag to file before returning it
calendar.write('END:VCALENDAR\n')
# closing calendar, exporting it and deleting temp calendar file
calendar.close()
# sending calendar to mail from env file
send_calendar(destination=DESTINATION, sender=SENDER, password=PASSWORD, filename=calendar_name)
os.remove(calendar_name + '.ics')
def main():
# loading file
wb = load_workbook('test_example_3.xlsx', data_only=True)
sh = wb.worksheets[0]
logging.basicConfig(level=logging.INFO)
logging.info('building started')
# writing file and sending
setup = get_setup()
events = get_events(sh)
create_calendar(setup, 'agenda', events=events)
if __name__ == '__main__':
main()
| {"/main.py": ["/mail_exporter.py", "/settings.py", "/extractor.py"], "/test_extractor.py": ["/extractor.py"], "/extractor.py": ["/settings.py"]} |
63,450 | luaroncrew/university_agenda_to_apple_calendar | refs/heads/main | /mail_exporter.py | import logging
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
def send_calendar(sender, destination, password, filename):
msg = MIMEMultipart('Here is your agenda for the next week')
msg['Subject'] = 'agenda'
msg['From'] = sender
msg['To'] = destination
attachment = open(filename + '.ics', "rb")
p = MIMEApplication(attachment.read(), _subtype="ics")
p.add_header(f'Content-Disposition', f"attachment; filename={filename}.ics")
msg.attach(p)
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login(sender, password)
server.sendmail(sender, destination, msg.as_string())
logging.info('message sent successfully')
| {"/main.py": ["/mail_exporter.py", "/settings.py", "/extractor.py"], "/test_extractor.py": ["/extractor.py"], "/extractor.py": ["/settings.py"]} |
63,451 | luaroncrew/university_agenda_to_apple_calendar | refs/heads/main | /test_extractor.py | from openpyxl import load_workbook
from extractor import read_agenda
# setting up testing files
wb1 = load_workbook('test_example_1.xlsx', data_only=True)
worksheet_1 = wb1.worksheets[0]
wb2 = load_workbook('test_example_2.xlsx', data_only=True)
worksheet_2 = wb2.worksheets[0]
wb3 = load_workbook('test_example_3.xlsx', data_only=True)
worksheet_3 = wb3.worksheets[0]
class TestReadAgendaEventsCount:
"""
checking if reading algorithm returns all the events
"""
def test_worksheet_1(self):
assert len(read_agenda(worksheet_1)) == 16
def test_worksheet_2(self):
assert len(read_agenda(worksheet_2)) == 15
def test_worksheet_3(self):
assert len(read_agenda(worksheet_3)) == 18
| {"/main.py": ["/mail_exporter.py", "/settings.py", "/extractor.py"], "/test_extractor.py": ["/extractor.py"], "/extractor.py": ["/settings.py"]} |
63,452 | luaroncrew/university_agenda_to_apple_calendar | refs/heads/main | /extractor.py | import datetime
from openpyxl import load_workbook
import settings
# settings
weekday_letters = settings.WEEKDAY_LETTERS
possible_cabinet_numbers = settings.POSSIBLE_CABINET_NUMBERS
all_group_names = settings.ALL_GROUP_NAMES
groups_to_exclude = settings.get_groups_to_exclude()
START_TIME = 8
wb = load_workbook('test_example_3.xlsx', data_only=True)
sh = wb.worksheets[0]
def get_cells_letter(cell_range):
"""
supporting function for better sorting dates, returns cell's range letter index.
if it contains 2 letters, returns 'Z' + letter to release sorting
"""
cell_letter = str()
range_first_coordinate = str(cell_range).split(':')[0]
for letter in range_first_coordinate:
if letter.isalpha():
cell_letter += letter
if len(cell_letter) == 2:
cell_letter = 'Z' + cell_letter[1]
return cell_letter
def lesson_in_my_agenda(lesson) -> bool:
"""
Filtering function.
if cell's content is your lesson, returns True
"""
content = lesson.split()
for group in groups_to_exclude:
if group in content:
return False
return True
def is_users_lesson(content) -> bool:
"""
if cell's content looks like a lesson, check by another function if lesson is for
user's group. Finally it will return true or false whether it must be in user's agenda
or not
"""
# checking if it's a lesson
elements = content.split()
for element in elements:
if element in ['TD', 'TP', 'CM']:
return lesson_in_my_agenda(content)
if len(content.split()) >= 6:
return lesson_in_my_agenda(content)
return False
def stringify_date(date: str) -> str:
"""
returns date in appropriate way for agenda
"""
date_elements = date.split('/')
string_date = date_elements[2] + date_elements[1] + date_elements[0]
return string_date
def stringify_time(time) -> str:
"""
returns time in appropriate way for agenda
"""
hours = str(int(time))
if len(hours) == 1:
hours = '0' + hours
minutes = '30' if time % 1 != 0 else '00'
return hours + minutes + '00'
def get_date(cell_range, dates):
"""
comparing merged cell's first letter to weekday letters from settings,
if date is found for the letter, return date connected to the cell
"""
# getting first letter
cell_main_letter = str(cell_range)[0]
# adding second letter if exists
if str(cell_range)[1].isalpha():
cell_main_letter += str(cell_range)[1]
# filtering
for index, letters in enumerate(weekday_letters):
if cell_main_letter in letters:
return dates[index]
def extract_cabinet_number(lesson: str):
"""
takes merged cell's text as param and returns the cabinet number from it by filtering or None if
it doesn't exist
"""
for element in lesson.split():
# filtering
if len(element.split('-')) == 2:
if len(element.split('-')[0]) == 1:
if len(element.split('-')[1]) == 3:
return element
if element in possible_cabinet_numbers:
return element
return None
def read_agenda(sheet) -> list:
"""
reading excel files to extract events from them,
returns list of dicts containing event information:
time, summary, date
"""
dates_ranges = []
lesson_ranges = []
# getting ranges to treat
ranges = sheet.merged_cells.ranges
# filtering ranges
for cell_range in ranges:
coordinate = str(cell_range).split(':')
content = sheet[coordinate[0]].value
if content is None:
continue
# checking if value is number
if isinstance(content, int):
continue
# checking if lesson is for my group
if is_users_lesson(content):
lesson_ranges.append(cell_range)
# checking if cell range is date
if (len(content.split('/')) >= 3) and (len(content.split(' ')) < 2):
dates_ranges.append(cell_range)
# making datetime objects out of str-dates to sort and then revert
dates = []
for cell_range in dates_ranges:
dates.append(sheet[str(cell_range).split(':')[0]].value)
dates = [datetime.datetime.strptime(date, '%d/%m/%Y') for date in dates]
dates.sort(reverse=True)
dates = [date.strftime('%d/%m/%Y') for date in dates]
# sometimes there are some additional dates_ranges in agenda, they must be deleted
if len(dates) > 5:
for k in range(len(dates) - 5):
dates.pop()
for cell_range in dates_ranges:
if sheet[str(cell_range).split(':')[0]].value not in dates:
dates_ranges.remove(cell_range)
# to avoid mixing dates we have to sort the cells
dates_ranges = sorted(dates_ranges, key=get_cells_letter)
events = []
# reading ranges with their times
for event_range in lesson_ranges:
read_cell_indexes = str(event_range).split(':')
# reading start time cell index
start_time = str()
for element in read_cell_indexes[0]:
if element.isdigit():
start_time += element
# reading end time cell index
end_time = str()
for element in read_cell_indexes[1]:
if element.isdigit():
end_time += element
start_time = START_TIME + (int(start_time) - 8) / 2
end_time = START_TIME + (int(end_time) - 8) / 2 + 0.5
event_start_time = stringify_time(start_time)
event_end_time = stringify_time(end_time)
# reading date
date_cell = get_date(event_range, dates_ranges)
date = sheet[str(date_cell).split(':')[0]].value
event_date = stringify_date(date)
contents = sheet[read_cell_indexes[0]].value
# getting summary
summary = contents.split('\n')[0]
# extracting cabinet number
location = extract_cabinet_number(contents)
# TODO: write a function that extracts teacher's name
event = {
'date': event_date,
'start_time': event_start_time,
'end_time': event_end_time,
'title': summary,
'location': location
}
events.append(event)
return events
if __name__ == '__main__':
print(read_agenda(sh))
| {"/main.py": ["/mail_exporter.py", "/settings.py", "/extractor.py"], "/test_extractor.py": ["/extractor.py"], "/extractor.py": ["/settings.py"]} |
63,453 | luaroncrew/university_agenda_to_apple_calendar | refs/heads/main | /settings.py | # settings
SETTINGS = {
'EXTRACTING_FROM_FILE': True,
'DEBUG': True,
}
# this variable contains 5 lists of letters, each list for one weekday
WEEKDAY_LETTERS = [
list('BCDEFGHI'),
list('JKLMNOPQ'),
list('RSTUVWXY'),
['Z', 'AA', 'AB', 'AC', 'AD', 'AE', 'AF', 'AG'],
['AH', 'AI', 'AJ', 'AK', 'AL', 'AM', 'AN', 'AO']
]
POSSIBLE_CABINET_NUMBERS = [
'Am1', 'Am2'
]
ALL_GROUP_NAMES = [
'STID-1-1',
'STID-1-2',
'STID-1-11',
'STID-1-12',
'STID-1-21',
'STID-1-22',
'STID-1-ECO-1',
'STID-1-ECO-2',
'STID-1-MATH',
'STID-1-INFO-1',
'STID-1-INFO-2'
]
USERS_GROUPS = [
'STID-1-2',
'STID-1-21',
'STID-1-ECO-2',
'STID-1-MATH'
]
def get_groups_to_exclude():
groups_to_exclude = ALL_GROUP_NAMES
[groups_to_exclude.remove(item) for item in USERS_GROUPS]
return groups_to_exclude
| {"/main.py": ["/mail_exporter.py", "/settings.py", "/extractor.py"], "/test_extractor.py": ["/extractor.py"], "/extractor.py": ["/settings.py"]} |
63,456 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/celery_tasks/sms/tasks.py | from celery_tasks.main import celery_app
# from celery_tasks.sms.yuntongxun import constants
# from celery_tasks.sms.yuntongxun.sms import CCP
from meiduo_mall.libs.yuntongxun.sms import CCP
from meiduo_mall.apps.verifications import constants
@celery_app.task(name='ccp_send_sms_code')
def ccp_send_sms_code(mobile, sms_code):
CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES // 60], 1)
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,457 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/verifications/views.py | from django.shortcuts import render
from django.views import View
from django_redis import get_redis_connection
from django import http
from random import randint
import logging
from meiduo_mall.utils.response_code import RETCODE
from meiduo_mall.libs.captcha.captcha import captcha
# from meiduo_mall.libs.yuntongxun.sms import CCP
from . import constants
from celery_tasks.sms.tasks import ccp_send_sms_code
logger = logging.getLogger('django')
class ImageCodeView(View):
"""
def get(self, request, uuid):
# 生成图片验证码
# name: 标识验证码校验唯一值
# text: 验证码的字符串数据
# image = 验证码的二进制数据
name, text, image = captcha.generate_captcha()
# 连接数据库存储验证数据: uuid-->text
redis_conn = get_redis_connection('verify_code')
redis_conn.setex(uuid, 300, text)
# 响应图片数据
return http.HttpResponse(image, content_type="img/jpg")
"""
def get(self, request, uuid):
name, text, image = captcha.generate_captcha()
redis_conn = get_redis_connection('verify_code')
redis_conn.setex('img_%s' % uuid, constants.IMAGE_CODE_REDIS_EXPIRES, text)
return http.HttpResponse(image, content_type='image/jpg')
class SMSCodeView(View):
def get(self, request, mobile):
# 1.获取查询参数
query_dict = request.GET
image_code = query_dict.get('image_code')
uuid = query_dict.get('uuid')
redis_conn = get_redis_connection('verify_code')
# 判断是否频繁发送验证码
sms_send_code = redis_conn.get('sms_send_%s' % mobile)
if sms_send_code:
return http.JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '访问过于频繁'})
# 2.验证参数
if all([image_code, uuid]) is False:
return http.HttpResponseForbidden("缺少必要的参数")
# 3.校验图片验证码
image_code_server = redis_conn.get('img_'+uuid)
# 判断图片验证码在数据库中是否为空(已经过期)
if image_code_server is None:
return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图片验证码已过期'})
# 对数据库中提取的数据进行解码
image_str_server = image_code_server.decode()
# 判断用户填写的短信验证码是否与数据库中的验证码匹配
if image_str_server.lower() != image_code.lower():
return http.JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图片验证码错误'})
# 4.发送短信验证码
sms_code = '%06d' % randint(0, 999999)
logger.info(sms_code)
# 实例化pipeline管道对象
pl = redis_conn.pipeline()
# 删除数据库中的图片验证码
# redis_conn.delete('img_' + uuid)
pl.delete('img_' + uuid)
# 将短信验证码存储至数据库
# redis_conn.setex('sms_%s' % mobile, contans.SMS_CODE_REDIS_EXPIRES, sms_code)
pl.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 存储验证码标识(过期时间为60秒)
# redis_conn.setex('sms_send_%s' % mobile, contans.SMS_CODE_FLAG_REDIS_EXPIRES, 1)
pl.setex('sms_send_%s' % mobile, constants.SMS_CODE_FLAG_REDIS_EXPIRES//5, 1)
pl.execute()
# CCP().send_template_sms(手机号码, [验证码, 提示用户验证码多久过期], 指定短信模板)
# CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_REDIS_EXPIRES // 60], 1)
# 使用celery分布式任务队列
# ccp_send_sms_code(mobile, sms_code) # 此调用方式依旧会进程阻塞
ccp_send_sms_code.delay(mobile, sms_code) # 此调用方式只会将函数引用存储至仓库中然后由worker执行
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'}) | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,458 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/contents/crons.py | import time
import os
from django.template import loader
from django.conf import settings
from .utils import get_category
from .models import ContentCategory
# from contents.crons import generate_static_index_html
def generate_static_index_html():
"""
生成静态的主页html文件
"""
print('%s: generate_static_index_html' % time.ctime())
"""
{
'lb': [],
'kx':[],
}
"""
contents = {}
# 查询所有广告分类模型集合
contents_cats_qs = ContentCategory.objects.all()
# 遍历所有广告分类模型集合
for contents_cats_model in contents_cats_qs:
# 过滤查询广告分类模型对应的广告信息集合
contents_qs = contents_cats_model.content_set.filter(status=True).order_by('sequence')
# 添加广告分类和广告信息至自带那种
contents[contents_cats_model.key] = contents_qs
context = {
'categories': get_category(), # 商品类别渲染
'contents': contents, # 商品广告渲染
}
# 获取首页模板文件
template = loader.get_template('index.html')
# 渲染首页html字符串
html_text = template.render(context)
# 将首页html字符串写入到指定目录，命名'index.html'
file_path = os.path.join(settings.STATICFILES_DIRS[0], 'index.html')
with open(file_path, 'w', encoding='utf-8') as f:
f.write(html_text)
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,459 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/contents/utils.py | from goods.models import GoodsCategory, GoodsChannel
def get_category():
"""
{
'组号': {'channels': [], 'sub_cats': []}
'组号': {'channels': [], 'sub_cats': []}
}
"""
# 商品类别字典
categories = {}
# 按照group_id和sequence对频道进行排序
channel_qs = GoodsChannel.objects.order_by('group_id', 'sequence')
for channel_model in channel_qs:
# 获取商品频道模型的组号
group_id = channel_model.group_id
# categories[group_id] = {'channels': [], 'sub_cats': []}
# 判断组号是否存在
# if group_id in categories:
# categories[group_id] = {'channels': [], 'sub_cats': []}
categories.setdefault(group_id, {'channels': [], 'sub_cats': []})
# 通过外键获取一级商品类别模型
cat1 = channel_model.category
# 将一级频道模型的url添加到一级分类模型的url中
cat1.url = channel_model.url
# 向商品类别字典追加一级类别模型
categories[group_id]['channels'].append(cat1)
# 获取一级分类模型下的所有二级分类模型
cat2_qs = cat1.subs.all()
for cat2_model in cat2_qs:
# 获取二级分类模型下的所有三级模型
cat3_qs = cat2_model.subs.all()
# 将三级分类模型存储至二级分类模型下的sub_cats属性中
cat2_model.sub_cats = cat3_qs
# 向商品类别字典追加二级类别模型
categories[group_id]['sub_cats'].append(cat2_model)
return categories
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,460 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/goods/utils.py |
def get_bread_crumb(category_model):
"""包装面包屑导航"""
bread_crumb = {}
# 获取三级类别模型并添加至字典
bread_crumb['cat3'] = category_model
# 获取二级类别模型并添加至字典
bread_crumb['cat2'] = category_model.parent
# 获取一级类别模型
cat1 = category_model.parent.parent
# 将频道url存储值一级类别模型url属性中
cat1.url = cat1.goodschannel_set.all()[0].url
bread_crumb['cat1'] = cat1
return bread_crumb
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,461 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/sina/urls.py | from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^sina/login/$', views.SinaLoginURLView.as_view()), # 新浪微博登录链接
url(r'^sina_callback/$', views.SinaOauthView.as_view()), # 新浪微博回调链接
] | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,462 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/carts/views.py | from django.shortcuts import render
from django.views import View
from django.http import HttpResponseForbidden, JsonResponse
import json, pickle, base64
from django_redis import get_redis_connection
import logging
from meiduo_mall.utils.response_code import RETCODE
from goods.models import SKU
logger = logging.getLogger('django')
# Create your views here.
class CartView(View):
"""购物车视图"""
def post(self, request):
"""添加商品到购物车"""
# 接收数据
dict = json.loads(request.body.decode())
sku_id = dict.get('sku_id')
count = dict.get('count')
selected = dict.get('selected', True)
# 校验数据
if all({sku_id, count}) is False:
return HttpResponseForbidden('缺少必要参数')
# 查询sku_id是否存在
try:
sku = SKU.objects.get(id=sku_id, is_launched=True)
except SKU.DoesNotExist:
return HttpResponseForbidden('参数错误')
# 判断count是否为整数类型
try:
count = int(count)
except Exception as e:
logger.error('count类型错误')
return HttpResponseForbidden('count类型错误')
# 判断selected是否为布尔类型
if isinstance(selected, bool) is False:
logger.error('selected类型错误')
return HttpResponseForbidden('selected类型错误')
user = request.user
# 判断用户是否登录
if user.is_authenticated:
# 登录用户连接redis数据库
redis_conn = get_redis_connection('carts')
pl = redis_conn.pipeline()
# 存储hash
pl.hincrby('cart_%s' % user.id, sku_id, count)
# 存储set
if selected:
pl.sadd('selected_%s' % user.id, sku_id)
pl.execute()
response = JsonResponse({"code": RETCODE.OK, "errmsg": '添加购物车成功'})
# 响应
return response
else:
"""
carts:{
sku_id: {'count': 1, 'selected': True}
}
"""
# 未登录用户判断是否添加过购物车
data = request.COOKIES.get('carts')
if data:
# 已添加用户获取购物车数据进行累加
data_bytes = data.encode()
data_bytes_unicode = base64.b64decode(data_bytes)
carts_dict = pickle.loads(data_bytes_unicode)
# 判断sku_id是否已经存在
if sku_id in carts_dict:
origin_count = carts_dict[sku_id]['count']
count += origin_count
else:
# 首次添加用户新建列表
carts_dict = {}
carts_dict[sku_id] = {'count': count, 'selected': selected}
# 将将字典转换为字符串数据
data_bytes_unicode = pickle.dumps(carts_dict)
data_bytes = base64.b64encode(data_bytes_unicode)
data_str = data_bytes.decode()
# 设置cookie
response = JsonResponse({'code': RETCODE.OK, 'errmsg': '添加购物车成功'})
response.set_cookie('carts', data_str, max_age=None)
# 响应
return response
def get(self, request):
"""购物车展示"""
# 判断用户是否登录
user = request.user
if user.is_authenticated:
# 登录用户查询数据并包装成cookie中的字典格式
redis_conn = get_redis_connection('carts')
# {sku_id:count, sku_id:count, sku_id:count}
hash_result = redis_conn.hgetall('cart_%s' % user.id)
if not hash_result:
return render(request, 'cart.html')
# {sku_id, sku_id, sku_id}
set_result = redis_conn.smembers('selected_%s' % user.id)
cart_dict ={}
for sku_id_byte in hash_result:
cart_dict[int(sku_id_byte)] = {'count': int(hash_result[sku_id_byte]), 'selected': sku_id_byte in set_result}
else:
# 未登录用户将数据转换成字典格式
data_str = request.COOKIES.get('carts')
# 如果有值转换为字典格式
if data_str:
cart_dict = pickle.loads(base64.b64decode(data_str.encode()))
else:
return render(request, 'cart.html')
# 遍历字典中的sku_id进行查询,并包装成字典追加到列表中
sku_qs = SKU.objects.filter(id__in=cart_dict.keys())
context = []
for sku in sku_qs:
count = cart_dict[sku.id]['count']
context.append({
'id': sku.id,
'selected': str(cart_dict[sku.id]['selected']),
'default_image_url': sku.default_image.url,
'name': sku.name,
'price': str(sku.price),
'count': count,
'amount': str(sku.price * count),
})
return render(request, 'cart.html', {'cart_skus': context})
def put(self, request):
"""修改购物车数据"""
# 接收数据
json_dict = json.loads(request.body.decode())
sku_id = json_dict.get('sku_id')
count = json_dict.get('count')
selected = json_dict.get('selected', True)
# 校验数据
if all({sku_id, count}) is False:
return HttpResponseForbidden('缺少必要参数')
try:
sku = SKU.objects.get(id=sku_id)
except SKU.DoesNotExist:
return HttpResponseForbidden('参数有误')
try:
count = int(count)
except Exception as e:
logger.error('count类型错误')
return HttpResponseForbidden('count类型错误')
if not isinstance(selected, bool):
logger.error('selected类型错误')
return HttpResponseForbidden('selected类型错误')
# 判断用户是登录
user = request.user
if user.is_authenticated:
redis_cli = get_redis_connection('carts')
pl = redis_cli.pipeline()
pl.hset('cart_%s' % user.id, sku_id, count)
if selected:
pl.sadd('selected_%s'% user.id, sku_id)
else:
pl.srem('selected_%s'% user.id, sku_id)
pl.execute()
context = {
'id': sku.id,
'selected': selected,
'default_image_url': sku.default_image.url,
'name': sku.name,
'price': sku.price,
'count': count,
'amount': sku.price * count,
}
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'cart_sku': context})
else:
cart_str = request.COOKIES.get('carts')
if cart_str:
cart_dict = pickle.loads(base64.b64decode(cart_str.encode()))
else:
return HttpResponseForbidden('购物车为空')
context = {
'id': sku.id,
'selected': selected,
'default_image_url': sku.default_image.url,
'name': sku.name,
'price': sku.price,
'count': count,
'amount': sku.price * count,
}
cart_dict[sku_id] = {'count': count, 'selected': selected}
cart_dict = base64.b64encode(pickle.dumps(cart_dict)).decode()
response = JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'cart_sku': context})
response.set_cookie('carts', cart_dict)
return response
def delete(self, request):
"""删除购物车数据"""
# 接收数据
json_dict = json.loads(request.body.decode())
sku_id = json_dict.get('sku_id')
# 校验数据
try:
sku = SKU.objects.get(id=sku_id)
except SKU.DoesNotExist:
return HttpResponseForbidden('参数有误')
response = JsonResponse({'code': RETCODE.OK, 'errmsg': '删除购物车成功'})
# 判断用户是否登录
user = request.user
if user.is_authenticated:
# 登录用户链接redis数据库
# hash = {sku_id: count} set = {sku_id}
redis_cli = get_redis_connection('carts')
pl = redis_cli.pipeline()
pl.hdel('cart_%s' % user.id, sku_id)
pl.srem('selected_%s' % user.id, sku_id)
pl.execute()
else:
# 未登录用户
# 获取cart_str
cart_str = request.COOKIES.get('carts')
# 判断是否有值
if cart_str:
# 如果有值 cart_str--->cart_dict
cart_dict = pickle.loads(base64.b64decode(cart_str.encode()))
else:
# 如果没值 提前响应
return response
# 判断sku_id是否在cart_dict中, 防止报错
# 删除cookie中对应sku_id数据
if sku_id in cart_dict:
del cart_dict[sku_id]
# 如果为最后一条数据, 直接删除整条数据并提前响应
if not cart_dict:
response.delete_cookie('carts')
return response
# 将cart_dict--->cart_str
cart_str = base64.b64encode(pickle.dumps(cart_dict)).decode()
# 设置cookies
response.set_cookie('carts', cart_str)
return response
class CartSelectedAllView(View):
def put(self, request):
"""购物车全选"""
# 接收数据
json_dict = json.loads(request.body.decode())
selected = json_dict.get('selected')
# 校验数据
if not isinstance(selected, bool):
return HttpResponseForbidden('selected类型错误')
response = JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
# 判断用户登录
user = request.user
if user.is_authenticated:
# 登录用户
# 链接数据库
# {sku_id: count} {sku_id}
redis_cli = get_redis_connection('carts')
sku_dict = redis_cli.hgetall('cart_%s' % user.id)
if selected:
# 全选状态将hash中的所有sku_id添加到set集合中
redis_cli.sadd('selected_%s' % user.id, *sku_dict.keys())
else:
# 取消全选将set集合中的所有sku_id删除
redis_cli.delete('selected_%s' % user.id)
else:
# 未登录用户
# 获取cart_str
cart_str = request.COOKIES.get('carts')
# 判断cart_str
if cart_str:
# 有值cart_str--->cart_dict
cart_dict = pickle.loads(base64.b64decode(cart_str.encode()))
else:
# 没有值进行提前响应
return HttpResponseForbidden('购物车数据为空')
# 批量修改selected的值
for sku_dict in cart_dict.values():
sku_dict['selected'] = selected
# 转换类型cart_dict--->cart_str
cart_str = base64.b64encode(pickle.dumps(cart_dict)).decode()
# 设置cookie
response.set_cookie('carts', cart_str)
return response
class CartSimpleView(View):
"""简单版购物车"""
def get(self, request):
# 判断用户是否登录
user = request.user
if user.is_authenticated:
# hash {sku_id: count} set{sku_id}
# 登录用户转换数据格式为{sku_id:{'count':1, 'selected': True}}
redis_cli = get_redis_connection('carts')
cart_hash = redis_cli.hgetall('cart_%s' % user.id)
if not cart_hash:
return JsonResponse({'code':RETCODE.NODATAERR, 'errmsg': '购物车无数据'})
cart_set = redis_cli.smembers('selected_%s' % user.id)
cart_dict = {}
for sku_id_byte in cart_hash:
cart_dict[int(sku_id_byte)] = {'count': int(cart_hash[sku_id_byte]), 'selected': sku_id_byte in cart_set}
else:
# 未登录用户获取cookie数据
cart_str = request.COOKIES.get('carts')
if cart_str:
# 获取到进行数据合适转换
cart_dict = pickle.loads(base64.b64decode(cart_str.encode()))
else:
# 获取不到提前响应
return JsonResponse({'code':RETCODE.NODATAERR, 'errmsg': '购物车无数据'})
context = []
sku_qs = SKU.objects.filter(id__in=cart_dict.keys())
for sku in sku_qs:
count = cart_dict[sku.id]['count']
context.append({
'id': sku.id,
'name': sku.name,
'count': count,
'default_image_url': sku.default_image.url,
})
response = JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'cart_skus': context})
return response
"""
{
sku_id: {'count': 1, 'selected': True}
sku_id: {'count': 1, 'selected': True}
sku_id: {'count': 1, 'selected': True}
}
""" | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,463 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/payment/urls.py | from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^payment/(?P<order_id>\d+)/$', views.PaymentURLView.as_view()), # 订单支付路由
url(r'^payment/status/$', views.PaymentSuccessView.as_view()), # 支付成功路由
] | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,464 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/oauth/urls.py | from django.conf.urls import url
from . import views
urlpatterns = [
# url(r'^qq/authorization/$', views.QQOAuthURLView.as_view()), # QQ登录路由
url(r'^qq/login/$', views.QQOAuthURLView.as_view()), # QQ登录路由
url(r'^oauth_callback$', views.QQOAuthUserView.as_view()), # QQ登录回调路由
] | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,465 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/carts/utils.py | import pickle, base64
from django_redis import get_redis_connection
def merge_cart_cookie_to_redis(request, response):
# 获取cookie中的购物车数据
user = request.user
cart_str = request.COOKIES.get('carts')
# 如果cookie中没有购物车数据直接返回
if not cart_str:
return
# {sku_id: {'count':1, 'selected': True}
# 如果cookie中有数据转换为字典格式
cart_dict = pickle.loads(base64.b64decode(cart_str.encode()))
# 链接redis数据库
redis_cli = get_redis_connection('carts')
pl = redis_cli.pipeline()
# 遍历cookie中购物车字典获取所有sku_id
for sku_id in cart_dict:
# 将sku购物车信息添加至redis数据库
pl.hset('cart_%s' % user.id, sku_id, cart_dict[sku_id]['count'])
if cart_dict[sku_id]['selected']:
pl.sadd('selected_%s' % user.id, sku_id)
else:
pl.srem('selected_%s' % user.id, sku_id)
# 执行管道
pl.execute()
# 完成合并后将cookie中的数据清空
response.delete_cookie('carts')
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,466 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/payment/views.py | from django.shortcuts import render
from django.http import HttpResponseForbidden, JsonResponse
from alipay import AliPay
from django.conf import settings
import os
from meiduo_mall.utils.views import LoginRequiredView
from orders.models import OrderInfo
from meiduo_mall.utils.response_code import RETCODE
from .models import Payment
# 读取公私密钥
app_private_key_string = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'keys/app_private_key.pem')).read()
alipay_public_key_string = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'keys/alipay_public_key.pem')).read()
class PaymentURLView(LoginRequiredView):
def get(self, request, order_id):
# 校验数据
user = request.user
try:
order = OrderInfo.objects.get(order_id=order_id, user=user, status=OrderInfo.ORDER_STATUS_ENUM['UNPAID'])
except OrderInfo.DoesNotExist:
return HttpResponseForbidden('订单提交失败')
# 创建alipay对象
alipay = AliPay(
appid=settings.ALIPAY_APPID, # APPID
app_notify_url=None, # 默认回调url
app_private_key_string=app_private_key_string,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_string=alipay_public_key_string,
sign_type="RSA2", # RSA 或者 RSA2
debug=settings.ALIPAY_DEBUG # 默认False
)
# 电脑网站支付，需要跳转到https://openapi.alipay.com/gateway.do? + order_string
order_string = alipay.api_alipay_trade_page_pay(
out_trade_no=order_id, # 要支付的订单id
total_amount=str(order.total_amount), # 要支付的订单总金额 Decimal类型要转换为字符串格式
subject='美多商城%s' % order_id, # 主题
return_url=settings.ALIPAY_RETURN_URL, # 回调地址
)
# 拼接路径
alipay_url = settings.ALIPAY_URL + order_string
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'alipay_url': alipay_url})
class PaymentSuccessView(LoginRequiredView):
"""订单支付成功"""
def get(self, request):
# 获取查询参数数据
query_dict = request.GET
data = query_dict.dict()
sign = data.pop('sign')
# 创建alipay对象
alipay = AliPay(
appid=settings.ALIPAY_APPID, # APPID
app_notify_url=None, # 默认回调url
app_private_key_string=app_private_key_string,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
alipay_public_key_string=alipay_public_key_string,
sign_type="RSA2", # RSA 或者 RSA2
debug=settings.ALIPAY_DEBUG # 默认False
)
# 判断认证是否通过
if alipay.verify(data, sign):
order_id = data.get('out_trade_no')
trade_id = data.get('trade_no')
try:
# 判断订单号和支付宝流水号是否已经存在
Payment.objects.get(order_id=order_id, trade_id=trade_id)
except Payment.DoesNotExist:
# 订单支付通过创建支付宝流水号表格并关联订单号
Payment.objects.create(
order_id=order_id,
trade_id=trade_id,
)
# 修改订单的支付状态
OrderInfo.objects.filter(order_id=order_id, status=OrderInfo.ORDER_STATUS_ENUM['UNPAID']).update(
status=OrderInfo.ORDER_STATUS_ENUM['UNCOMMENT'])
# 渲染订单支付成功页面
return render(request, 'pay_success.html', {'trade_id': trade_id})
else:
# 提前响应
return HttpResponseForbidden('订单支付失败')
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,467 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/utils/fastdfs/fastdfs_storage.py | from django.core.files.storage import Storage
class FastDFSStoreage(Storage):
def _open(self):
pass
def _save(self):
pass
def url(self, name):
return 'http://127.0.0.1:8888/' + name | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,468 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/verifications/constants.py | # 保存常量数据
IMAGE_CODE_REDIS_EXPIRES = 300 # 图形验证码有效期(单位:秒)
SMS_CODE_REDIS_EXPIRES = 300 # 短信验证码有效期(单位:秒)
SMS_CODE_FLAG_REDIS_EXPIRES = 300 # 短信验证码有效期(单位:秒)
# 找回密码常量数据
VERIFY_CODE_ERROR = 400 # 验证码有误
USER_MOBILE_ERROR = 404 # 用户名或手机号有误
# SMS_CODE_EXPIRED = 410 # 验证码已过期
ACCESS_TOKEN__REDIS_EXPIRES = 600 # access_token有效期 | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,469 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/oauth/utils.py | from itsdangerous import TimedJSONWebSignatureSerializer as Serializer, BadData
from django.conf import settings
def generate_openid_signature(raw_openid):
"""加密"""
# 创建加密对象
serializer = Serializer(settings.SECRET_KEY, 600)
# 加密并包装为字典格式
openid_dict = {'openid': raw_openid}
openid = serializer.dumps(openid_dict)
# 解码
return openid.decode()
def check_openid(openid):
"""解密"""
# 创建解密对象
serializer = Serializer(settings.SECRET_KEY, 600)
try:
data = serializer.loads(openid)
openid = data.get('openid')
return openid
except BadData:
return None | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,470 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/oauth/views.py | from django.shortcuts import render, redirect
from QQLoginTool.QQtool import OAuthQQ
from django.views import View
from django.http import JsonResponse, HttpResponseServerError, HttpResponseForbidden
from django.conf import settings
from django.contrib.auth import login
from django_redis import get_redis_connection
from users.models import User
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
import logging
import re
from meiduo_mall.utils.response_code import RETCODE
from.models import OAuthQQUser
from .utils import generate_openid_signature, check_openid
from carts.utils import merge_cart_cookie_to_redis
logger = logging.getLogger('django')
class QQOAuthURLView(View):
def get(self, request):
# 获取查询数据
next_url = request.GET.get('next') or ('/')
# 创建qq认证工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI,
state=next_url)
# 拼接路径
qq_url = oauth.get_qq_url()
# 响应json数据
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'login_url': qq_url})
class QQOAuthUserView(View):
def get(self, request):
# 接收数据
code = request.GET.get('code')
# 校验数据
if code is None:
return HttpResponseForbidden('缺少必要参数')
# 创建qq认证工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI,)
try:
# 通过code获取token
access_token = oauth.get_access_token(code)
# 通过token获取openid
openid = oauth.get_open_id(access_token)
except Exception as e:
logger.error('oauth2.0认证失败')
return HttpResponseServerError("oauth2.0认证失败")
try:
# 通过openid查询用户是否绑定
oauth_model = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 未绑定用户渲染
# 对数据进行加密(默认为bytes类型)
data = {'openid': generate_openid_signature(openid)}
return render(request, 'oauth_callback.html', data)
else:
# 状态保持
user = oauth_model.user
login(request, user)
# 重定向并设置cookie
response = redirect(request.GET.get('state') or '/')
# 合并购物车
merge_cart_cookie_to_redis(request, response)
response.set_cookie('username', user.username, max_age=3600*24*14)
return response
def post(self, request):
# 获取数据
query_dict = request.POST
mobile = query_dict.get('mobile')
password = query_dict.get('password')
sms_code_client = query_dict.get('sms_code')
openid = query_dict.get('openid')
# 校验数据
if all([mobile, password, sms_code_client, openid]) is False:
return HttpResponseForbidden('缺少必要的参数')
if not re.match('^1[3-9]\d{9}$', mobile):
return HttpResponseForbidden('手机号格式错误')
if not re.match('[0-9A-Za-z]{8,20}$', password):
return HttpResponseForbidden('密码格式错误')
redis_conn = get_redis_connection('verify_code')
sms_code_server = redis_conn.get('sms_%s' % mobile)
# 判断短信验证码是过期
if sms_code_server is None:
return render(request, 'oauth_callback.html', {'sms_code_errmsg': '短信验证码错误'})
if sms_code_server.decode() != sms_code_client:
return render(request, 'oauth_callback.html', {'sms_code_errmsg': '短信验证码错误'})
# 创建解密对象
openid = check_openid(openid)
if openid is None:
return HttpResponseForbidden('缺少必要的参数')
# 判断用户是否已经注册过
try:
# 已注册用户校验用户密码是否正确
user = User.objects.get(mobile=mobile)
except:
# 未注册用户创建新用户
user = User.objects.create_user(username=mobile, password=password, mobile=mobile)
else:
if user.check_password(password) is False:
content = {'qq_login_errmsg': '帐号或密码错误'}
return render(request, 'oauth_callback.html', content)
# 创建qq登录用户数据并绑定openid
OAuthQQUser.objects.create(user=user, openid=openid)
# 状态保持
login(request, user)
# 重定向并设置cookie
response = redirect(request.GET.get('state') or '/')
# 合并购物车
merge_cart_cookie_to_redis(request, response)
response.set_cookie('username', user.username, max_age=3600*24*14)
return response | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,471 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/sina/views.py | from django.shortcuts import render, redirect
from django.http import JsonResponse, HttpResponseForbidden, HttpResponseServerError
from django.views import View
from django.conf import settings
from carts.utils import merge_cart_cookie_to_redis
from django.contrib.auth import login
from django_redis import get_redis_connection
import re
from . import sinaweibopy3
from meiduo_mall.utils.response_code import RETCODE
from .models import OAuthSinaUser
from users.models import User
from oauth.utils import generate_openid_signature, check_openid
# Create your views here.
class SinaLoginURLView(View):
def get(self, request):
# 获取查询参数数据
next_url = request.GET.get('next', '/')
# 创建微博客户端对象
client = sinaweibopy3.APIClient(app_key=settings.APP_KEY, # APP_KEY
app_secret=settings.APP_SECRET, # APP_SECRET
redirect_uri=settings.REDIRECT_URL) # 回调地址
# 生成跳转链接
login_url = client.get_authorize_url()
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'login_url': login_url})
class SinaOauthView(View):
def get(self, request):
code = request.GET.get('code')
# 校验数据
if code is None:
return HttpResponseForbidden('缺少必要参数')
# 创建客户端对象
client = sinaweibopy3.APIClient(app_key=settings.APP_KEY, # APP_KEY
app_secret=settings.APP_SECRET, # APP_SECRET
redirect_uri=settings.REDIRECT_URL) # 回调地址
try:
result = client.request_access_token(code)
access_token = result.access_token
uid = result.uid
except Exception as e:
return HttpResponseServerError("oauth2.0认证失败")
# 判断帐号是否已经绑定用户
try:
sina_user = OAuthSinaUser.objects.get(uid=uid)
except OAuthSinaUser.DoesNotExist:
# 未绑定用户渲染绑定用户页面
data = {'uid': generate_openid_signature(uid)}
return render(request, 'sina_callback.html', data)
else:
# 获取用户对象
user = sina_user.user
# 保持登录状态
login(request, user)
# 重定向到指定页面
response = redirect('/')
merge_cart_cookie_to_redis(request, response)
response.set_cookie('username', user.username, max_age=3600*24*14)
return response
def post(self, request):
# 获取数据
query_dict = request.POST
mobile = query_dict.get('mobile')
password = query_dict.get('password')
sms_code_client = query_dict.get('sms_code')
openid = query_dict.get('uid')
# 校验数据
if all([mobile, password, sms_code_client, openid]) is False:
return HttpResponseForbidden('缺少必要的参数')
if not re.match('^1[3-9]\d{9}$', mobile):
return HttpResponseForbidden('手机号格式错误')
if not re.match('[0-9A-Za-z]{8,20}$', password):
return HttpResponseForbidden('密码格式错误')
redis_conn = get_redis_connection('verify_code')
sms_code_server = redis_conn.get('sms_%s' % mobile)
# 判断短信验证码是过期
if sms_code_server is None:
return render(request, 'oauth_callback.html', {'sms_code_errmsg': '短信验证码错误'})
if sms_code_server.decode() != sms_code_client:
return render(request, 'oauth_callback.html', {'sms_code_errmsg': '短信验证码错误'})
open_id = check_openid(openid)
if open_id is None:
return HttpResponseForbidden('缺少必要的参数')
# 判断用户是否已经注册过
try:
# 已注册用户校验用户密码是否正确
user = User.objects.get(mobile=mobile)
except:
# 未注册用户创建新用户
user = User.objects.create_user(username=mobile, password=password, mobile=mobile)
else:
if user.check_password(password) is False:
content = {'qq_login_errmsg': '帐号或密码错误'}
return render(request, 'oauth_callback.html', content)
# 创建qq登录用户数据并绑定openid
OAuthSinaUser.objects.create(user=user, uid=open_id)
# 状态保持
login(request, user)
# 重定向并设置cookie
response = redirect('/')
# 合并购物车
merge_cart_cookie_to_redis(request, response)
response.set_cookie('username', user.username, max_age=3600 * 24 * 14)
return response | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,472 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/libs/yuntongxun/constants.py | # 保存常量数据
IMAGE_CODE_REDIS_EXPIRES = 300 # 图形验证码有效期(单位:秒)
SMS_CODE_REDIS_EXPIRES = 300 # 短信验证码有效期(单位:秒)
SMS_CODE_FLAG_REDIS_EXPIRES = 300 # 短信验证码有效期(单位:秒) | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,473 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/goods/views.py | from django.shortcuts import render
from django.views import View
from django.http import HttpResponseForbidden, JsonResponse
from django.core.paginator import Paginator, EmptyPage
from django.utils import timezone
from django_redis import get_redis_connection
import json
# Create your views here.
from .utils import get_bread_crumb
from .models import GoodsCategory, SKU, GoodVisitCount
from contents.utils import get_category
from meiduo_mall.utils.response_code import RETCODE
from meiduo_mall.utils.views import LoginRequiredView
class ListView(View):
def get(self, request, category_id, page_num):
page_num = int(page_num)
try:
# 获取三级类别模型对象
category_model = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return render(request, '404.html')
# 通过是否含有下级类别来判断是否为三级类别
sub_cat = category_model.subs.all()
if sub_cat:
return render(request, '404.html')
# 获取查询参数中的排序方式, 用户如果未指定则按照默认方式
sort = request.GET.get('sort', 'default')
# 按照价格字段排序
if sort == 'price':
sort_field = 'price'
# 按照销量字段排序
elif sort == 'hot':
sort_field = '-sales'
else:
# 默认按照创建时间排序
sort_field = 'create_time'
# 每页展示的商品数量
page = 5
# 获取当前三级类别下的所有sku查询集
sku_qs = category_model.sku_set.filter(category=category_model, is_launched=True).order_by(sort_field)
# 当前三级类别下的所有sku数量
sku_num = sku_qs.count()
# 分页展示的页面总数量
# total_page = sku_num // page + 1 if sku_num % page else 0
# page_sku = sku_qs[0:5]
# page_sku = sku_qs[5:10]
# page_sku = sku_qs[10:15]
# 利用切片获取当前页面要展示的sku
# page_sku = sku_qs[(page_num-1) * page: page*page_num]
# 创建分页器对象
paginator = Paginator(sku_qs, page)
try:
# 分页器筛选当前页面要展示的sku
page_sku = paginator.page(page_num)
except EmptyPage:
return HttpResponseForbidden('empty page')
# 分页展示的页面总数量
total_page = paginator.num_pages
context = {
'categories': get_category(), # 频道分类
'breadcrumb': get_bread_crumb(category_model), # 面包屑导航
'category': category_model, # 三级类别模型
'page_skus': page_sku, # 分页后商品sku
'page_num': page_num, # 当前页码
'total_page': total_page, # 总页数
'sort': sort, # 排序方式
}
return render(request, 'list.html', context)
class HotGoodsView(View):
def get(self, request, category_id):
try:
category_model = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return HttpResponseForbidden("参数错误")
# 通过是否含有下级类别来判断是否为三级类别
sub_cat = category_model.subs.all()
if sub_cat:
return HttpResponseForbidden("参数错误")
hot_sku_qs = category_model.sku_set.filter(category=category_model, is_launched=True).order_by('-sales')
hot_sku = hot_sku_qs[0:2]
context = []
for sku in hot_sku:
context.append(
{
'id': sku.id,
'default_image_url': sku.default_image.url,
'name': sku.name,
'price': sku.price
}
)
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'hot_skus': context})
class DetailsGoodsView(View):
def get(self, request, sku_id):
try:
sku_model = SKU.objects.get(id=sku_id, is_launched=True)
except SKU.DoesNotExist:
return HttpResponseForbidden("参数错误")
category_model = sku_model.category
spu = sku_model.spu
"""1.准备当前商品的规格选项列表 [8, 11]"""
# 获取出当前正显示的sku商品的规格选项id列表
current_sku_spec_qs = sku_model.specs.order_by('spec_id')
current_sku_option_ids = [] # [8, 11]
for current_sku_spec in current_sku_spec_qs:
current_sku_option_ids.append(current_sku_spec.option_id)
"""2.构造规格选择仓库
{(8, 11): 3, (8, 12): 4, (9, 11): 5, (9, 12): 6, (10, 11): 7, (10, 12): 8}
"""
# 构造规格选择仓库
temp_sku_qs = spu.sku_set.all() # 获取当前spu下的所有sku
# 选项仓库大字典
spec_sku_map = {} # {(8, 11): 3, (8, 12): 4, (9, 11): 5, (9, 12): 6, (10, 11): 7, (10, 12): 8}
for temp_sku in temp_sku_qs:
# 查询每一个sku的规格数据
temp_spec_qs = temp_sku.specs.order_by('spec_id')
temp_sku_option_ids = [] # 用来包装每个sku的选项值
for temp_spec in temp_spec_qs:
temp_sku_option_ids.append(temp_spec.option_id)
spec_sku_map[tuple(temp_sku_option_ids)] = temp_sku.id
"""3.组合 并找到sku_id 绑定"""
spu_spec_qs = spu.specs.order_by('id') # 获取当前spu中的所有规格
for index, spec in enumerate(spu_spec_qs): # 遍历当前所有的规格
spec_option_qs = spec.options.all() # 获取当前规格中的所有选项
temp_option_ids = current_sku_option_ids[:] # 复制一个新的当前显示商品的规格选项列表
for option in spec_option_qs: # 遍历当前规格下的所有选项
temp_option_ids[index] = option.id # [8, 12]
option.sku_id = spec_sku_map.get(tuple(temp_option_ids)) # 给每个选项对象绑定下他sku_id属性
spec.spec_options = spec_option_qs # 把规格下的所有选项绑定到规格对象的spec_options属性上
# 查询sku关联的所有商品订单信息
order_goods = sku_model.ordergoods_set.filter(is_commented=True).order_by('-create_time')
context = {
'categories': get_category(),
'breadcrumb': get_bread_crumb(category_model),
'sku': sku_model,
'spu': spu,
'order_goods': order_goods,
'category': category_model,
'spec_qs': spu_spec_qs, # 当前商品的所有规格数据
}
return render(request, 'detail.html', context)
class GoodVisitView(View):
"""商品访问量统计"""
def post(self, request, category_id):
# 校验
try:
# 获取三级类别模型对象
category = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return HttpResponseForbidden("参数错误")
# 判断当前类别是否为三级类别
if category.subs.all():
return HttpResponseForbidden("参数错误")
# 获取当前计算机的日期
# date = timezone.localdate()
date = timezone.now()
# 查询当前商品类别今日是否访问过
try:
# 已访问商品类别直接访问量计数加1
good_visit = GoodVisitCount.objects.get(category=category, date=date)
except GoodVisitCount.DoesNotExist:
# 未访问商品类别新增记录并将访问量计数加1
good_visit = GoodVisitCount(category=category)
good_visit.count += 1
good_visit.save()
# 响应Json数据
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,474 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/goods/urls.py | from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^list/(?P<category_id>\d+)/(?P<page_num>\d+)/$', views.ListView.as_view()), # 商品列表路由
url(r'^hot/(?P<category_id>\d+)/$', views.HotGoodsView.as_view()), # 热销商品路由
url(r'^detail/(?P<sku_id>\d+)/$', views.DetailsGoodsView.as_view()), # 商品详情路由
url(r'^visit/(?P<category_id>\d+)/$', views.GoodVisitView.as_view()), # 商品访问量路由
] | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,475 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/users/urls.py | from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^register/$', views.RegisterView.as_view()), # 设置注册页面路由
url(r'^usernames/(?P<username>[a-zA-Z0-9_-]{5,20})/count/$', views.UserNameCountView.as_view()), # 用户名重复检测
url(r'^mobiles/(?P<mobile>1[345789]\d{9})/count/$', views.MobileCountView.as_view()), # 手机号码重复检测
url(r'^login/$', views.LoginView.as_view()), # 用户登录页面
url(r'^logout/$', views.LogoutView.as_view()), # 用户退出登录页面
url(r'^info/$', views.InfoView.as_view()), # 用户中心页面
url(r'^emails/$', views.EmailView.as_view()), # 用户邮箱
url(r'^emails/verification/$', views.VerifyEmailView.as_view()), # 验证邮箱
url(r'^addresses/$', views.AddressView.as_view()), # 收货地址
url(r'^addresses/create/$', views.CreateAddressView.as_view()), # 新增收货地址
url(r'^addresses/(?P<id>\d+)/$', views.DeleteAddressView.as_view()), # 删除收货地址
url(r'^addresses/(?P<id>\d+)/default/$', views.DefaultAddressView.as_view()), # 设置默认收货地址
url(r'^addresses/(?P<id>\d+)/title/$', views.AddressTitleView.as_view()), # 修改收货地址标题
url(r'^password/$', views.PasswordView.as_view()), # 修改用户密码
url(r'^browse_histories/$', views.UserBrowserHistory.as_view()), # 用户浏览记录路由
url(r'^find_password/$', views.FindPasswordView.as_view()), # 找回用户密码
url(r'^accounts/(?P<username>[a-zA-Z0-9_-]{5,20})/sms/token/$', views.ImageToFindPasswordView.as_view()), # 找回密码之图片验证码
url(r'^sms_codes/$', views.SmsCodeToFindPasswordView.as_view()), # 找回密码之发送短信验证码
url(r'^accounts/(?P<username>[a-zA-Z0-9_-]{5,20})/password/token/$', views.CheckSmsToFindPasswordView.as_view()), # 找回密码之校验短信验证码
url(r'^users/(?P<user_id>\d+)/password/$', views.SetNewPasswordView.as_view()), # 找回密码之设置新密码
] | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,476 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/areas/views.py | from django.shortcuts import render
from django.core.cache import cache
from django.http import JsonResponse, HttpResponseForbidden
from meiduo_mall.utils.views import LoginRequiredView
from meiduo_mall.utils.response_code import RETCODE
from .models import Area
# Create your views here.
class AreaView(LoginRequiredView):
def get(self, request):
# 接收数据
area_id = request.GET.get('area_id')
# 判断是否为空
if area_id is None:
province_list = cache.get('province_list')
if province_list is None:
# 获取省份查询集
province_model_list = Area.objects.filter(parent_id=None)
# 创建空列表存储省份ID和名称
province_list = []
# 遍历省份查询集, 并向空列表中追加省份字典数据
for province_model in province_model_list:
province_list.append({'id': province_model.id, 'name': province_model.name})
cache.set('province_list', province_list, 3600)
# 响应JSON数据
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'province_list': province_list})
else:
# 查询对应市/区
try:
sub_data = cache.get(area_id)
if sub_data is None:
# 查询父类模型
parent_model = Area.objects.get(id=area_id)
# 通过外键查询父类模型下的所有子模型
sub_model_list = parent_model.subs.all()
sub_list = []
for sub_model in sub_model_list:
sub_list.append({'id': sub_model.id, 'name': sub_model.name})
sub_data = {
'id': parent_model.id,
'name': parent_model.name,
'subs': sub_list
}
cache.set(area_id, sub_data, 3600)
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'sub_data': sub_data})
except Area.DoesNotExist:
return HttpResponseForbidden('查询失败')
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,477 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/carts/urls.py | from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^carts/$', views.CartView.as_view()), # 购物车路由
url(r'^carts/selection/$', views.CartSelectedAllView.as_view()), # 购物车全选
url(r'^carts/simple/$', views.CartSimpleView.as_view()), # 简单版购物车
] | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,478 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/orders/views.py | from django.shortcuts import render
from decimal import Decimal
from django_redis import get_redis_connection
from django.http import JsonResponse, HttpResponseForbidden
from django.db import transaction
from django.core.paginator import Paginator,EmptyPage
import json, logging
from django.utils import timezone
from meiduo_mall.utils.views import LoginRequiredView
from meiduo_mall.utils.response_code import RETCODE
from users.models import Address
from goods.models import SKU
from .models import OrderInfo, OrderGoods
logger = logging.getLogger('django')
# Create your views here.
class OrderSettlementView(LoginRequiredView):
"""订单结算页面"""
def get(self, request):
user = request.user
# 查询当前用户下的所有收货地址
address_qs = Address.objects.filter(user=user, is_deleted=False)
# 查询当前用户已勾选的sku商品
redis_cli = get_redis_connection('carts')
# {sku_id: count}
hash_cart = redis_cli.hgetall('cart_%s' % user.id)
set_cart = redis_cli.smembers('selected_%s' % user.id)
sku_dict = {}
# 过滤已勾选的商品并包装成{sku_id: count}
for sku_id_byte in set_cart:
sku_dict[int(sku_id_byte)] = int(hash_cart[sku_id_byte])
# 获取所有sku对象查询集
sku_qs = SKU.objects.filter(id__in=sku_dict.keys())
# 设置初始总量0
total_count = 0
# 设置初始总价0.00
total_amount = Decimal('0.00')
# 获取所有sku对象
for sku in sku_qs:
sku.count = sku_dict[sku.id]
sku.amount = sku.count * sku.price
total_count += sku.count
total_amount += sku.amount
# 设置固定运费
freight = Decimal('10.00')
context = {
'addresses': address_qs,
'skus': sku_qs,
'total_count': total_count,
'total_amount': total_amount,
'freight': freight,
'payment_amount': total_amount + freight,
}
return render(request, 'place_order.html', context)
class OrderCommitView(LoginRequiredView):
"""订单提交页面"""
def post(self, request):
# 接收数据
user = request.user
json_data = json.loads(request.body.decode())
address_id = json_data.get('address_id')
pay_method = json_data.get('pay_method')
# 校验数据
if all([address_id, pay_method]) is False:
return HttpResponseForbidden('缺少必要的参数')
try:
address = Address.objects.get(id=address_id, user=user, is_deleted=False)
except Address.DoesNotExist:
return HttpResponseForbidden('收货地址有误')
if pay_method not in (OrderInfo.PAY_METHODS_ENUM['CASH'], OrderInfo.PAY_METHODS_ENUM['ALIPAY']):
return HttpResponseForbidden('支付方式有误')
# 修改四表数据 order_info, order_goods, sku, spu
# 生成订单ID
order_id = timezone.now().strftime('%Y%m%d%H%M%S') + '%09d' % user.id
# 判断订单状态
status = OrderInfo.ORDER_STATUS_ENUM['UNPAID'] if pay_method == OrderInfo.PAY_METHODS_ENUM['ALIPAY'] else OrderInfo.ORDER_STATUS_ENUM['UNSEND']
# 开始事务
with transaction.atomic():
# 创建保存点
save_point = transaction.savepoint()
try:
# 暴力回滚
# 创建订单信息表
order_info = OrderInfo.objects.create(
order_id=order_id,
user=user,
address=address,
total_count=0,
total_amount=Decimal('0.00'),
freight=Decimal('10.00'),
pay_method=pay_method,
status=status,
)
# 修改sku的库存和销量以及spu的销量
redis_cli = get_redis_connection('carts')
count_hash = redis_cli.hgetall('cart_%s' % user.id)
selected_set = redis_cli.smembers('selected_%s' % user.id)
cart_dict = {}
# 过滤数据 已勾选商品{sku_id: count}
for sku_id in selected_set:
cart_dict[int(sku_id)] = int(count_hash[sku_id])
for sku_id in cart_dict:
while True:
sku = SKU.objects.get(id=sku_id)
# 原始库存和销量
origin_stock = sku.stock
origin_sales = sku.sales
# 购买数量
buy_count = cart_dict[sku_id]
# 判断库存是否充足
if origin_stock < buy_count:
# 如果执行到此处回滚数据至保存点
transaction.savepoint_rollback(save_point)
return JsonResponse({'code': RETCODE.STOCKERR, 'errmsg': '%s商品库存不足' % sku.name})
# 购买后的库存和销量
new_stock = origin_stock - buy_count
new_sales = origin_sales + buy_count
# 更新sku的库存和销量
# sku.stock = new_stock
# sku.sales = new_sales
# sku.save()
result = SKU.objects.filter(id=sku_id, stock=origin_stock).update(sales=new_sales, stock=new_stock)
if result == 0:
continue
# 更新spu的销量
spu = sku.spu
spu.sales += buy_count
spu.save()
# 创建商品信息表
order_goods = OrderGoods.objects.create(
order=order_info,
sku=sku,
count=buy_count,
price=sku.price,
)
order_info.total_count += buy_count
order_info.total_amount += buy_count * sku.price
break
# 订单总金额包含运费
order_info.total_amount += order_info.freight
order_info.save()
except Exception as e:
logger.error(e)
transaction.savepoint_rollback(save_point)
return JsonResponse({'code': RETCODE.STOCKERR, 'errmsg': '订单提交失败'})
else:
# 提交事务
transaction.savepoint_commit(save_point)
# 清空购物车数据
pl = redis_cli.pipeline()
pl.hdel('cart_%s' % user.id, *selected_set)
pl.delete('selected_%s' % user.id)
pl.execute()
# 响应json
return JsonResponse({'code': RETCODE.OK, 'errmsg': '订单提交成功', 'order_id': order_id})
class OrderSuccessView(LoginRequiredView):
"""订单提交成功界面"""
def get(self, request):
# 接收
user = request.user
result = request.GET
order_id = result.get('order_id')
payment_amount = result.get('payment_amount')
pay_method = result.get('pay_method')
# 校验
if all([order_id, pay_method, payment_amount]) is False:
return HttpResponseForbidden('缺少必要参数')
try:
OrderInfo.objects.get(order_id=order_id, pay_method=pay_method, total_amount=payment_amount, user=user)
except OrderInfo.DoesNotExist:
return HttpResponseForbidden('订单提交失败')
# 响应
context = {
'payment_amount': payment_amount,
'order_id': order_id,
'pay_method': pay_method
}
return render(request, 'order_success.html', context)
class ShowOrderView(LoginRequiredView):
"""展示用户订单"""
def get(self, request, page):
# 获取当前登录用户
user = request.user
# 如果没有指定页面默认为第一页
page_num = page if page else 1
# 查询所有的订单按最新创建时间降序排列
orders = OrderInfo.objects.filter(user=user).order_by('-create_time')
# 将所有订单分页展示, 每页显示数量为5个
paginator = Paginator(orders, 5)
try:
# 获取指定页面显示的订单
page_orders = paginator.page(page_num)
except EmptyPage:
return HttpResponseForbidden("EmptyPage")
# 获取分页显示的每个订单对象
for order in page_orders:
# 获取支付方式的中文字段
if order.pay_method == OrderInfo.PAY_METHODS_ENUM['ALIPAY']:
order.pay_method_name = "支付宝"
else:
order.pay_method_name = '货到付款'
# 获取订单状态的中文字段
if order.status == OrderInfo.ORDER_STATUS_ENUM['UNPAID']:
order.status_name = "待支付"
elif order.status == OrderInfo.ORDER_STATUS_ENUM['UNCOMMENT']:
order.status_name = "待评价"
elif order.status == OrderInfo.ORDER_STATUS_ENUM['UNSEND']:
order.status_name = "待发货"
elif order.status == OrderInfo.ORDER_STATUS_ENUM['UNRECEIVED']:
order.status_name = "待收货"
elif order.status == OrderInfo.ORDER_STATUS_ENUM['FINISHED']:
order.status_name = "已完成"
else:
order.status_name = "已取消"
# 单个订单添加一个列表属性
order.sku_list = []
# 查询每个订单对应的所有商品
order_goods = OrderGoods.objects.filter(order_id=order.order_id)
# 获取单个商品订单信息
for goods in order_goods:
sku = goods.sku
sku.count = goods.count
sku.amount = goods.count*goods.price
order.sku_list.append(sku)
# 获取总页数
total_page = paginator.num_pages
context = {
'page_orders': page_orders,
'page_num': page_num,
'total_page': total_page,
}
return render(request, 'user_center_order.html', context)
class OrderCommentView(LoginRequiredView):
"""订单评价页面"""
def get(self, request):
# 接收数据
user = request.user
order_id = request.GET.get('order_id')
# 校验数据
try:
order = OrderInfo.objects.get(order_id=order_id, user=user, status=OrderInfo.ORDER_STATUS_ENUM["UNCOMMENT"])
except OrderInfo.DoesNotExist:
return HttpResponseForbidden('订单有误')
# 查询到当前订单内的所有商品sku并包装成字典格式添加到列表中
uncomment_goods_list = []
order_goods = order.skus.filter(is_commented=False)
for order_good in order_goods:
sku = order_good.sku
uncomment_goods_list.append({
'sku_id': sku.id,
'name': sku.name,
'price': str(sku.price),
'order_id': order_id,
'default_image_url': sku.default_image.url
# 'display_score': sku.display_score,
# 'url': sku.url,
})
context = {
'uncomment_goods_list': uncomment_goods_list
}
return render(request, 'goods_judge.html', context)
def post(self, request):
# 接收数据
user = request.user
data = json.loads(request.body.decode())
order_id = data.get('order_id')
sku_id = data.get('sku_id')
comment = data.get('comment') # 评论内容
score = data.get('score') # 商品评分
is_anonymous = data.get('is_anonymous') # 是否匿名
# 校验数据
if all([order_id, sku_id, comment, score]) is False:
return HttpResponseForbidden('缺少必要的参数')
try:
# 判断订单号是否存在
order = OrderInfo.objects.get(order_id=order_id, user=user, status=OrderInfo.ORDER_STATUS_ENUM["UNCOMMENT"])
except OrderInfo.DoesNotExist:
return HttpResponseForbidden('评价失败')
try:
# 判断商品是否存在
sku = SKU.objects.get(id=sku_id)
except SKU.DoesNotExist:
return HttpResponseForbidden('评价失败')
# 校验商品评分是否为0-5的整数
if score not in range(0, 6):
return HttpResponseForbidden('请选择评价星级')
# 判断is_anonymous是否为bool类型
if isinstance(is_anonymous, bool) is False:
return HttpResponseForbidden('评价失败')
try:
# 获取要评价的订单商品
order_goods = OrderGoods.objects.get(sku=sku, order=order, is_commented=False)
except OrderGoods.DoesNotExist:
return HttpResponseForbidden('评价失败')
else:
# 修改并保存订单评价信息
order_goods.comment = comment
order_goods.score = score
order_goods.is_anonymous = is_anonymous
order_goods.is_commented = True
order_goods.save()
# 查询订单中所有商品类型总数
order_sku_count = order.skus.count()
# 查询订单中所有已评价商品类型总数
count = order.skus.filter(is_commented=True).count()
if order_sku_count == count:
# 如果订单中所有商品已评价修改订单状态
order.status = OrderInfo.ORDER_STATUS_ENUM['FINISHED']
order.save()
return JsonResponse({'code': RETCODE.OK, 'errmsg': '订单评价成功'})
else:
# 如果订单中商品未评价完刷新页面
return JsonResponse({'code': RETCODE.REFRESH, 'errmsg': '订单评价成功'}) | {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,479 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/celery_tasks/main.py | # celery 启动文件
from celery import Celery
import os
# 使用django配置环境模板
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "meiduo_mall.settings.dev")
# 实例化celery对象
celery_app = Celery('meiduo')
# 指定任务仓库
celery_app.config_from_object('celery_tasks.config')
# 执行哪些任务
celery_app.autodiscover_tasks(['celery_tasks.sms', 'celery_tasks.email'])
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,480 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/contents/views.py | from django.shortcuts import render
from django.views import View
from .utils import get_category
from .models import ContentCategory
# Create your views here.
class IndexView(View):
def get(self, request):
"""
{
'lb': [],
'kx':[],
}
"""
contents = {}
# 查询所有广告分类模型集合
contents_cats_qs = ContentCategory.objects.all()
# 遍历所有广告分类模型集合
for contents_cats_model in contents_cats_qs:
# 过滤查询广告分类模型对应的广告信息集合
contents_qs = contents_cats_model.content_set.filter(status=True).order_by('sequence')
# 添加广告分类和广告信息至自带那种
contents[contents_cats_model.key] = contents_qs
context = {
'categories': get_category(), # 商品类别渲染
'contents': contents, # 商品广告渲染
}
return render(request, 'index.html', context)
# def goods_category():
#
# """
# {
# group_id: {channels: [], sub_cats: []}
# }
# """
# categories = {}
# # 获取商品频道分类查询集
# channel_qs = GoodsChannel.objects.order_by('group_id', 'sequence')
# for channel_model in channel_qs:
# # 获取频道分类模型的group_id
# group_id = channel_model.group_id
# if group_id not in categories:
# categories['group_id'] = {'channels': [], 'sub_cats': []}
# cat1 = channel_model.category
# cat1.url = channel_model.url
# categories['group_id']['channels'].append(cat1)
#
#
# # 渲染模板内容
# content = {
# # 商品分类
# 'category': categories,
#
# }
# return content
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
63,481 | silence-py/django_meiduo_shopping | refs/heads/master | /meiduo_mall/meiduo_mall/apps/users/views.py | from django.shortcuts import render, redirect
from django.views import View
from django.http import HttpResponse, HttpResponseForbidden, JsonResponse
from django.contrib.auth import login, authenticate, logout
from django.db.utils import DatabaseError
from django_redis import get_redis_connection
from django.conf import settings
from django.contrib.auth.mixins import LoginRequiredMixin
# from django.core.mail import send_mail
from random import randint
import re, json, logging
from .models import User
from meiduo_mall.utils.response_code import RETCODE
from meiduo_mall.utils.views import LoginRequiredView
from celery_tasks.email.tasks import send_verify_email
from users.utils import generate_verify_email_url, check_email
from goods.models import SKU
from .models import Address
from oauth.utils import generate_openid_signature, check_openid
from carts.utils import merge_cart_cookie_to_redis
from verifications import constants
from celery_tasks.sms.tasks import ccp_send_sms_code
logger = logging.getLogger('django')
# Create your views here.
class RegisterView(View):
"""用户注册页面"""
def get(self, request):
return render(request, 'register.html') # 返回注册页面
def post(self, request):
# 1.获取表单数据
query_dict = request.POST
username = query_dict.get('username')
password = query_dict.get('password')
password2 = query_dict.get('password2')
sms_code_client = query_dict.get('sms_code')
mobile = query_dict.get('mobile')
allow = query_dict.get('allow')
# 连接数据库
redis_conn = get_redis_connection('verify_code')
# 2. 校验数据
if all([username, password, password2, sms_code_client, mobile, allow]) is False:
return HttpResponseForbidden('数据填写不完整')
if not re.match('^[a-zA-Z0-9_-]{5,20}$', username):
return HttpResponseForbidden('请输入5-20个字符的用户名')
if not re.match('^[0-9A-Za-z]{8,20}$', password):
return HttpResponseForbidden('请输入8-20位的密码')
if password != password2:
return HttpResponseForbidden('两次输入的密码不一致')
if not re.match('^1[3-9]\d{9}$', mobile):
return HttpResponseForbidden('请输入正确的手机号码')
# 查询短信验证码
sms_code_server = redis_conn.get('sms_%s' % mobile).decode()
# 判断短信验证码是否已经过期
if sms_code_server is None:
return render(request, 'register.html', context={'sms_code_error': '短信验证码已过期'})
# 验证短信验证码
if sms_code_client != sms_code_server:
return render(request, 'register.html', context={'sms_code_error': '短信验证码错误'})
# 3.保存注册数据
try:
user = User.objects.create_user(username=username, password=password, mobile=mobile)
except DatabaseError:
return render(request, 'register.html', {'register_errmsg': '注册失败'})
# 4.状态保持
login(request, user)
response = redirect('/')
response.set_cookie('username', user.username, max_age=settings.SESSION_COOKIE_AGE)
return response
class UserNameCountView(View):
"""用户名重复检测"""
def get(self, request, username):
count = User.objects.filter(username=username).count()
return JsonResponse(data={'code': RETCODE.OK, 'errmsg': 'OK', 'count': count})
class MobileCountView(View):
"""手机号重复检测"""
def get(self, request, mobile):
count = User.objects.filter(mobile=mobile).count()
return JsonResponse(data={'code': RETCODE.OK, 'errmsg': 'OK', 'count': count})
class LoginView(View):
"""用户登录页面"""
def get(self, request):
return render(request, 'login.html')
def post(self, request):
# 获取表单数据
query_dict = request.POST
username = query_dict.get('username')
password = query_dict.get('pwd')
remembered = query_dict.get('remembered')
# 校验数据
if all([username, password]) is None:
return HttpResponseForbidden("缺少必要的参数")
if not re.match('^[a-zA-Z0-9_-]{5,20}$', username):
return render(request, 'login.html', {'loginerror': '帐号或密码错误'})
if not re.match('^[0-9A-Za-z]{8,20}$', password):
return render(request, 'login.html', {'loginerror': '帐号或密码错误'})
# 多帐号登录功能实现
# try:
# user = User.objects.get(username=username)
# except User.DoesNotExist:
# try:
# user = User.objects.get(mobile=username)
# except User.DoesNotExist:
# return render(request, 'login.html', {'account_errmsg': '帐号或密码错误'})
#
# if user.check_password(password) is False:
# return render(request, 'login.html', {'account_errmsg': '帐号或密码错误'})
# 用户认证 authenticate(请求对象, 认证参数), 查询不到用户返回None
user = authenticate(request, username=username, password=password)
if user is None:
return render(request, 'login.html', {'loginerror': '帐号或密码错误'})
# 状态保持
login(request, user)
if remembered is None:
request.session.set_expiry(0)
else:
request.session.set_expiry(settings.SESSION_COOKIE_AGE)
# response = redirect('/')
# 根据查询参数next的值重定向
response = redirect(request.GET.get('next') or '/')
merge_cart_cookie_to_redis(request, response)
# 设置cookie
response.set_cookie('username', user.username, max_age=settings.SESSION_COOKIE_AGE if remembered else None)
return response
class LogoutView(View):
"""用户退出登录"""
def get(self, request):
logout(request)
response = redirect('/login/')
response.delete_cookie('username')
return response
class InfoView(LoginRequiredMixin, View):
def get(self, request):
user = request.user
# isinstance(对象, 类) 判断对象是否属于此类, 若属于返回True, 否则返回False
# if isinstance(user, User):
# return render(request, 'user_center_info.html')
# is_authenticated 判断用户是否登录, 返回一个对象
# if user.is_authenticated:
return render(request, 'user_center_info.html')
# else:
# return redirect('/login/?next=/info/')
class EmailView(LoginRequiredView):
def put(self, request):
user = request.user
if user.email == '':
# 接收数据
json_str = request.body.decode()
data = json.loads(json_str)
email = data.get('email')
# 校验数据
if email is None:
return HttpResponseForbidden('缺少必要参数')
if not re.match('^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return HttpResponseForbidden('邮箱不正确')
# 修改数据
user.email = email
user.save()
# 发送邮件
# send_mail(subject='主题', message='基本内容', from_email='发件人', recipient_list='收件人列表',
# html_message='邮件超文本内容')
# subject = '美多商城邮箱验证'
# send_mail(subject=subject, message='', from_email=settings.EMAIL_FROM, recipient_list=[user.email],
# html_message='邮件超文本内容')
# 对查询参数进行加密
verify_url = generate_verify_email_url(user)
# 使用celery发送邮件
send_verify_email.delay(user.email, verify_url)
# 响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
class VerifyEmailView(View):
def get(self, request):
# 获取数据
data = request.GET.get('token')
if data is None:
return HttpResponseForbidden('缺少必要的参数')
token_dict = check_email(data)
# 校验数据
user_id = token_dict.get('user_id')
email = token_dict.get('email')
# 修改邮箱激活状态
try:
user = User.objects.get(id=user_id, email=email)
except User.DoesNotExist:
return HttpResponseForbidden('验证失败')
else:
try:
user.email_active = True
user.save()
except Exception as e:
return HttpResponseForbidden('邮箱激活失败')
# 响应页面
return redirect('/info/')
class AddressView(LoginRequiredView):
def get(self, request):
# 获取当前用户
user = request.user
# 查询当前用户的所有收获地址
query_set = Address.objects.filter(user=user, is_deleted=False)
# query_sets = user.addresses.filter(is_deleted=False)
# 将查询集对象转换为列表
address_list = []
for address in query_set:
address_list.append(
{
'id': address.id,
'title': address.title,
'receiver': address.receiver,
'province_id': address.province.id,
'province': address.province.name,
'city_id': address.city.id,
'city': address.city.name,
'district_id': address.district.id,
'district': address.district.name,
'place': address.place,
'mobile': address.mobile,
'tel': address.tel,
'email': address.email,
}
)
# 编辑模板内容
content = {
'addresses': address_list,
'default_address_id': user.default_address_id
}
return render(request, 'user_center_site.html', content)
class CreateAddressView(LoginRequiredView):
def post(self, request):
user = request.user
count = user.addresses.filter(is_deleted=False).count()
if count == 20:
return JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '添加地址已上限'})
user = request.user
# 接收
json_data = json.loads(request.body.decode())
# 校验
title = json_data.get('title')
receiver = json_data.get('receiver')
province_id = json_data.get('province_id')
city_id = json_data.get('city_id')
district_id = json_data.get('district_id')
place = json_data.get('place')
mobile = json_data.get('mobile')
tel = json_data.get('tel')
email = json_data.get('email')
if all([title, receiver, province_id, city_id, district_id, place, mobile]) is False:
return HttpResponseForbidden('缺少必要的参数')
if not re.match(r'^1[3-9]\d{9}$', mobile):
return HttpResponseForbidden('格式错误')
if tel:
if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
return HttpResponseForbidden('参数tel有误')
if email:
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return HttpResponseForbidden('参数email有误')
try:
# 新增收获地址
address = Address.objects.create(user=request.user,
title=receiver,
receiver=receiver,
province_id=province_id,
city_id=city_id,
district_id=district_id,
place=place,
mobile=mobile,
tel=tel,
email=email
)
# 判断用户是否有默认地址
if not user.default_address:
user.default_address = address
user.save()
except Exception as e:
return JsonResponse({'code': RETCODE.DBERR, 'errmsg': '新增地址失败'})
# 数据转字典格式
data = {
'id': address.id,
'title': address.title,
'receiver': address.receiver,
'province_id': address.province.id,
'province': address.province.name,
'city_id': address.city.id,
'city': address.city.name,
'district_id': address.district.id,
'district': address.district.name,
'place': address.place,
'mobile': address.mobile,
'tel': address.tel,
'email': address.email,
}
# 响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'address': data})
class DeleteAddressView(LoginRequiredView):
def delete(self, request, id):
"""删除收货地址"""
# 接收
address_id = id
# 校验
if not address_id:
return HttpResponseForbidden('缺少必要参数')
# 逻辑删除
try:
address = Address.objects.get(id=address_id)
address.is_deleted = True
address.save()
except Address.DoesNotExist:
return HttpResponseForbidden('地址不存在')
# 响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
def put(self, request, id):
"""编辑收货地址"""
# 接收
address_id = int(id)
user = request.user
json_data = json.loads(request.body.decode())
# 校验
if not address_id:
return HttpResponseForbidden('缺少必要参数')
title = json_data.get('title')
receiver = json_data.get('receiver')
province_id = json_data.get('province_id')
city_id = json_data.get('city_id')
district_id = json_data.get('district_id')
place = json_data.get('place')
mobile = json_data.get('mobile')
tel = json_data.get('tel')
email = json_data.get('email')
if all([title, receiver, province_id, city_id, district_id, place, mobile]) is False:
return HttpResponseForbidden('缺少必要的参数')
if not re.match(r'^1[3-9]\d{9}$', mobile):
return HttpResponseForbidden('格式错误')
if tel:
if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
return HttpResponseForbidden('参数tel有误')
if email:
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return HttpResponseForbidden('参数email有误')
try:
address = Address.objects.get(id=address_id)
address.is_deleted = True
address.save()
except Address.DoesNotExist:
return HttpResponseForbidden('地址不存在')
try:
# 新增收获地址
address = Address.objects.create(user=request.user,
title=receiver,
receiver=receiver,
province_id=province_id,
city_id=city_id,
district_id=district_id,
place=place,
mobile=mobile,
tel=tel,
email=email
)
# 判断用户是否有默认地址
# if not user.default_address:
# user.default_address = address
# user.save()
if user.default_address_id == address_id:
user.default_address_id = address.id
user.save()
except Exception as e:
return JsonResponse({'code': RETCODE.DBERR, 'errmsg': '新增地址失败'})
# 数据转字典格式
data = {
'id': address.id,
'title': address.title,
'receiver': address.receiver,
'province_id': address.province.id,
'province': address.province.name,
'city_id': address.city.id,
'city': address.city.name,
'district_id': address.district.id,
'district': address.district.name,
'place': address.place,
'mobile': address.mobile,
'tel': address.tel,
'email': address.email,
}
# 响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'address': data})
class DefaultAddressView(LoginRequiredView):
def put(self, request, id):
# 接收
address_id = id
user = request.user
# 校验
if not address_id:
return HttpResponseForbidden('缺少必要参数')
# 修改
try:
user.default_address_id = address_id
user.save()
except User.DoesNotExist:
return HttpResponseForbidden('用户不存在')
# 响应
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
class AddressTitleView(LoginRequiredView):
def put(self, request, id):
# 接收
address_id = id
data = json.loads(request.body.decode())
title = data.get('title')
# 校验
if not all([address_id, data, title]):
return HttpResponseForbidden('缺少必要参数')
# 修改
try:
address = Address.objects.get(id=address_id)
address.title = title
address.save()
except Address.DoesNotExist:
return HttpResponseForbidden('地址不存在')
return JsonResponse({'code': RETCODE.OK, 'errmsg': '修改标题成功'})
class PasswordView(LoginRequiredView):
def get(self, request):
"""渲染用户修改密码页面"""
return render(request, 'user_center_pass.html')
def post(self, request):
# 接收数据
user = request.user
data = request.POST
old_pwd = data.get('old_pwd')
new_pwd = data.get('new_pwd')
new_cpwd = data.get('new_cpwd')
# 校验数据
if all([old_pwd, new_pwd, new_cpwd]) is False:
return HttpResponseForbidden('缺少必要参数')
if new_pwd != new_cpwd:
return HttpResponseForbidden('密码不一致')
if not re.match(r'^[0-9A-Za-z]{8,20}$', old_pwd):
return HttpResponseForbidden('密码格式错误')
if not re.match(r'^[0-9A-Za-z]{8,20}$', new_pwd):
return HttpResponseForbidden('密码格式错误')
if not user.check_password(old_pwd):
return render(request, 'user_center_pass.html', {'change_pwd_errmsg': "密码错误"})
# 修改密码
try:
user.set_password(new_pwd)
user.save()
except User.DoesNotExist:
return HttpResponseForbidden('用户不存在')
# 用户退出登录
logout(request)
# 重定向到用户登录界面
response = redirect('/login/')
response.delete_cookie('username')
return response
class UserBrowserHistory(View):
def post(self, request):
"""用户历史浏览商品"""
# 判断用户是否登录
user = request.user
if not user.is_authenticated:
return JsonResponse({'code': RETCODE.SESSIONERR, 'errmsg': '用户未登录'})
# 接收数据
json_data = request.body.decode()
json_dict = json.loads(json_data)
sku_id = json_dict.get('sku_id')
user_id = request.user.id
# 校验数据
try:
SKU.objects.get(id=sku_id)
except SKU.DoesNotExist:
return render(request, '404.html')
# 连接数据库
redis_conn = get_redis_connection('history')
pl = redis_conn.pipeline()
# 去重复
pl.lrem(user_id, 0, sku_id)
# 从头插入
pl.lpush(user_id, sku_id)
# 切片取出
pl.ltrim(user_id, 0, 4)
pl.execute()
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
def get(self, request):
"""渲染用户中心浏览历史"""
user = request.user
redis_conn = get_redis_connection('history')
# 查询当前用户的浏览记录
sku_ids = redis_conn.lrange(user.id, 0, -1)
sku_list = []
for sku_id in sku_ids:
sku = SKU.objects.get(id=sku_id)
sku_list.append({
'id': sku.id,
'name': sku.name,
'price': sku.price,
"default_image_url": sku.default_image.url,
})
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'skus': sku_list})
class FindPasswordView(View):
"""找回用户密码"""
def get(self, request):
return render(request, 'find_password.html')
class ImageToFindPasswordView(View):
"""找回密码之校验图片验证码"""
def get(self, request, username):
# 接收数据
username = username
query_dict = request.GET
image_code = query_dict.get('image_code')
uuid = query_dict.get('uuid')
# 校验数据
if all({username, image_code, uuid}) is False:
return HttpResponseForbidden('缺少必要参数')
if not re.match(r'[a-zA-Z0-9_-]{5,20}', username):
return HttpResponseForbidden('参数有误')
# 判断用户是否存在
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
try:
user = User.objects.get(mobile=username)
except User.DoesNotExist:
return JsonResponse({'code': RETCODE.USERERR, 'errmsg': '用户名或手机号不存在'},
status=constants.USER_MOBILE_ERROR)
redis_conn = get_redis_connection('verify_code')
image_text = redis_conn.get('img_%s' % uuid)
# 判断图片验证码在数据库中是否为空(是否过期)
if image_text is None:
return JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图片验证码已过期'},
status=constants.VERIFY_CODE_ERROR)
# # 删除图片验证码
# redis_conn.delete('img_%s' % uuid)
# 判断图片验证码是否正确
if image_code.upper() != image_text.decode().upper():
return JsonResponse({'code': RETCODE.IMAGECODEERR, 'errmsg': '图形验证码错误'},
status=constants.VERIFY_CODE_ERROR)
# 将token存储到redis数据库
redis_conn.setex('token_%s' % user.mobile, constants.ACCESS_TOKEN__REDIS_EXPIRES, user.username)
# 加密用户手机号
access_token = generate_openid_signature(user.mobile)
# 响应结果
return JsonResponse({'status': RETCODE.OK, 'errmsg': 'OK', 'mobile': user.mobile, 'access_token': access_token})
class SmsCodeToFindPasswordView(View):
"""找回密码之发送短信验证码"""
def get(self, request):
# 接收数据
access_token = request.GET.get('access_token')
mobile = check_openid(access_token)
# 链接redis数据库校验token
redis_conn = get_redis_connection('verify_code')
username = redis_conn.get('token_%s' % mobile)
# 判断是否频繁发送验证码
sms_send_code = redis_conn.get('sms_send_%s' % mobile)
if sms_send_code:
return JsonResponse({'code': RETCODE.THROTTLINGERR, 'errmsg': '访问过于频繁', 'message': '访问过于频繁'},
status=constants.VERIFY_CODE_ERROR)
# 校验token是否过期
if not username:
return JsonResponse({'code': RETCODE.NODATAERR, 'errmsg': '等待超时', 'message': '等待超时,请刷新页面'},
status=constants.VERIFY_CODE_ERROR)
# 校验用户是否存在
try:
user = User.objects.get(mobile=mobile)
except User.DoesNotExist:
return HttpResponseForbidden('用户不存在')
# 发送短信验证码
sms_code = '%06d' % randint(0, 999999)
logger.info(sms_code)
# 实例化pipeline管道对象
pl = redis_conn.pipeline()
# 将短信验证码存储至数据库
# redis_conn.setex('sms_%s' % mobile, contans.SMS_CODE_REDIS_EXPIRES, sms_code)
pl.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 存储验证码标识(过期时间为60秒)
# redis_conn.setex('sms_send_%s' % mobile, contans.SMS_CODE_FLAG_REDIS_EXPIRES, 1)
pl.setex('sms_send_%s' % mobile, constants.SMS_CODE_FLAG_REDIS_EXPIRES // 5, 1)
# 执行管道
pl.execute()
# 使用celery分布式任务队列
# ccp_send_sms_code(mobile, sms_code) # 此调用方式依旧会进程阻塞
ccp_send_sms_code.delay(mobile, sms_code) # 此调用方式只会将函数引用存储至仓库中然后由worker执行
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
class CheckSmsToFindPasswordView(View):
"""找回密码之校验短信验证码"""
def get(self, request, username):
# 接收数据
# 用户名
username = username
# 短信验证码(客户端)
sms_code_cli = request.GET.get('sms_code')
# 判断用户是否存在
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
try:
user = User.objects.get(mobile=username)
except User.DoesNotExist:
return JsonResponse({'code': RETCODE.USERERR, 'errmsg': '用户名或手机号不存在'},
status=constants.USER_MOBILE_ERROR)
# 获取用户手机号
mobile = user.mobile
# 连接redis数据库校验短信验证码
redis_conn = get_redis_connection('verify_code')
# 获取redis中的短信验证码数据
sms_code_server = redis_conn.get('sms_%s' % mobile)
# # # 判断短信验证码是否过期
if not sms_code_server:
return JsonResponse({'code': RETCODE.NODATAERR, 'errmsg': '请输入正确的短信验证码',},
status=constants.VERIFY_CODE_ERROR)
# # 判断短信验证码是否正确
if sms_code_cli != sms_code_server.decode():
return JsonResponse({'code': RETCODE.SMSCODERR, 'errmsg': '短信验证码不正确'},
status=constants.VERIFY_CODE_ERROR)
# 设置access_token
access_token = generate_openid_signature(user.mobile)
return JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK', 'user_id': user.id, 'access_token': access_token})
class SetNewPasswordView(View):
"""设置新密码"""
def post(self, request, user_id):
# 接收数据
json_data = json.loads(request.body.decode())
user_id = user_id
password = json_data.get('password')
password2 = json_data.get('password2')
access_token = json_data.get('access_token')
mobile = check_openid(access_token)
# 校验数据
if all([user_id, password, password2, access_token]) is False:
return HttpResponseForbidden('缺少必要参数')
# 判断用户是否存在
try:
user = User.objects.get(id=user_id, mobile=mobile)
except User.DoesNotExist:
return HttpResponseForbidden('用户校验失败')
if password != password2:
return JsonResponse({'code': RETCODE.PWDERR, 'errmsg': '两次密码不一致', 'message': '短信验证码已过期'},
status=constants.VERIFY_CODE_ERROR)
if not re.match(r'^[0-9A-Za-z]{8,20}$', password):
return JsonResponse({'code': RETCODE.PWDERR, 'errmsg': '密码格式有误', 'message': '密码格式有误'},
status=constants.VERIFY_CODE_ERROR)
if not re.match(r'^[0-9A-Za-z]{8,20}$', password2):
return JsonResponse({'code': RETCODE.PWDERR, 'errmsg': '密码格式有误', 'message': '密码格式有误'},
status=constants.VERIFY_CODE_ERROR)
# 修改用户密码
user.set_password(password)
user.save()
return JsonResponse({'code': RETCODE.OK, 'errmsg': '修改密码成功'})
| {"/meiduo_mall/meiduo_mall/apps/contents/crons.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"], "/meiduo_mall/meiduo_mall/apps/oauth/views.py": ["/meiduo_mall/meiduo_mall/apps/oauth/utils.py"], "/meiduo_mall/meiduo_mall/apps/goods/views.py": ["/meiduo_mall/meiduo_mall/apps/goods/utils.py"], "/meiduo_mall/meiduo_mall/apps/contents/views.py": ["/meiduo_mall/meiduo_mall/apps/contents/utils.py"]} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.