text stringlengths 38 1.54M |
|---|
d1={
101:"RaviKumar",
102:"Vishnu"}
print(d1[101])
for i in d1:
print(d1[i])
print(i,"\t",d1[i]) |
import json
with open("C:\\Users\\Administrator\\PycharmProjects\\untitled\\data_file\\user_info.json","r")as f:
data=f.read()
user_list=json.loads(data)
print(user_list) |
file_open = open("C:\\Users\\Ramya\\QAdata_as_of_Feb172011\\python_problems\\other_python_prob\\agedata.csv", 'r')
dict = {}
for i in file_open:
print i
x = i.rstrip('\n').split(',')
print "x", x
key = x[0]
value = x[1]
# print key, value
if dict.has_key(key):
dict[key].append(value)
else:
dict[key] = [value]
print dict
file_open.close()
|
"""
Named Entity Recognition
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import torch
from .common.hparams import HParams
from .data.conll import conll2003_dataset
from .data.nyt import nyt_ingredients_ner_dataset
from .tasks.sequence_tagging import TransformerTagger
from .tasks.sequence_tagging import BiLSTMTagger
from .tasks.sequence_tagging import hparams_tagging_base
from .tasks.sequence_tagging import train, evaluate, infer, interactive
from .common.prefs import PREFS
from .common.info import Info
import sys, os
import logging
from functools import partial
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
Info(__doc__).models(TransformerTagger, BiLSTMTagger).datasets(conll2003_dataset, nyt_ingredients_ner_dataset)
PREFS.defaults(
data_root='./.data/conll2003',
data_train='eng.train.txt',
data_validation='eng.testa.txt',
data_test='eng.testb.txt',
early_stopping='highest_5_F1'
)
# Default dataset is Conll2003
conll2003 = partial(conll2003_dataset, 'ner',
root=PREFS.data_root,
train_file=PREFS.data_train,
validation_file=PREFS.data_validation,
test_file=PREFS.data_test)
nyt_ingredients_ner = partial(nyt_ingredients_ner_dataset)
# Hyperparameter configuration for NER tasks
def hparams_transformer_ner():
hparams = hparams_tagging_base()
return hparams.update(
embedding_size_char=16,
embedding_size_char_per_word=100,
num_heads=4,
attention_key_channels=0, # Take hidden size
attention_value_channels=0, # Take hidden size
filter_size = 128,
filter_size_char = 64,
input_dropout=0.2,
attention_dropout=0.2,
relu_dropout=0.2,
learning_rate_decay='noam_step',
learning_rate_warmup_steps=500,
use_crf=True
)
def hparams_lstm_ner():
hparams = hparams_tagging_base()
return hparams.update(
embedding_size_char=25,
embedding_size_char_per_word=25,
hidden_size=100,
learning_rate=0.05,
learning_rate_decay='noam_step',
learning_rate_warmup_steps=100,
num_hidden_layers=1,
dropout=0.5,
use_crf=True
)
hparams_map = {
TransformerTagger: hparams_transformer_ner(),
BiLSTMTagger: hparams_lstm_ner()
}
# Add HParams mapping
train = partial(train, hparams_map=hparams_map)
|
import numpy as np
import pandas as pd
#import matplotlib.pyplot as plt
import re
from tqdm import tqdm
import time
import os,sys
from collections import Counter
import punctuation
import codecs
import pyIO
import datetime
import tools
import tools
import fasttext
def get_word_by_filename(filename):
for i in range(10):
if filename.find('_cat%d_'%i) != -1:
return 'cat%d'%i
return 'xxx'
classifier = None
def get_word_by_fastText(text):
global classifier
if classifier is None:
classifier = fasttext.load_model('model_classify.bin')
labels = classifier.predict_proba([text, ], 1)
word = 'cat%s'%(labels[0][0][0].replace('__label__', ''))
print('get_word_by_fastText labels:', labels, ', word:', word, ', text:', text)
return word
def get_word_probe_by_fastText(text):
global classifier
if classifier is None:
classifier = fasttext.load_model('model_classify.bin')
labels = classifier.predict_proba([text, ], k=2)
# word = 'cat%s'%(labels[0][0].replace('__label__', ''))
# print('get_word_by_fastText labels:', labels, ', word:', word, ', text:', text)
#
# return (word, probe)
return labels[0]
def get_label_bye_filename(filename):
for i in range(10):
if filename.find('cat%d_'%i) != -1:
return '__label__%d , '%i
return 'xxx'
def save_file_by_cat_filename(filename, i):
dst_filename = "raw_data/dir_step05/step05_res_%02d"%i + filename.split('/')[-1].replace(".txt", "_res.txt")
res_list = []
c_list = pyIO.get_content(filename)
word = get_word_by_filename(filename)
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 'filename:', filename)
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 'dst_filename:', dst_filename)
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 'word:', word, '\n')
for c in c_list:
res = word + ' ' + c
res_list.append(res)
pyIO.save_to_file("\n".join(res_list), dst_filename)
def save_file_by_cat_fasttext(filename, i):
dst_filename = "tmp/step05/step05_res_%02d"%i + filename.split('/')[-1].replace(".txt", "_res.txt")
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 'filename:', filename)
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 'dst_filename:', dst_filename)
res_list = []
c_list = pyIO.get_content(filename)
for c in c_list:
word = get_word_by_fastText(c)
res = word + ' ' + c
# print('res:', res, ',word:', word)
# if res.find('cat1 cat1') != -1:
# print('error!')
# sys.exit(0)
res_list.append(res)
pyIO.save_to_file("\n".join(res_list), dst_filename)
if __name__ == '__main__':
filename_list = tools.get_filename_list('raw_data/dir_step04')
filename_list.sort()
print('filename_list:', filename_list)
operation = 'train'
if len(sys.argv) > 2:
operation = sys.argv[2]
for i,filename in enumerate(filename_list):
print('i, filename:', i, filename)
if operation == 'test':
save_file_by_cat_fasttext(filename, i)
elif operation == 'train':
save_file_by_cat_filename(filename, i)
else:
print('error operation:', operation)
|
class Edge:
def __init__(self):
"""nothing to initialize, assume set gets called right after"""
def print_state(self):
print "edge:", "[", self.i, self.j, "] -> c:", self.c, " f: ", self.f
def set(self, i, j, c=0, f=0):
self.i = i
self.j = j
self.c = c
self.f = 0
|
# -*- coding: utf-8 -*-
from z3 import *
q1, q2, q3, q4 = Reals('q1 q2 q3 q4')
p = Real('p')
R, T, S, P = Reals('R T S P')
f0 = -P*p + P + T*p
f1 = (P*p - P + R*p**2 - R*p - S*p**2 + 2*S*p - S - T*p)/(p - 2)
f2 = (-P*p + P + R*p**2 - S*p**2 + S*p + T*p)/(p + 1)
f3 = -P*p/2 + P/2 + R*p/2 - S*p/2 + S/2 + T*p/2
f4 = -P*p + P + T*p
f5 = -P*p**2 + P*p - R*p**2 + R*p + S*p**2 - 2*S*p + S + T*p**2
f6 = -P*p/2 + P/2 + R*p/2 - S*p/2 + S/2 + T*p/2
f7 = -(P*p**2 - P*p - R*p + S*p - S - T*p**2)/(p + 1)
f8 = -P*p + P + T*p
f9 = -P*p/2 + P/2 + R*p/2 - S*p/2 + S/2 + T*p/2
f10 = P*p**2 - 2*P*p + P + R*p**2 - S*p**2 + S*p - T*p**2 + T*p
f11 = -(P*p**2 - 2*P*p + P + R*p - S*p + S - T*p**2 + T*p)/(p - 2)
f12 = R*p - S*p + S
f13 = R*p - S*p + S
f14 = R*p - S*p + S
f15 = R*p - S*p + S
exprs = [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15]
# check for greatest
check_index = 0
s = Solver()
s.add(T>R, R>P, P>S)
s.add(2*R > T+S)
s.add(p>0, p<1)
s.add(q1>0,q1<1)
s.add(q2>0,q2<1)
s.add(q3>0,q3<1)
s.add(q4>0,q4<1)
for i in range(len(exprs)):
if (i == check_index):
continue
s.push()
s.add(exprs[check_index] < exprs[i])
result = s.check()
if result == sat:
print(i,s.model())
else:
print(i,"unsat",s)
s.pop() |
from unittest.mock import patch
import pytest
from app.dao import DAO
from app.models.aluno import Aluno
def test_get():
dao = DAO(Aluno())
dao.get()
assert isinstance(dao, DAO)
def test_insert():
aluno = DAO(Aluno(nome="Teste")).insert()
assert isinstance(aluno, Aluno)
assert aluno.nome == "Teste"
def test_insert_throw_exception():
dao = DAO(Aluno(nome="Teste"))
with patch(
"app.models.db.db.session.add", side_effect=Exception("Fake exception")
):
with pytest.raises(Exception):
dao.insert()
def test_update():
aluno = DAO(Aluno(nome="Teste")).insert()
assert isinstance(aluno, Aluno)
aluno.email = "teste@teste.com"
aluno_atualizado = DAO(aluno).update()
assert isinstance(aluno_atualizado, Aluno)
assert aluno_atualizado.email == "teste@teste.com"
def test_update_throw_exception():
dao = DAO(Aluno(nome="Teste"))
with patch(
"app.models.db.db.session.add", side_effect=Exception("Fake exception")
):
with pytest.raises(Exception):
dao.update()
def test_delete():
aluno = DAO(Aluno(nome="Teste")).insert()
assert isinstance(aluno, Aluno)
assert DAO(aluno).delete()
def test_delete_throw_exception():
dao = DAO(Aluno(nome="Teste"))
with patch(
"app.models.db.db.session.delete",
side_effect=Exception("Fake exception"),
):
with pytest.raises(Exception):
dao.delete()
|
##########
#Question#
##########
'''
URL: https://leetcode.com/problems/sort-array-by-increasing-frequency/
Given an array of integers nums, sort the array in increasing order based on the frequency of the values. If multiple values have the same frequency, sort them in decreasing order.
Return the sorted array.
Example 1:
Input: nums = [1,1,2,2,2,3]
Output: [3,1,1,2,2,2]
Explanation: '3' has a frequency of 1, '1' has a frequency of 2, and '2' has a frequency of 3.
Example 2:
Input: nums = [2,3,1,3,2]
Output: [1,3,3,2,2]
Explanation: '2' and '3' both have a frequency of 2, so they are sorted in decreasing order.
Example 3:
Input: nums = [-1,1,-6,4,5,-6,1,4,1]
Output: [5,-1,4,4,-6,-6,1,1,1]
Constraints:
1 <= nums.length <= 100
-100 <= nums[i] <= 100
'''
##########
#Solution#
##########
class Solution:
def frequencySort(self, nums: List[int]) -> List[int]:
if len(nums) <= 1:
return nums
freq_nums = {}
for num in nums:
freq_nums[num] = freq_nums.get(num, 0) + 1
rev_freq_nums = {}
for k,v in freq_nums.items():
if v not in rev_freq_nums.keys():
rev_freq_nums[v] = [k]
else:
rev_freq_nums[v].append(k)
result = []
for key, value in sorted(rev_freq_nums.items()):
values= list(value)
if len(values) == 1:
for item in values:
for i in range(0,key):
result.append(item)
else:
for item in sorted(values, reverse=True):
for i in range(0,key):
result.append(item)
return result
|
from django.contrib.contenttypes.models import ContentType
from django.db import models
from django.urls import reverse
from mptt.fields import TreeForeignKey
from mptt.models import MPTTModel
from django.utils.translation import ugettext_lazy as _
from django_comments.abstracts import CommentAbstractModel
class OmsComment(CommentAbstractModel, MPTTModel):
parent = TreeForeignKey(
"self",
verbose_name=_("Родительский комментарий"),
on_delete=models.CASCADE,
null=True,
blank=True,
related_name='children')
update = models.DateTimeField(_("Изменен"), auto_now=True)
published = models.BooleanField(_("Отображать?"), default=True)
# def delete_comment(self):
# return reverse('delete_comment', kwargs={'pk': self.id})
#
# def edit_comment(self):
# return reverse('edit_comment', kwargs={'pk': self.id})
#
# def answer_comment(self):
# return reverse('answer_comment', kwargs={'pk': self.id})
|
Given a string of both uppercase and lowercase alphabets, the task is to print the string with alternate occurrences of any character dropped(including space and consider upper and lowercase as same).
Input:
First line consists of T test cases. First line of every test case consists of String S.
Output:
Single line output, print the updated string.
Constraints:
1<=T<=100
1<=|String|<=10000
Example:
Input:
2
It is a long day dear.
Geeks for geeks
code:
t=int(input())
while t>0:
txt=input()
ls=[]
for x in txt:
s=x.lower()
if s in ls:
ls.remove(s)
continue
else:
ls.append(s)
print(x,end="")
print()
t-=1
|
def welcome():
print("You are welcome!")
welcome()
def Salutation(name):
print('Welcome ' + name + " !")
Salutation(input('what is your name: ')) |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
from alipay.aop.api.constant.ParamConstants import *
class AlCollectionReceiveBaseInfoDTO(object):
def __init__(self):
self._collection_title = None
self._memo = None
self._order_id = None
self._source_sys = None
self._template_id = None
@property
def collection_title(self):
return self._collection_title
@collection_title.setter
def collection_title(self, value):
self._collection_title = value
@property
def memo(self):
return self._memo
@memo.setter
def memo(self, value):
self._memo = value
@property
def order_id(self):
return self._order_id
@order_id.setter
def order_id(self, value):
self._order_id = value
@property
def source_sys(self):
return self._source_sys
@source_sys.setter
def source_sys(self, value):
self._source_sys = value
@property
def template_id(self):
return self._template_id
@template_id.setter
def template_id(self, value):
self._template_id = value
def to_alipay_dict(self):
params = dict()
if self.collection_title:
if hasattr(self.collection_title, 'to_alipay_dict'):
params['collection_title'] = self.collection_title.to_alipay_dict()
else:
params['collection_title'] = self.collection_title
if self.memo:
if hasattr(self.memo, 'to_alipay_dict'):
params['memo'] = self.memo.to_alipay_dict()
else:
params['memo'] = self.memo
if self.order_id:
if hasattr(self.order_id, 'to_alipay_dict'):
params['order_id'] = self.order_id.to_alipay_dict()
else:
params['order_id'] = self.order_id
if self.source_sys:
if hasattr(self.source_sys, 'to_alipay_dict'):
params['source_sys'] = self.source_sys.to_alipay_dict()
else:
params['source_sys'] = self.source_sys
if self.template_id:
if hasattr(self.template_id, 'to_alipay_dict'):
params['template_id'] = self.template_id.to_alipay_dict()
else:
params['template_id'] = self.template_id
return params
@staticmethod
def from_alipay_dict(d):
if not d:
return None
o = AlCollectionReceiveBaseInfoDTO()
if 'collection_title' in d:
o.collection_title = d['collection_title']
if 'memo' in d:
o.memo = d['memo']
if 'order_id' in d:
o.order_id = d['order_id']
if 'source_sys' in d:
o.source_sys = d['source_sys']
if 'template_id' in d:
o.template_id = d['template_id']
return o
|
class Person(object):
__count = 0
@staticmethod
def how_many():
return Person.__count
def __init__(self, name):
self.name = name
Person.__count = Person.__count + 1
print(Person.how_many())
p1 = Person('Bob')
print(Person.how_many())
|
import logging
import os
import boto3
from botocore.exceptions import ClientError
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_dynamodb.adapter import DynamoDbAdapter
ddb_region = os.environ.get('DYNAMODB_PERSISTENCE_REGION')
ddb_table_name = os.environ.get('DYNAMODB_PERSISTENCE_TABLE_NAME')
ddb_resource = boto3.resource('dynamodb', region_name=ddb_region)
dynamodb_adapter = DynamoDbAdapter(table_name=ddb_table_name, create_table=False, dynamodb_resource=ddb_resource)
def create_presigned_url(object_name):
"""Generate a presigned URL to share an S3 object with a capped expiration of 60 seconds
:param object_name: string
:return: Presigned URL as string. If error, returns None.
"""
s3_client = boto3.client('s3',
region_name=os.environ.get('S3_PERSISTENCE_REGION'),
config=boto3.session.Config(signature_version='s3v4',s3={'addressing_style': 'path'}))
try:
bucket_name = os.environ.get('S3_PERSISTENCE_BUCKET')
response = s3_client.generate_presigned_url('get_object',
Params={'Bucket': bucket_name,
'Key': object_name},
ExpiresIn=60*1)
except ClientError as e:
logging.error(e)
return None
# The response contains the presigned URL
return response
def get_word_to_practise(handler_input):
#handler_input -> String
session_attr = handler_input.attributes_manager.session_attributes
currentWordList = session_attr["words"]
counter = session_attr["nextWordIndex"]
if len(currentWordList) == 0:
return "0"
elif counter < len(currentWordList)-1:
currentWord = currentWordList[counter]
counter += 1
session_attr["nextWordIndex"] = counter
return currentWord
elif counter == len(currentWordList)-1:
currentWord = currentWordList[counter]
counter+=1
session_attr["nextWordIndex"] = counter
return currentWord
else:
return "1"
def create_word_report(handler_input):
#handler_input -> dict
session_attr = handler_input.attributes_manager.session_attributes
currentWordList = session_attr["words"]
report = session_attr["wordReport"]
for word in currentWordList:
report[word] = 0
return report
def sortReport(report):
#dict -> list
""" This helper function will take a given wordReport and return a list of tuple containing the individual word and the incorrect attempts. """
sortedReport = sorted(report.items(),key = lambda t: t[1],reverse=True)
#print(sortedReport)
return sortedReport
def get_ordinal_indicator(handler_input,counter):
#handler_input, Int -> String
"""Return st, nd, rd, th ordinal indicators according to counter."""
session_attr = handler_input.attributes_manager.session_attributes
if len(session_attr["words"]) -1 == counter:
return "last"
counter +=1
if counter == 1:
return "1st"
elif counter == 2:
return "2nd"
elif counter == 3:
return "3rd"
elif counter >20:
return "next"
else:
return "{}th".format(str(counter))
def get_spelling_for_word(word):
# String -> String
#use ssml tag <break> to add pause after each letter
spelling = "<break time ='0.5s'></break>".join(word)
#spelling = '.'.join(word)
return spelling
def get_phoenetics_for_letter(letter):
# String -> String
"""Helper function to get phonetic sound of individual letter in the word."""
phonemes =''
phonemes = letterPhonemeDict[letter]
return phonemes
def get_phonetic_spelling(word):
#String -> String
""" This function will take a given word and construct a phonetic spelling which is the combination of phonetic sound of each letter in the word."""
spelling = ""
for letter in word:
spelling = spelling + get_phoenetics_for_letter(letter) +" <break time ='0.3s'></break>"
return spelling
#This Python Dictionary holds the phonics sound of each letter.
letterPhonemeDict = {
"a": "ah",
"b": "buh",
"c": "cuh",
"d": "duh",
"e": "eh",
"f": "fuh",
"g": "guh",
"h": "huh",
"i": "eeh",
"j": "jawh",
"k": "cuh",
"l": "ul",
"m": "mmm",
"n": "uhn",
"o": "ohh",
"p": "pppuh",
"q": "koo",
"r": "err",
"s": "sshh",
"t": "ttuh",
"u": "uh",
"v": "vvvooh",
"w": "wuh",
"x": "kusssshhh",
"y": "yuh",
"z": "zzizz"
}
|
# Generated by Django 3.2 on 2021-04-20 09:03
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('articles', '0006_comment_article'),
]
operations = [
migrations.AlterField(
model_name='comment',
name='body',
field=models.CharField(max_length=150),
),
]
|
from qt import *
from kdeui import *
from kdecore import *
from kfile import *
from KPyBTMain.Forms import KPyBTCfgPageGlobalsBase
class KPyBTCfgPageGlobals(KPyBTCfgPageGlobalsBase):
def __init__(self,parent,config):
KPyBTCfgPageGlobalsBase.__init__(self,parent)
self.connect(self.btnTorrentDir,SIGNAL("clicked()"),self.slotTorrentDir)
self.connect(self.btnDownloadDir,SIGNAL("clicked()"),self.slotDownloadDir)
def slotTorrentDir(self):
dirName=KFileDialog.getExistingDirectory(self.kcfg_TorrentDirectory.text(),self,"Torrent Directory")
self.kcfg_TorrentDirectory.setText(dirName)
def slotDownloadDir(self):
dirName=KFileDialog.getExistingDirectory(self.kcfg_DownloadDirectory.text(),self,"Torrent Directory")
self.kcfg_DownloadDirectory.setText(dirName)
|
# Generated by Django 2.1.3 on 2018-12-04 09:25
import datetime
from django.db import migrations, models
from django.utils.timezone import utc
class Migration(migrations.Migration):
dependencies = [
('messenger', '0002_auto_20181204_1447'),
]
operations = [
migrations.AlterField(
model_name='contact',
name='email',
field=models.EmailField(max_length=70),
),
migrations.AlterField(
model_name='contact',
name='sent_date',
field=models.DateTimeField(blank=True, default=datetime.datetime(2018, 12, 4, 9, 25, 22, 917601, tzinfo=utc), null=True, verbose_name='Sent date'),
),
]
|
from dfa import DFARuleBook, DFADesign
class FARule(object):
def __init__(self, state, character, new_state):
self.state = state
self.character = character
self.new_state = new_state
def applies_to(self, state, character):
return self.state == state and self.character == character
def follow(self):
return self.new_state
def __str__(self):
return "#<FARule {} -- {} --> {}>".format(self.state, self.character,
self.new_state)
class NFARulebook(object):
def __init__(self, rules):
self.rules = rules
def next_state(self, states, character):
n_states = []
for state in states:
s = self.follow_rules_for(state, character)
n_states += s
return set(n_states)
def follow_rules_for(self, state, character):
return [rule.follow() for rule in self.rule_for(state, character)]
def rule_for(self, state, character):
return [
rule for rule in self.rules if rule.applies_to(
state, character)]
def follow_free_moves(self, states):
more_states = self.next_state(states, None)
if more_states.issubset(states):
return states
else:
return self.follow_free_moves(more_states | states)
def alphabet(self):
return list(set([rule.character for rule in self.rules if
rule.character]))
class NFA(object):
def __init__(self, current_state, accept_state, rulebook):
self.accept_state = accept_state
self.rulebook = rulebook
self.current_state = frozenset(
self.rulebook.follow_free_moves(current_state))
def accept(self):
return bool(self.current_state & set(self.accept_state))
def read_string(self, string):
for s in string:
self.read_character(s)
def read_character(self, character):
self.current_state = self.rulebook.next_state(self.current_state,
character)
self.current_state = self.rulebook.follow_free_moves(
self.current_state)
class NFADesign(object):
def __init__(self, start_state, accept_state, rulebook):
self.start_state = start_state
self.accept_state = accept_state
self.rulebook = rulebook
def is_accepting(self, string):
nfa = self.to_nfa()
nfa.read_string(string)
return nfa.accept()
def to_nfa(self, current_state=None):
if not current_state:
current_state = {self.start_state}
return NFA(current_state, self.accept_state, self.rulebook)
class NFASimulation(object):
def __init__(self, nfa_design):
self.nfa_design = nfa_design
def next_state(self, state, character):
nfa = self.nfa_design.to_nfa(state)
nfa.read_character(character)
return frozenset(nfa.current_state)
def rules_for(self, state):
return [FARule(state, character, self.next_state(state, character)) for
character in self.nfa_design.rulebook.alphabet()]
def discover_states_and_rules(self, states):
rules = []
for state in states:
rules += self.rules_for(state)
more_states = set([rule.follow() for rule in rules])
if more_states.issubset(states):
return [states, rules]
else:
return self.discover_states_and_rules(states | more_states)
def to_dfa_design(self):
start_state = self.nfa_design.to_nfa().current_state
states, rules = self.discover_states_and_rules({start_state})
accept_state = [state for state in
states if self.nfa_design.to_nfa(state).accept()]
return DFADesign(start_state, accept_state, DFARuleBook(rules))
if __name__ == "__main__":
rulebook = NFARulebook(
[
FARule(1, 'a', 1), FARule(1, 'a', 2), FARule(1, None, 2),
FARule(2, 'b', 3),
FARule(3, 'b', 1), FARule(3, None, 2)
]
)
nfa_design = NFADesign(1, [3], rulebook)
print(nfa_design)
print(nfa_design.to_nfa().current_state)
print(nfa_design.to_nfa({2}).current_state)
print(nfa_design.to_nfa({3}).current_state)
nfa = nfa_design.to_nfa({2, 3})
nfa.read_character('b')
print(nfa.current_state)
print("-" * 100)
simulation = NFASimulation(nfa_design)
print(simulation.next_state({1, 2}, 'a'))
print(simulation.next_state({1, 2}, 'b'))
print(simulation.next_state({3, 2}, 'b'))
print(simulation.next_state({1, 3, 2}, 'b'))
print(simulation.next_state({1, 3, 2}, 'a'))
print("-" * 100)
print(rulebook.alphabet())
rules = simulation.rules_for(frozenset({1, 2}))
for r in rules:
print(r)
rules = simulation.rules_for(frozenset({3, 2}))
for r in rules:
print(r)
print("-" * 100)
start_state = nfa_design.to_nfa().current_state
print(start_state)
states, rules = simulation.discover_states_and_rules(set([start_state]))
print(states)
for r in rules:
print(r)
print("-" * 100)
print(nfa_design.to_nfa({1, 2}).accept())
print(nfa_design.to_nfa({3, 2}).accept())
print("-" * 100)
dfa_design = simulation.to_dfa_design()
print(dfa_design.is_accepting('aaa'))
print(dfa_design.is_accepting('aab'))
print(dfa_design.is_accepting('bbbabb'))
|
from django.conf.urls import patterns, include, url
from rest_framework import routers
from users import views as users_view
from couples import views as couples_view
# from django.contrib import admin
# admin.autodiscover()
router = routers.SimpleRouter(trailing_slash=False)
router.register(r'users', users_view.UserListCreateView)
router.register(r'users', users_view.UserViewSet)
router.register(r'couples', couples_view.CoupleListView)
router.register(r'tokens', users_view.TokensViewSet)
urlpatterns = patterns('',
# Examples:
# url(r'^$', 'VProject.views.home', name='home'),
# url(r'^blog/', include('blog.urls')),
url(r'^', include(router.urls)),
#url(r'^admin/', include(admin.site.urls)),
)
|
import pychromecast
import requests
import random
from time import sleep
from requests.auth import HTTPBasicAuth
LFM_API_KEY = '57ee3318536b23ee81d6b27e36997cde'
SPOTIFY_API_CLIENT = 'b5c1e08b7d2846edb40ad73eadcbce95'
SPOTIFY_API_SECRET = '6f92952220eb4b36975d14e928226db2'
def getTopArtists(username):
request = requests.get('http://ws.audioscrobbler.com/2.0/', params={'format': 'json', 'api_key': LFM_API_KEY, 'method': 'user.gettopartists', 'user': username})
print request.json()
return request.json()['topartists']['artist']
def getSpotifyToken():
request = requests.post('https://accounts.spotify.com/api/token', data={'grant_type': 'client_credentials'}, auth=HTTPBasicAuth(SPOTIFY_API_CLIENT, SPOTIFY_API_SECRET))
return request.json()['access_token']
def getSpotifyArtistId(bearer, artist):
search = requests.get('https://api.spotify.com/v1/search', headers={'Authorization': 'Bearer ' + bearer}, params={'q': artist['name'], 'type': 'artist', 'limit': 1})
return search.json()['artists']['items'][0]['id']
def getSpotifySeed(bearer, artists):
choice = []
for i in xrange(0, 5):
choice.append(random.choice(artists))
seed = map(lambda c, bearer=bearer: getSpotifyArtistId(bearer, c), choice)
return seed
def getRecommendations(bearer, seed):
seed_artists = reduce(lambda s, a: s + a + ',', seed, '')[0:-1]
recs = requests.get('https://api.spotify.com/v1/recommendations', headers={'Authorization': 'Bearer ' + bearer}, params={'market': 'FR', 'seed_artists': seed_artists, 'limit': 100})
tracks = map(lambda t: t['id'], recs.json()['tracks'])
return tracks
def queueInMopidy(tracks):
data = {
'id': 500,
'method': 'core.tracklist.add',
'jsonrpc': '2.0',
'params': {
'uris': map(lambda t: 'spotify:track:' + t, tracks)
}
}
print data
requests.post('http://raspberrypi.local:6680/mopidy/rpc', json={
'id': 409,
'method': 'core.tracklist.clear',
'jsonrpc': '2.0',
'params': {}
})
request = requests.post('http://raspberrypi.local:6680/mopidy/rpc', json=data)
requests.post('http://raspberrypi.local:6680/mopidy/rpc', json={
'id': 501,
'method': 'core.playback.play',
'jsonrpc': '2.0',
'params': {}
})
print request.json()
def launchCast(uuid):
casts = pychromecast.get_chromecasts()
cast = filter(lambda x: str(x.uuid) == uuid, casts)[0]
print cast
cast.media_controller.play_media('http://192.168.2.1:8000/stream', 'audio/vorbis')
sleep(5)
if __name__ == '__main__':
bearer = getSpotifyToken()
top = getTopArtists('hugoatease')
seed = getSpotifySeed(bearer, top)
tracks = getRecommendations(bearer, seed)
queueInMopidy(tracks)
launchCast('0c63adba-2bab-cfef-697d-bf5167f98e31')
|
# -*- coding: utf-8 -*-
import logging
from utils import mongo
from utils import config
from utils import entity_resolver
class ParseMeetings():
def __init__(self, **kwargs):
self._logger = logging.getLogger('spud')
self.db = mongo.MongoInterface()
self.resolver = entity_resolver.MasterEntitiesResolver()
self.lords_titles = config.lords_titles
self.secretarial_titles = ["secretaries", "secretary"]
self.ministerial_titles = "ministerial"
self.PREFIX = "meetings"
if kwargs["refreshdb"]:
self.db.drop("%s_parse" % self.PREFIX)
def run(self):
self._logger.debug("Parsing Ministerial Meetings")
_all_meetings = self.db.fetch_all("%s_scrape" % self.PREFIX, paged=False)
titles = []
for doc in _all_meetings:
titles.append(doc["title"])
if any(title in doc["title"] for title in self.secretarial_titles):
#self._parse_secretarial(doc)
pass
if "ministerial" in doc["title"].lower():
self._parse_ministerial(doc)
print "\n\ntitle count:", len(set(titles))
def _parse_ministerial(self, meeting):
orgs = []
host = {}
if "organisation" in meeting:
orgs = self._parse_organisation(meeting["organisation"].strip())
for org in orgs:
date = None
purpose = None
if "name" in meeting:
host = self._parse_host(meeting["name"].strip())
if "date" in meeting and len(meeting["date"]) == 10 \
and "-" in meeting["date"]:
date = meeting["date"]
if "purpose" in meeting:
purpose = meeting["purpose"]
if host["position"]:
position = self._resolve_position(host["position"])
else:
position = None
entry = {
"title": meeting["title"],
"department": meeting["department"],
"host_name": host["name"],
"host_position": position,
"organisation": org,
"date": date,
"source": meeting["source"],
"purpose": purpose,
"published_at": meeting["published_at"],
"meeting_type": "Ministerial Meetings",
}
self._logger.debug("... %s" % org)
self._logger.debug("--> %s x %s\n" % (host["name"], position))
self.db.save("%s_parse" % self.PREFIX, entry)
def _parse_organisation(self, org_string):
separators = ["/", ",", ";", "\n", "-"]
organisations = []
if any(sep in org_string for sep in separators):
for sep in separators:
if sep in org_string:
orgs = org_string.split(sep)
if len(orgs) == 2 and sep == ",":
organisations.append(org_string)
else:
for org in orgs:
if len(org.strip()) > 1:
name = self._resolve_influencer(org.strip())
organisations.append(name)
break
else:
name = self._resolve_influencer(org_string.strip())
organisations.append(name)
return organisations
def _parse_host(self, name_string):
positions = ["minister", "secretary"]
name, position = self._synatic_parse(name_string)
if not name:
name, position = self._entity_parse(name_string)
# if still name not found see if it's just the position
if not name:
if any(pos in name_string.lower() for pos in positions):
position = name_string
return {"name": name, "position": position}
def _synatic_parse(self, name_string):
name_string = u"{}".format(name_string)
rear, front = {}, {}
name, position = None, None
separators = [" - ", u" \x96 ", ";", ","]
# try finding the name using the string syntax
if any(sep in name_string for sep in separators):
for sep in separators:
if sep in name_string:
sent = name_string.split(sep)
# check end of string
name = self._resolve_politician(sent[-1].strip())
rear = {"name": name, "sep": sep}
if name:
break
if not name:
# check beginning of string
name = self._resolve_politician(sent[0].strip())
front = {"name": name, "sep": sep}
if name:
break
# if name found try get the position
if name:
if rear["name"]:
sent = name_string.split(rear["sep"])
position = rear["sep"].join(sent[:-1]).strip()
elif front["name"]:
sent = name_string.split(front["sep"])
position = front["sep"].join(sent[1:]).strip()
return name, position
def _entity_parse(self, name_string):
position = None
name = self._resolve_politician(name_string)
if name:
name_split = name.split(" ")
position = name_string.split(name_split[0])[0]
return name, position
def _resolve_influencer(self, candidate):
name = None
if "mp" in candidate.lower():
name = self._resolve_politician(candidate)
if not name:
name = self.resolver.find_influencer(candidate)
return candidate if name is None else name
def _resolve_politician(self, candidate):
if any(title in candidate for title in self.lords_titles):
name = self.resolver.find_lord(candidate)
else:
name = self.resolver.find_mp(candidate)
return name
def _resolve_name(self, candidate):
name = self.resolver.get_entities(candidate)
return candidate if name is None else name
def _resolve_position(self, candidate):
name = self.resolver.find_position(candidate)
return candidate if name is None else name
def parse(**kwargs):
ParseMeetings(**kwargs).run() |
# from datetime import date, datetime
# from unittest import skip
# from unittest.mock import MagicMock, patch
# from dateutil.relativedelta import relativedelta
# from django.test import TestCase
# from balances.models import PeriodBalance
# from balances.strategies.periods import (BaseStrategy, ChangedAccountStrategy, CreateStrategy, DeleteStrategy,
# UpdateStrategy)
# from balances.tests.helpers import PeriodBalanceWithTransactionsFactory
# from transactions.models import Account, Transaction
# from transactions.tests.base_test import BaseTestHelper
# class StrategyTestMixin:
# def setUp(self):
# self.user = self.create_user(email='testuser@test.com', password='testing')[0]
# self.account = self.create_account(current_effective_balance=100, current_real_balance=100)
# self.strategy = self.strategy_cls(None)
# def create_period_balance(self, start, end, account=None):
# PeriodBalance.objects.create(
# account=account or self.account,
# start_date=start,
# end_date=end,
# closed_effective_value=0,
# closed_real_value=0
# )
# def mock_transaction_instance(self, **kwargs):
# if 'value' in kwargs:
# kwargs.update({ 'real_value': kwargs['value'] if kwargs['payment_date'] else 0 })
# self.strategy.instance = MagicMock(account=self.account, **kwargs)
# def assert_account_balances(self, effective, real):
# account = Account.objects.get(pk=self.account.id)
# self.assertEqual(effective, account.current_effective_balance)
# self.assertEqual(real, account.current_real_balance)
# class BaseStrategyTestCase(StrategyTestMixin, TestCase, BaseTestHelper):
# strategy_cls = BaseStrategy
# @patch.multiple(BaseStrategy, __abstractmethods__=set()) #Allow instantiate abstract class
# def setUp(self):
# super().setUp()
# def test_get_due_lower_date(self):
# self.mock_transaction_instance(
# due_date=date(2014, 8, 22),
# payment_date=date(2017, 1, 1)
# )
# self.assertEqual(self.strategy.get_lower_date(), self.strategy.instance.due_date)
# def test_get_payment_lower_date(self):
# self.mock_transaction_instance(
# due_date=date(2014, 8, 22),
# payment_date=date(2010, 1, 1)
# )
# self.assertEqual(self.strategy.get_lower_date(), self.strategy.instance.payment_date)
# def test_get_lower_date_payment_none(self):
# self.mock_transaction_instance(
# due_date=date(2014, 8, 22),
# payment_date=None
# )
# self.assertEqual(self.strategy.get_lower_date(), self.strategy.instance.due_date)
# def test_is_from_previous_period_returns_true(self):
# self.mock_transaction_instance(
# due_date=date(2018, 1, 22),
# payment_date=None
# )
# self.create_period_balance(date(2018, 1, 1), date(2018, 1, 31))
# self.assertTrue(self.strategy.is_from_previous_period())
# def test_is_from_previous_period_returns_false(self):
# self.mock_transaction_instance(
# due_date=date(2018, 2, 22),
# payment_date=None
# )
# self.create_period_balance(date(2018, 1, 1), date(2018, 1, 31))
# self.assertFalse(self.strategy.is_from_previous_period())
# def test_is_from_previous_period_another_account_returns_false(self):
# another_account = self.create_account(name='another')
# self.create_period_balance(date(2018, 1, 1), date(2018, 1, 31), another_account)
# self.mock_transaction_instance(
# due_date=date(2018, 1, 22),
# payment_date=date(2018, 1, 22)
# )
# self.assertFalse(self.strategy.is_from_previous_period())
# class CreateStrategyTestCase(StrategyTestMixin, TestCase, BaseTestHelper):
# strategy_cls = CreateStrategy
# @patch('balances.factories.create_period_balance_for', side_effect=None)
# def test_is_from_previous_period_checks_missing_period(self, ignore_mock):
# self.mock_transaction_instance()
# with patch.object(self.strategy, 'check_missing_periods', return_value=True) as mock:
# self.assertTrue(self.strategy.is_from_previous_period())
# self.assertTrue(mock.called)
# def test_check_missing_periods_returns_both_dates(self):
# self.mock_transaction_instance(
# due_date=date(2017, 8, 22),
# payment_date=date(2017, 8, 23)
# )
# expected = [date(2017, 8, 22), date(2017, 8, 23)]
# self.assertEqual(expected,
# self.strategy.check_missing_periods(self.account))
# def test_check_missing_periods_returns_false_current_period(self):
# self.create_period_balance(date(2018, 1, 1), date(2018, 1, 31))
# self.mock_transaction_instance(
# due_date=date.today(),
# payment_date=date.today()
# )
# self.assertFalse(self.strategy.check_missing_periods(self.account))
# def test_check_missing_periods_another_account(self):
# another_account = self.create_account(name='another')
# self.create_period_balance(date(2018, 1, 1), date(2018, 1, 31), another_account)
# self.mock_transaction_instance(
# due_date=date(2018, 1, 22),
# payment_date=date(2018, 1, 22)
# )
# #only existent for another account
# self.assertTrue(self.strategy.check_missing_periods(self.account))
# def test_update_current_balance(self):
# self.mock_transaction_instance(
# due_date=date.today(),
# payment_date=date.today(),
# value=100
# )
# self.strategy.update_current_balance(self.strategy.instance)
# self.assert_account_balances(200, 200)
# def test_update_current_balance_without_payment_date(self):
# self.mock_transaction_instance(
# due_date=date.today(),
# payment_date=None,
# value=100
# )
# self.strategy.update_current_balance(self.strategy.instance)
# self.assert_account_balances(200, 100)
# class UpdateStrategyTestCase(StrategyTestMixin, TestCase, BaseTestHelper):
# strategy_cls = UpdateStrategy
# def setUp(self):
# super().setUp()
# self.another_account = self.create_account(name='other', current_effective_balance=100,
# current_real_balance=100)
# def test_get_lower_date_compare_old_dates(self):
# self.mock_transaction_instance(
# initial_due_date=date(2017, 1, 1),
# initial_payment_date=date(2016, 5, 1),
# due_date=date(2016, 12, 1),
# payment_date=date(2016, 12, 1)
# )
# self.assertEqual(self.strategy.get_lower_date(), self.strategy.instance.initial_payment_date)
# def test_get_lower_date_compare_none_dates(self):
# self.mock_transaction_instance(
# initial_due_date=date(2016, 5, 1),
# initial_payment_date=date(2017, 1, 1),
# due_date=date(2016, 12, 1),
# payment_date=None
# )
# self.assertEqual(self.strategy.get_lower_date(), self.strategy.instance.initial_due_date)
# def test_update_current_balance_increasing(self):
# self.mock_transaction_instance(
# initial_due_date=date(2017, 1, 1),
# initial_payment_date=date(2017, 1, 1),
# initial_value=100,
# due_date=date(2017, 1, 1),
# payment_date=date(2017, 1, 1),
# value=150
# )
# self.strategy.update_current_balance(self.strategy.instance)
# self.assert_account_balances(150, 150)
# def test_update_current_balance_remove_payment(self):
# self.mock_transaction_instance(
# initial_due_date=date(2017, 1, 1),
# initial_payment_date=date(2017, 1, 1),
# initial_value=100,
# due_date=date(2017, 1, 1),
# payment_date=None,
# value=100
# )
# self.strategy.update_current_balance(self.strategy.instance)
# self.assert_account_balances(100, 0)
# def test_update_current_balance_decreasing(self):
# self.mock_transaction_instance(
# initial_due_date=date(2017, 1, 1),
# initial_payment_date=date(2017, 1, 1),
# initial_value=100,
# due_date=date(2017, 1, 1),
# payment_date=date(2017, 1, 1),
# value=80
# )
# self.strategy.update_current_balance(self.strategy.instance)
# self.assert_account_balances(80, 80)
# def test_changed_due_date_to_past(self):
# self.mock_transaction_instance(
# initial_due_date=date(2017, 1, 1),
# initial_payment_date=date(2017, 1, 1),
# initial_value=100,
# due_date=date(2016, 12, 1), #PAST
# payment_date=date(2017, 1, 1),
# value=100
# )
# class DeleteStrategyTestCase(StrategyTestMixin, TestCase, BaseTestHelper):
# strategy_cls = DeleteStrategy
# def test_update_current_balance(self):
# self.mock_transaction_instance(
# due_date=date(2017, 1, 1),
# payment_date=date(2017, 1, 1),
# value=50
# )
# self.strategy.update_current_balance(self.strategy.instance)
# self.assert_account_balances(50, 50)
|
import numpy as np
import random
# normalize all data
def normalize(data):
print("Data normalization...")
shape = data.shape
data = np.reshape(data, (shape[0], -1))
# scaling
data = data.astype('float32') / 255.
# normalizing
data = data - np.mean(data, axis=0)
print("Done.")
return np.reshape(data, shape)
# normalize a single image
def image_normalization(img):
img = img.astype('float32') / 255.
img = img - np.mean(img)
return img
# prepare all data (npz version)
def prepare_data(data):
print("Data preparing...")
eye_left, eye_right, face, face_mask, y = data
eye_left = normalize(eye_left)
eye_right = normalize(eye_right)
face = normalize(face)
face_mask = np.reshape(face_mask, (face_mask.shape[0], -1)).astype('float32')
y = y.astype('float32')
print("Done.")
return [eye_left, eye_right, face, face_mask, y]
# shuffle data
def shuffle_data(data):
idx = np.arange(data[0].shape[0])
np.random.shuffle(idx)
for i in list(range(len(data))):
data[i] = data[i][idx]
return data
|
def matchResultat(match_id, cursor):
goal_list = cursor.execute(
"select home_team_goal, away_team_goal from 'Match' where id =" + str(match_id) + ";").fetchall()
if goal_list[0][0] > goal_list[0][1]:
result = 0
elif goal_list[0][0] < goal_list[0][1]:
result = 2
else:
result = 1
return result
|
'''
DiscoAtThePanic - Robin Han, Vincent Chi
SoftDev2 pd7
K #17: PPFTLCW
2019-04-14
'''
import math
a = [0,1,2,3,4]
b = [0,1,2]
not_primes = []
def q1_loop():
temp = []
for i in range(5):
temp.append(i*22)
print(temp)
def q1_list():
print ([x*22 for x in a])
def q2_loop():
temp = []
for i in range(5):
temp.append(i*10+7)
print (temp)
def q2_list():
print ([x*10+7 for x in a])
def q3_loop():
temp2 = []
for u in range(3):
for i in range(3):
temp2.append(i*u)
print(temp2)
def q3_list():
print([x * y for x in b for y in b])
def q4_loop():
temp = []
for i in range(101):
for j in range(2,int(math.sqrt(i)) + 1):
if (i % j == 0):
temp.append(i)
break
print (temp)
def q4_list():
[not_primes.append(x) for x in range(101) for y in range(2,int(math.sqrt(x)+1)) if x%y == 0 and x not in not_primes]
print(not_primes)
def q5_loop():
temp = []
flag = True
for i in range(2, 101):
for j in range(2,int(math.sqrt(i)) + 1):
if (i % j == 0):
flag = False
break
else:
flag = True
if (flag):
temp.append(i)
print(temp)
def q5_list():
primes = []
[primes.append(e) for e in range(2, 100) if e not in not_primes]
print(primes)
def q6_loop(num):
temp3 = []
for i in range(1,num+1):
if (num % i == 0):
temp3.append(i)
print (temp3)
def q6_list(num):
factors = []
[factors.append(x) for x in range(1,num+1) if num%x == 0]
print(factors)
def q7_loop(matrix):
result = [[0 for x in range(len(matrix))] for y in range(len(matrix[0]))]
for i in range(len(matrix)):
for j in range(len(matrix[0])):
result[j][i] = (matrix[i][j])
print(result)
def q7_list(matrix):
tran = [[matrix[j][i] for j in range(len(matrix))] for i in range(len(matrix[0]))]
print(tran)
q1_list()
q1_loop()
q2_list()
q2_loop()
q3_list()
q3_loop()
q4_list()
q4_loop()
q5_list()
q5_loop()
num = 72
q6_list(num)
q6_loop(num)
matrix = [[1,2,3],[4,5,6],[7,8,9]]
q7_list(matrix)
q7_loop(matrix) |
import geojson
import requests
geojsonurl = 'https://raw.githubusercontent.com/jtweddle89/proj-mapping/master/test/map.geojson'
r = requests.get(geojsonurl)
mydata = r.json()
print(mydata.keys())
#print out keys and values of every item in every properties dictionary, skipping items that have value of ""
ix = len(mydata['features']) - 1
for i in mydata['features']:
# print (mydata['features'][ix]['properties'])
for (k,v) in mydata['features'][ix]['properties'].items():
if len(k)>=11:
tabs = '\t\t'
else:
tabs = '\t\t\t'
if v=="":
continue
print k, tabs, v
ix -= 1
|
from core import app
from markupsafe import escape
from http import HTTPStatus
from flask import abort, request
from flask.wrappers import Response
from datetime import datetime
from models import db
from models import User
@app.route("/hello/<username>", methods=['GET'])
def get_username(username):
sanitized_username=escape(username)
user = User.query.filter_by(username=sanitized_username).first()
if user is None:
abort(404)
if user.days_until_birthday() == 0:
return {
"message": f"Hello, {user.username}! Happy birthday!"
}
return {
"message": f"Hello, {user.username}! Your birthday is in {user.days_until_birthday()} day(s)"
}
@app.route("/hello/<username>", methods=['PUT'])
def put_username(username):
sanitized_username=escape(username)
request_data = request.get_json()
try:
birth_date_str = request_data['dateOfBirth']
birth_date = datetime.strptime(birth_date_str, "%Y-%m-%d")
except (KeyError, ValueError):
abort(400, 'Invalid message format')
user = User.query.filter_by(username=sanitized_username).first()
try:
if user is None:
newuser = User(sanitized_username, birth_date)
db.session.add(newuser)
db.session.commit()
else:
user.birth_date = birth_date
db.session.commit()
except ValueError as e:
abort(400, f'Invalid value: {str(e)}')
return Response(status=HTTPStatus(204))
@app.route("/health", methods=['GET'])
def health():
try:
db.engine.execute('SELECT 1')
except:
abort(500, "FAILED: Database connection failed")
return Response(response="OK", status=HTTPStatus(200))
@app.route("/liveness", methods=['GET'])
def liveness():
return Response(response="OK", status=HTTPStatus(200))
|
from random import*
firstavg = 0
randavg = 0
leastavg = 0
zeroten = 0
for a in range(100000):
# number of flips for each of 100 coins
tenFlips = range(1000)
# total flips
tenthousand = range(10000)
for i in range(10000):
tenthousand[i] = randint(0, 1)
for j in range(1000):
tenFlips[j] = 0
for k in range(10):
tenFlips[j] += tenthousand[j*10+k]
# random coin to choose
randcoin = randint(0, 999)
firstavg += tenFlips[0]
randavg += tenFlips[randcoin]
leastavg += min(tenFlips)
for b in range(1000):
if(tenFlips[b] == 0):
zeroten += 1
elif (tenFlips[b] == 10):
zeroten += 1
print "the average number of heads for the first coin is: ", float(firstavg)/float(100000)
print "the average number of heads for random coin is: ", float(randavg)/float(100000)
print "the average number of minimum heads for coin is: ", float(leastavg)/float(100000)
print "the number of zero heads or ten heads for 10 flips is: ", zeroten
|
name=" Pratiksha "
print(name)
#Strip remove the blank Spaces
print(name.strip())
print(len(name))
Last_name="Sawandkar"
print(Last_name[2:5])
print(Last_name)
var=Last_name.lower()
print(var)
var2=Last_name.replace("r" , "t")
print(var2)
var3=Last_name.lower()
print(var3)
#Remove , Using The replace method
friends="Pratiksha, Sudarsha, Kattyani, Priya"
var4=friends.replace(","," ")
print(var4)
var5=friends.replace(", ","\n")
print(var5)
#concat String
str1="Pratiksha"
str2="Balaji"
str3="Sawandkar"
str4=str1+" "+str2+ " "+str3
print(str4)
#Used Place Holders
temp="This is a {} and is a good girl name {}".format(str1, str2)
print(temp)
str5="Maya"
temp1=f"this is a {str1} and she is good girl {str5}"
print(temp1)
#Operators
a=20
b=60
print(a + b) # Addition
print (a - b) #Sub
print (a * b) #Mul
print (a / b) #Div
print (a ** b) #Exponentiation
print (a // b) #Floot Division
print (a % b) #Modula |
import numpy as np
def encode_16bit(wave: np.ndarray):
encoded = ((wave + 1) * 2 ** 15).astype(np.int32)
encoded[encoded == 2 ** 16] = 2 ** 16 - 1
coarse = encoded // 256
fine = encoded % 256
return coarse, fine
def encode_single(wave: np.ndarray, bit: int = 8):
if 8 < bit:
wave = wave.astype(np.float64)
coarse = ((wave + 1) * 2 ** (bit - 1)).astype(np.int32)
coarse[coarse == 2 ** bit] = 2 ** bit - 1
return coarse
def decode_16bit(coarse, fine):
signal = (coarse * 256 + fine) / (2 ** 16 - 1) * 2 - 1
return signal.astype(np.float32) if hasattr(signal, "astype") else signal
def decode_single(coarse, bit: int = 8):
signal = coarse / (2 ** bit - 1) * 2 - 1
return signal.astype(np.float32) if hasattr(signal, "astype") else signal
def encode_mulaw(x: np.ndarray, mu: int):
mu = mu - 1
y = np.sign(x) * np.log1p(mu * np.abs(x)) / np.log1p(mu)
return y
def decode_mulaw(x: np.ndarray, mu: int):
mu = mu - 1
y = np.sign(x) * ((1 + mu) ** np.abs(x) - 1) / mu
return y
|
import sys, os
import pandas as pd
from specter import Spec, expect
from timezone import Timezone
sys.path.append(os.path.join(os.path.dirname(__file__), '../', 'code'))
class TimezoneSpec(Spec):
class to_standard(Spec):
def should_convert_to_standard(self):
tz = Timezone('Abu Dhabi')
expect(tz.to_standard()).to.equal('Asia/Muscat')
|
import pygame as pg
from services.resources import ResourcesService
class GameObject:
image_path = None
def __init__(self, screen):
self._screen = screen
self._image = pg.image.load(ResourcesService(self.get_image_path()).path).convert_alpha()
self._rect = self._image.get_rect()
def get_image_path(self):
if self.image_path is not None:
return self.image_path
raise ValueError('image_path is not set')
def render(self):
self._screen.blit(self._image, self._rect) |
#! /usr/bin/env python
import numpy as np
import torch
import torch.nn as nn
import math
import rospy
from std_msgs.msg import String, Int8
from geometry_msgs. msg import Vector3
from collections import OrderedDict
from Algs.AutoDecompose import Decompose
from Tasks.decomposeTask import DecomposeTask
from Algs.doubleQ import DoubleQ
from Tasks.hierarchyTask import HierarchyTask
from Tasks.box_slope_task import BoxSlopeTask
from Tasks.omni_box_slope_task import OmniBoxSlopeTask
from Tasks.hierarchy_MBRL_task import Hierarchy_MBRL_Task
from Tasks.planner import Planner
from Algs.hierarchical_MBRL import Hierarchical_MBRL
# from Algs.SoftActorCritic import SAC
NAME = 'bot'
algs = {
0: 'INVERSE',
1: 'CONTROL',
2: 'DOUBLE_CONTROL',
3: 'OMNI_CONTROL',
4: 'PLANNER',
5: 'MBRL'
}
ALGORITHM = 5
description = algs[ALGORITHM]
rospy.init_node('Dummy', anonymous = True)
if description == 'INVERSE':
agents = OrderedDict({
#ensure ordering matches ros messages
"bot": {"sub": "/state", "pub": "/action"} #joint action space
})
params = {
'clusters': 3,
'mode': 'RNN', #Spectral, RNN
'state_n': 4, # this does not include time
'horizon': 6,
'noise': False
}
params = {"params": params, "agents": agents}
bot = Decompose(params, NAME, DecomposeTask())
if description == 'CONTROL':
agents = OrderedDict({
#ensure ordering matches ros messages
"bot": {"sub": "/state", "pub": "/action"} #joint action space
})
valPars = {
'neurons': (7, 256, 256, 5),
'act': ['F.leaky_relu','F.leaky_relu'],
'mu': torch.Tensor([0, 0, 0,
0, 0, 0, 0]),
'std': torch.Tensor([1, 1, 1,
1, 1, 1, 1]),
'trainMode': False,
'load': False,
'dual': False,
}
valTrain = {
'batch': 256,
'lr': 3e-4,
'buffer': 2000, #500
'gamma': .99,
'explore': .9,
'double': True,
}
params = {"valPars": valPars, "valTrain": valTrain, "agents": agents}
tanker = DoubleQ(params, NAME, HierarchyTask())
#agent = SAC(params, NAME, HierarchyTask())
if description == 'DOUBLE_CONTROL':
NAME = 'a_bot'
agents = OrderedDict({
#ensure ordering matches ros message
"a_bot": {"sub": "/state", "pub": "/action1"}, #joint action space
})
agents["b_bot"] = {"sub": "/state", "pub": "/action2"}
# agents["c_bot"] = {"sub": "/state", "pub": "/action3"}
# Placeholders
valPars = {
'neurons': (6, 256, 256, 4),
'act': ['F.leaky_relu','F.leaky_relu'],
'mu': torch.Tensor([0, 0, 0, 0, 0, 0]),
'std': torch.Tensor([1, 1, 1, 1, 1, 1]),
'trainMode': False,
'load': False,
'dual': False,
}
valTrain = {
'batch': 256,
'lr': 3e-4,
'buffer': 5000,
'gamma': .99,
'explore': .9,
'double': True,
}
params = {"valPars": valPars, "valTrain": valTrain, "agents": agents}
tanker = DoubleQ(params, NAME, BoxSlopeTask())
if description == 'OMNI_CONTROL':
NAME = 'a_bot'
agents = OrderedDict({
#ensure ordering matches ros message
"a_bot": {"sub": "/state", "pub": "/action1"}, #joint action space
})
agents["b_bot"] = {"sub": "/state", "pub": "/action2"}
agents["c_bot"] = {"sub": "/state", "pub": "/action3"}
#agents["d_bot"] = {"sub": "/state", "pub": "/action4"}
# Placeholders
valPars = {
'neurons': (18, 256, 256, 8),
'act': ['F.leaky_relu','F.leaky_relu'],
'mu': torch.Tensor([-2, 0, 5, 0, 0, 0,
-1, 0, .5,0, 0, 0,
-1, 0, .5,0, 0, 0]),
'std': torch.Tensor([1, 1, 1, np.pi, np.pi, np.pi,
1, 1, 1, np.pi, np.pi, np.pi,
1, 1, 1, np.pi, np.pi, np.pi]),
'trainMode': True,
'load': False,
'dual': False,
}
valTrain = {
'batch': 128,
'lr': 3e-4,
'buffer': 500,
'gamma': .99,
'explore': .9,
'double': True,
}
params = {"valPars": valPars, "valTrain": valTrain, "agents": agents}
tanker = DoubleQ(params, NAME, OmniBoxSlopeTask())
if description == 'PLANNER':
NAME = 'a_bot'
agents = OrderedDict({
#ensure ordering matches ros message
"a_bot": {"sub": "/state", "pub": "/action1"}, #joint action space
})
agents["b_bot"] = {"sub": "/state", "pub": "/action2"}
# agents["c_bot"] = {"sub": "/state", "pub": "/action3"}
policyPars = {
'neurons': (10, 256, 256, 8), # 5 box-related state, 4 goal-related state, 1 indicator, 8 controls
'act': ['F.leaky_relu','F.leaky_relu'],
'mu': torch.Tensor([0, 0, 0, 0, 0,
0, 0, 0, 0, 0]),
'std': torch.Tensor([1, 1, 1, 1, 1,
1, 1, 1, 1, 1]),
'trainMode': False, # Make sure both value and policy are set to the same thing
'load': False,
'dual': False,
}
policyTrain = {
'batch': 256,
'lr': 3e-4,
'buffer': 5000,
'gamma': .95,
'explore': 0, # Don't change this. Tune the exploration up top
'double': True,
'noise': 0,
'priority': True
}
params = {"valPars": policyPars, "valTrain": policyTrain, "agents": agents}
planner = Planner(params, NAME)
if description == 'MBRL':
NAME = 'a_bot'
agents = OrderedDict({
#ensure ordering matches ros message
"a_bot": {"sub": "/state", "pub": "/action"}, #joint action space
})
agents["b_bot"] = {"sub": "/state", "pub": "/action2"}
valPars = {
'neurons': (18, 400, 400, 400, 9), # 5 box-related state, 4 goal-related state, 8 action one hot, 1 indicator
'act': ['F.leaky_relu','F.leaky_relu', 'F.leaky_relu'],
'mu': torch.Tensor([0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0 ,0 ,0 ,0 ,0]),
'std': torch.Tensor([1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1]),
'trainMode': True, # Make sure both value and policy are set to the same thing
'load': False,
'dual': False,
'u_n': 8,
's_n': 8,
'dropout': 0
}
valTrain = {
'batch': 256, #512 used to be...but might be too slow
'lr': 3e-4,
'noise': .05,
'buffer': 5000,
'gamma': 0, # Tune the policy below
'explore': .7, # this was changed to .5 for MB
'double': True,
'pretrain': False,
'one_hot': True
}
policyPars = {
'neurons': (10, 256, 256, 8), # 5 box-related state, 4 goal-related state, 1 indicator, 8 controls
'act': ['F.leaky_relu','F.leaky_relu'],
'mu': torch.Tensor([0, 0, 0, 0, 0,
0, 0, 0, 0, 0]),
'std': torch.Tensor([1, 1, 1, 1, 1,
1, 1, 1, 1, 1]),
'trainMode': True, # Make sure both value and policy are set to the same thing
'load': False,
'dual': False,
}
policyTrain = {
'batch': 32, # used to be 256
'lr': 3e-4,
'buffer': 2500,
'gamma': .95,
'explore': 0, # Don't change this. Tune the exploration up top
'double': True,
'noise': 0,
'priority': True
}
doubleQPars = {'valPars': policyPars, 'valTrain': policyTrain, 'agents': agents}
params = {"valPars": valPars, "valTrain": valTrain, 'doubleQ_params': doubleQPars, "agents": agents}
agent = Hierarchical_MBRL(params, NAME, Hierarchy_MBRL_Task())
while(True):
x = 1+1 |
# coding: utf-8
import floppyforms.__future__ as forms_
from django import forms
from django.conf import settings
from django.contrib.auth import get_user_model
from django.utils.safestring import mark_safe
from django.utils.translation import ugettext_lazy as _
from scoop.core.util.shortcuts import get_website_name
from scoop.user.util.signals import credentials_form_check_email, credentials_form_check_name, credentials_form_check_username
class UserNewForm(forms.ModelForm):
""" Formulaire d'inscription """
# Constantes
PASSWORD_LENGTH_MIN = 4
USERNAME_LENGTH_MIN = 3
USERNAME_LENGTH_MAX = 20
FIRST_NAME_LENGTH_MAX = 20
LAST_NAME_LENGTH_MAX = 40
# Champs
username = forms_.SlugField(max_length=30, min_length=4, label=_("User name"),
widget=forms_.TextInput(attrs={'placeholder': _("Letters, digits and underscores")}))
email = forms_.EmailField(label=_("Email"), widget=forms_.TextInput(attrs={'placeholder': _("A non disposable email")}))
email_confirm = forms_.EmailField(label=_("Retype email"))
password_confirm = forms_.CharField(max_length=128, widget=forms_.PasswordInput(render_value=True), label=_("Retype password"))
# Validation
def clean_password(self):
"""" Valider et renvoyer les données du champ mot de passe """
password = self.cleaned_data['password']
if not password or len(password) < UserNewForm.PASSWORD_LENGTH_MIN:
raise forms.ValidationError(_("Your password should be at least {min} characters long").format(min=UserNewForm.PASSWORD_LENGTH_MIN))
return password
def clean_password_confirm(self):
""" Valider et renvoyer les données du champ confirmation de mot de passe """
confirm = self.cleaned_data['password_confirm']
if 'password_confirm' not in self.cleaned_data or confirm != self.cleaned_data.get('password'):
raise forms.ValidationError(_("The password must be identical in both fields."))
return confirm
def clean_email(self):
""" Valider et renvoyer les données du champ email """
email = self.cleaned_data['email'].lower()
credentials_form_check_email.send(sender=self, email=email)
if get_user_model().objects.filter(email__iexact=email).exists():
raise forms.ValidationError(_("This e-mail address is already in use."))
return email
def clean_email_confirm(self):
""" Valider et renvoyer les données du champ confirmation de l'email """
confirm = self.cleaned_data['email_confirm'].lower()
if not self.fields['email_confirm'].required:
return confirm
if 'email_confirm' not in self.cleaned_data or confirm != self.cleaned_data.get('email'):
raise forms.ValidationError(_("The email addresses must be identical."))
return confirm
def clean_name(self):
""" Valider et renvoyer les données du champ nom """
name = self.cleaned_data['name']
credentials_form_check_name.send(sender=self, name=name)
if len(name) > UserNewForm.FIRST_NAME_LENGTH_MAX:
raise forms.ValidationError(_("Your first name must not exceed {max} characters").format(max=UserNewForm.FIRST_NAME_LENGTH_MAX))
return name
def clean_username(self):
""" Valider et renvoyer les données du champ nom d'utilisateur """
name = self.cleaned_data['username']
credentials_form_check_username.send(sender=self, username=name)
length = len(name)
# Renvoyer une erreur si le pseudo est utilisé
if get_user_model().objects.filter(username__iexact=name):
raise forms.ValidationError(_("This nickname is already in use."))
# Renvoyer une erreur si le pseudo est trop court ou long
if length > UserNewForm.USERNAME_LENGTH_MAX or length < UserNewForm.USERNAME_LENGTH_MIN:
raise forms.ValidationError(
_("Your nickname should be between {min} and {max} characters long.").format(min=UserNewForm.USERNAME_LENGTH_MIN,
max=UserNewForm.USERNAME_LENGTH_MAX))
return name.lower()
def clean_eula(self):
""" Valider et renvoyer les données du champ Accepter les CGU """
checked = self.cleaned_data.get('eula', True)
if 'eula' in self.cleaned_data and checked is False:
raise forms.ValidationError(_("You must accept our EULA to proceed."))
return True
def __init__(self, *args, **kwargs):
""" Initialiser le formulaire """
super(UserNewForm, self).__init__(*args, **kwargs)
# Métadonnées
class Meta:
model = get_user_model()
fields = ('username', 'email', 'email_confirm', 'password', 'password_confirm')
widgets = {'password': forms_.PasswordInput(render_value=True, attrs={'autocomplete': 'off'}),
'password_confirm': forms_.PasswordInput(render_value=False, attrs={'autocomplete': 'off'}),
'username': forms_.TextInput(attrs={'placeholder': _("4 characters minimum")}),
}
class UserEditForm(UserNewForm):
""" Formulaire de modification du mot de passe du compte """
original = forms.CharField(widget=forms.PasswordInput(), label=_("Original"))
# Métadonnées
class Meta:
model = get_user_model()
fields = ('password', 'password_confirm', 'original')
widgets = {'password': forms.PasswordInput(attrs={'autocomplete': 'off'})}
class EULAForm(forms.Form):
""" Formulaire de validation des CGU """
# Constantes
CHOICES = ((False, _("I refuse to comply to the EULA and do not want to use this website")),
(True, _("I abide to the {website} EULA").format(website=get_website_name()))
)
# Champs
eula = forms_.BooleanField(required=True, label=_("EULA"), widget=forms.Select(choices=CHOICES))
# Initialiseur
def __init__(self, *args, **kwargs):
""" Initialiser le formulaire """
super(EULAForm, self).__init__(*args, **kwargs)
self.fields['eula'].error_messages = {'required': _("You must abide to the EULA to continue")}
|
import datetime
from flask_jwt_extended import JWTManager
from app.utils.env_utils import EnvUtils
jwt = JWTManager()
def configure_security(app):
access_token_expires = datetime.timedelta(seconds=int(EnvUtils.get_env('APP_SECURITY_ACCESS_TOKEN_EXPIRES')))
refresh_token_expires = datetime.timedelta(seconds=int(EnvUtils.get_env('APP_SECURITY_REFRESH_TOKEN_EXPIRES')))
app.config['JWT_SECRET_KEY'] = EnvUtils.get_env('APP_SECURITY_SECRET_KEY')
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = access_token_expires
app.config['JWT_REFRESH_TOKEN_EXPIRES'] = refresh_token_expires
jwt.init_app(app)
@jwt.user_identity_loader
def user_identity_lookup(current_user):
return str(current_user.id)
|
from django.apps import AppConfig
class ServiceProductConfig(AppConfig):
name = 'service_product'
|
"""
找出100~999之间的所有水仙花数
水仙花数是各位立方和等于这个数本身的数
如: 153 = 1**3 + 5**3 + 3**3
@Author:jyang
@Date:5/10/2019
"""
import math
l = []
for i in range(100, 1000):
a = int(i/100)
b = int(i%100/10)
c = int(i%100%10)
if i == math.pow(a, 3) + math.pow(b, 3) + math.pow(c, 3):
l.append(i)
print(l) |
#!/usr/bin/python3.4
# coding: utf-8
"""
Programme (classe) : thread_p2_arret.py version 1.0
Date : 17-03-2018
Auteur : Hervé Dugast
source : https://python.developpez.com/faq/?page=Thread
Fonctionnement :
Affiche exécution de 3 threads (compteur infini). Demande l'arrêt de chacun des threads et
montre l'arrêt propre de chaque thread.
Principe utilisé pour arrêter proprement le thread :
Dans la méthode run, on utilise une boucle while qui exécute ses instructions tant qu'aucun
événement de type arrêt est actif. Pour déclencher un événement de type arrêt, on utilise la
méthode stop qui appelera la méthode monEvent._stopevent.set(). Lorsque cette dernière est
appelée, la boucle while se termine, ce qui arrête proprement le thread.
En utilisant la classe Event, on accélère l'arrêt du thread. En effet, la méthode
monEvent.wait(timeout) bloque l'exécution du thread pendant la durée timeout, sauf si la méthode
monEvent._stopevent.set() est appelée entre temps. Autrement dit, l'utilisation de
monEvent.wait(timeout) permet d'effectuer une temporisation que l'on peut interrompre grâce à
monEvent._stopevent.set(), ce qui n'aurait pas été possible avec un time.sleep(duree).
------- affichage console ------------------------------------------------------
Thread A 0
Thread B 0
Thread C 0
Thread A 1
Thread B 1
Thread C 1
-> Demande arrêt Thread B
* Le thread Thread B s'est termine proprement
Thread A 2
Thread C 2
Thread C 3
Thread A 3
Thread C 4
-> Demande arrêt Thread C
-> a.join(timeout=5) lancé. Prog principal bloqué !
Thread A 4
* Le thread Thread C s'est termine proprement
Thread A 5
Thread A 6
* timeout a.join() écoulé... Prog principal reprend... Thread A continue...
Thread A 7
Thread A 8
-> Demande arrêt Thread A
* Le thread Thread A s'est termine proprement
--- Fin programme ---
--------------------------------------------------------------------------------
"""
from threading import Thread, Event
import time
class Affiche(Thread):
def __init__(self, nom = ''):
""" constructeur
"""
Thread.__init__(self)
self.nom = nom
#
self._stopevent = Event()
def run(self):
i = 0
while not self._stopevent.isSet():
print(self.nom, i)
i += 1
self._stopevent.wait(2.0)
print("* Le thread "+self.nom +" s'est termine proprement")
def stop(self):
self._stopevent.set( )
a = Affiche('Thread A')
b = Affiche('Thread B')
c = Affiche('Thread C')
a.start()
b.start()
c.start()
time.sleep(3)
print("-> Demande arrêt Thread B")
b.stop()
time.sleep(5)
print("-> Demande arrêt Thread C")
c.stop()
# bloque le programme principal à cet endroit jusqu'à ce que le thread A se termine ou que le
# timeout=7 soit écoulé. Attention, dans notre cas, le programme principal reprendra son exécution
# à la fin du timeout et le thread A continuera également son exécution.
print("-> a.join(timeout=5) lancé. Prog principal bloqué !")
a.join(timeout=5)
print("* timeout a.join() écoulé... Prog principal reprend... Thread A continue...")
time.sleep(4)
print("-> Demande arrêt Thread A")
a.stop()
# un petit délai s'écoule entre la demande d'arrêt du thread et son arrêt réel
time.sleep(1)
print("--- Fin programme ---")
|
# SMALLEST MULTIPLE
# Get all prime numbers and their powers
a = 2**4 * 3**2 * 5 * 7 * 11 * 13 * 17 * 19
print(a)
|
import plotly.graph_objs as go
import plotly
import math
plotly.tools.set_credentials_file(username='ltknow', api_key='Lg7qlfduhEolzJYMyEdk')
class MapDrawer(object):
def __init__(self, as_graph):
self.as_graph = as_graph
def draw_map(self, filename):
colorscale = [[0.0, 'rgb(254,224,144)'], [0.1111111111111111, 'rgb(253,174,97)'],
[0.2222222222222222, 'rgb(244,109,67)'], [0.3333333333333333, 'rgb(215,48,39)'],
[0.4444444444444444, 'rgb(165,0,38)'], [0.5555555555555556, 'rgb(49,54,149)'],
[0.6666666666666666, 'rgb(69,117,180)'], [0.7777777777777778, 'rgb(116,173,209)'],
[0.8888888888888888, 'rgb(171,217,233)'], [1.0, 'rgb(171,217,233)']]
# use the two lists to store the radius and angle of every node
r = list()
sizes = list()
theta = list()
data = list()
# get the max degree of the graph
max_degree = 1
max_radius = 0
for node in self.as_graph:
if int(self.as_graph.degree(node)) > max_degree:
max_degree = int(self.as_graph.degree(node))
# add radius and angle to the node
for node in self.as_graph.nodes:
if self.as_graph.degree(node) <= 0:
radius = 1 - math.log(1.0 / max_degree)
else:
radius = 1 - math.log(float(self.as_graph.degree(node)) / max_degree)
if radius > max_radius:
max_radius = radius
area = 10 * float(self.as_graph.degree(node) + max_degree) / (max_degree * 2)
try:
angle = self.as_graph.node[node]['longtitude']
except KeyError:
continue
r.append(radius)
sizes.append(area)
theta.append(angle)
self.as_graph.add_node(node, pos=(radius, angle), degree=self.as_graph.degree(node))
node = go.Scatterpolar(
r=r,
theta=theta,
mode='markers',
marker=dict(
symbol='square',
size=sizes,
cmax=0,
color=r, # set color equal to the radius
colorscale=colorscale,
showscale=True
)
)
edge_r1 = list()
edge_theta1 = list()
edge_r2 = list()
edge_theta2 = list()
edge_r3 = list()
edge_theta3 = list()
for edge in self.as_graph.edges:
try:
r0, t0 = self.as_graph.node[edge[0]]['pos']
r1, t1 = self.as_graph.node[edge[1]]['pos']
radius = max(r0, r1)
flag = radius/max_radius
if flag <= 0.4:
edge_r3 += [r0, r1, None]
edge_theta3 += [t0, t1, None]
elif flag <= 0.7:
edge_r2 += [r0, r1, None]
edge_theta2 += [t0, t1, None]
else:
edge_r1 += [r0, r1, None]
edge_theta1 += [t0, t1, None]
except KeyError:
continue
edge1 = go.Scatterpolar(
r=edge_r1,
theta=edge_theta1,
line=dict(
width=0.5,
color='rgba(171,217,233,0.1)',
),
mode='lines'
)
data.append(edge1)
edge2 = go.Scatterpolar(
r=edge_r2,
theta=edge_theta2,
line=dict(
width=1,
color='rgba(49,54,149,0.2)',
),
mode='lines'
)
data.append(edge2)
edge3 = go.Scatterpolar(
r=edge_r3,
theta=edge_theta3,
line=dict(
width=2,
color='rgba(215,48,39,0.5)',
),
mode='lines'
)
data.append(edge3)
data.append(node)
fig = go.Figure(data=data)
plotly.offline.plot(fig, filename=filename + '.html', auto_open=True)
|
import maya.cmds as cmds
cmds.polyCylinder(n='TourBase',r=3,h=6)
cmds.xform(ws=True, piv=(0,3,0))
cmds.move(0,-3,0)
for i in range(2):
cmds.polyCylinder(n='Tour1',r=3.2+(.1*i),h=0.3,sa=30)
cmds.move(0,0.3*i,0)
cmds.group('Tour*',n='GroupTour')
cmds.select('GroupTour')
cmds.xform(ws=True, piv=(0,0.75,0))
cmds.move(0,-0.75,0, 'GroupTour')
cmds.polyPipe(n='Remp',r=3.4,h=2.5,t=0.5,sa=40)
for i in range(12):
cmds.polyCube(n='Rempart',w=0.5,h=0.5,d=1)
cmds.xform(ws=True,piv=(0,-.25,0))
cmds.move(0,.25,0)
cmds.move(0,.2,3.2, relative=True)
cmds.xform(ws=True, rotatePivot=(0,0,0))
cmds.rotate(0,30*i,0)
for i in range(12):
cmds.polyCube(n='Fente',w=1,h=.5,d=.1)
cmds.move(3.2,0,0, relative=True)
cmds.xform(ws=True, rotatePivot=(0,0,0))
cmds.rotate(0,30*i,0)
cmds.group('Fente*', n='GroupFentes')
cmds.group('Remp*',n='GroupRempart')
cmds.rotate(0,15,0,)
cmds.polyUnite('Fente*','Rempart*',n='TrouResult')
cmds.polyBoolOp('Remp','TrouResult', op=2, n='RempartResult')
cmds.move(0,0.2,0)
cmds.group('GroupTour','GroupFentes','GroupRempart','RempartResult','TrouResult', n='Tour')
cmds.duplicate('Tour',n='TourHaut')
cmds.move(0,3,0)
cmds.scale(.8,.8,.8)
|
import numpy as np
import pandas as pd
import gdal
import gdalconst
def rcs_trihedral_cr(cr_len, wavelength, inc_angle, tilt_angle, azimuth_angle):
tilt_angle = np.deg2rad(tilt_angle)
azimuth_angle = np.deg2rad(azimuth_angle)
theta = inc_angle + tilt_angle
t1 = (4 * np.pi * (cr_len ** 4)) / (wavelength ** 2)
t2 = np.cos(theta) + ((np.sin(theta)) * (np.sin(azimuth_angle) + np.cos(azimuth_angle)))
t3 = 2.0 / t2
t4 = (t2 - t3) ** 2
rcs = t1 * t4
return rcs
def absolute_cal(s_hh, rcs):
a = np.abs(s_hh) / (rcs ** 0.5)
return a
def f_at_cr(s_hh, s_vv):
denominator = s_hh * np.conj(s_hh)
numerator = s_vv * np.conj(s_vv)
f = (numerator / denominator) ** 0.25
return f.real
def g_at_dist(hv_arr, vh_arr):
numerator = np.mean(np.abs(hv_arr) ** 2)
denominator = np.mean(np.abs(vh_arr) ** 2)
g = (numerator / denominator) ** 0.25
return numerator, denominator, g
def phi_plus_cr(s_hh, s_vv):
added = s_vv * np.conj(s_hh)
return np.arctan(added.imag / added.real)
def phi_minus_dist(hv_arr, vh_arr):
diff = np.mean(hv_arr * vh_arr)
return diff, np.arctan(diff.imag / diff.real)
def radio_copol(hh_img, vv_img, inc_img, wave_length, cr_info, out_file=None):
hh_f = gdal.Open(hh_img)
vv_f = gdal.Open(vv_img)
inc_f = gdal.Open(inc_img)
hh_band = hh_f.GetRasterBand(1)
vv_band = vv_f.GetRasterBand(1)
inc_band = inc_f.GetRasterBand(1)
data = pd.read_csv(
cr_info,
usecols=[
"CR_ID",
"Azimuth_Angle",
"Tilt_Angle",
"Side_Length",
"loc_row",
"loc_col",
"Side_Length"
]
)
out_dat = list()
# dummy
r1 = "/home/abhisek/Public/hh_abs"
r2 = "/home/abhisek/Public/vv_abs"
i = 1
for row in data.itertuples():
cr_id = row.CR_ID
r = row.loc_row
c = row.loc_col
cr_len = row.Side_Length
phi = np.deg2rad(row.Azimuth_Angle)
inc_a = (inc_band.ReadAsArray(xoff=c, yoff=r, win_xsize=1, win_ysize=1))[0][0]
tilt_a = np.deg2rad(row.Tilt_Angle)
hh_pix = (hh_band.ReadAsArray(xoff=c, yoff=r, win_xsize=1, win_ysize=1))[0][0]
vv_pix = (vv_band.ReadAsArray(xoff=c, yoff=r, win_xsize=1, win_ysize=1))[0][0]
# Check
drv = gdal.GetDriverByName("GTiff")
f1 = drv.Create(r1 + str(i), 50, 50, 1, gdal.GDT_Float32)
f2 = drv.Create(r2 + str(i), 50, 50, 1, gdal.GDT_Float32)
b1 = f1.GetRasterBand(1)
b2 = f2.GetRasterBand(1)
hh_k = np.abs(hh_band.ReadAsArray(xoff=c - 24, yoff=r - 24, win_xsize=50, win_ysize=50))
vv_k = np.abs(vv_band.ReadAsArray(xoff=c - 24, yoff=r - 24, win_xsize=50, win_ysize=50))
b1.WriteArray(hh_k)
b2.WriteArray(vv_k)
b1.FlushCache()
b2.FlushCache()
i += 1
sigma_0 = rcs_trihedral_cr(
cr_len=cr_len,
wavelength=wave_length,
inc_angle=inc_a,
tilt_angle=tilt_a,
azimuth_angle=phi
)
a = absolute_cal(s_hh=hh_pix, rcs=sigma_0)
f = f_at_cr(s_hh=hh_pix, s_vv=vv_pix)
phi_p = phi_plus_cr(s_hh=hh_pix, s_vv=vv_pix)
out_dat.append([cr_id, cr_len, r, c, inc_a, a, f, phi_p, hh_pix, vv_pix, sigma_0])
df = pd.DataFrame(
out_dat, columns=[
'CR_ID',
'CR_LEN',
'ROW_ID',
'COL_ID',
'INC_ANGLE',
'A',
'f',
'Phi_PLUS',
"HH",
"VV",
"RCS"
]
)
if out_file is not None:
df.to_csv(out_file, sep=',', encoding='utf-8', index=None)
return df
def radio_xpol(hv_img, vh_img, row_offset=None, col_offset=None, outfile=None, row_start=0, col_start=0):
hv_f = gdal.Open(hv_img)
vh_f = gdal.Open(vh_img)
hv_band = hv_f.GetRasterBand(1)
vh_band = vh_f.GetRasterBand(1)
if row_offset is None:
row_offset = hv_band.YSize
if col_offset is None:
col_offset = hv_band.XSize
hv_homogeneous = hv_band.ReadAsArray(xoff=col_start, yoff=row_start, win_xsize=col_offset, win_ysize=row_offset)
vh_homogeneous = vh_band.ReadAsArray(xoff=col_start, yoff=row_start, win_xsize=col_offset, win_ysize=row_offset)
n, d, g = g_at_dist(hv_arr=hv_homogeneous, vh_arr=vh_homogeneous)
dif, phi_m = phi_minus_dist(hv_arr=hv_homogeneous, vh_arr=vh_homogeneous)
dat = [[n, d, dif, g, phi_m]]
df = pd.DataFrame(dat, columns=['numerator', 'denominator', 'diff', 'g', 'phi_m'])
if outfile is not None:
df.to_csv(outfile, sep=',', encoding='utf-8', index=None)
return df
def fit_radio_params(copol_params, a_deg=1, phi_deg=1, abs_file=None, php_file=None):
data = pd.read_csv(
copol_params,
usecols=["CR_ID", "INC_ANGLE", "A", "Phi_PLUS"]
)
inc_arr = list()
abs_arr = list()
php_arr = list()
for row in data.itertuples():
inc = row.INC_ANGLE
a = row.A
phi_p = row.Phi_PLUS
inc_arr.append(inc)
abs_arr.append(a)
php_arr.append(phi_p)
abs_arr = np.array(abs_arr)
php_arr = np.array(php_arr)
inc_arr = np.array(inc_arr) - np.deg2rad(45)
abs_coeffs = [np.polyfit(x=inc_arr, y=abs_arr, deg=a_deg)]
php_coeffs = [np.polyfit(x=inc_arr, y=php_arr, deg=phi_deg)]
abs_sub = np.arange(a_deg + 1).astype(str)
php_sub = np.arange(phi_deg + 1).astype(str)
abs_hdr = list(reversed(np.core.defchararray.add("A_", abs_sub).tolist()))
php_hdr = list(reversed(np.core.defchararray.add("a_", php_sub).tolist()))
df1 = pd.DataFrame(abs_coeffs, columns=abs_hdr)
df2 = pd.DataFrame(php_coeffs, columns=php_hdr)
if abs_file is not None:
df1.to_csv(abs_file, sep=',', encoding='utf-8', index=None)
if php_file is not None:
df2.to_csv(php_file, sep=',', encoding='utf-8', index=None)
return df1, df2
def write_copol_params(
abs_coeffs,
phi_coeffs,
inc_img,
abs_img_out,
php_img_out,
coeff_deg=False,
row_start=0,
col_start=0,
row_offset=None,
col_offset=None
):
inc_file = gdal.Open(inc_img)
inc_band = inc_file.GetRasterBand(1)
if row_offset is None:
row_offset = inc_band.XSize
if col_offset is None:
col_offset = inc_band.YSize
dat1 = pd.read_csv(abs_coeffs)
dat2 = pd.read_csv(phi_coeffs)
i_r, i_c = dat1.shape
p_r, p_c = dat2.shape
if i_r == 1 and p_r == 1:
i_coeffs = dat1.iloc[0].tolist()
p_coeffs = dat2.iloc[0].tolist()
driver = gdal.GetDriverByName("ENVI")
outfile_i = driver.Create(abs_img_out, row_offset, col_offset, 1, gdalconst.GDT_Float32)
band_i = outfile_i.GetRasterBand(1)
outfile_p = driver.Create(php_img_out, row_offset, col_offset, 1, gdalconst.GDT_Float32)
band_p = outfile_p.GetRasterBand(1)
for i in range(row_offset):
for j in range(col_offset):
r = row_start + i
c = col_start + j
inc_pix = inc_band.ReadAsArray(xoff=r, yoff=c, win_xsize=1, win_ysize=1)[0][0]
inc = inc_pix - (np.pi / 4.0)
if coeff_deg:
inc = np.rad2deg(inc)
abs_pix = np.polyval(i_coeffs, inc)
abs_pix = np.array([[abs_pix]])
band_i.WriteArray(abs_pix, xoff=i, yoff=j)
phip_pix = np.polyval(p_coeffs, inc)
phip_pix = np.array([[phip_pix]])
band_p.WriteArray(phip_pix, xoff=i, yoff=j)
if band_i is not None:
band_i.FlushCache()
band_p.FlushCache()
|
try:
pasw=input("please enter your password: ")
assert len(pasw)>8, "you have entered wrong lenght"
except AssertionError as obj:
print("you have enter wrong lenght of password")
finally:
print("Program terminated") |
"""empty message
Revision ID: a15584bf7905
Revises: f8ab52be12f8
Create Date: 2019-11-22 17:03:02.655881
"""
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = 'a15584bf7905'
down_revision = 'f8ab52be12f8'
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.alter_column('Artist', 'genres',
existing_type=postgresql.ARRAY(sa.VARCHAR()),
nullable=False)
op.alter_column('Artist', 'phone',
existing_type=sa.VARCHAR(length=120),
nullable=True)
op.alter_column('Venue', 'genres',
existing_type=postgresql.ARRAY(sa.VARCHAR()),
nullable=False)
op.alter_column('Venue', 'phone',
existing_type=sa.VARCHAR(length=120),
nullable=True)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.alter_column('Venue', 'phone',
existing_type=sa.VARCHAR(length=120),
nullable=False)
op.alter_column('Venue', 'genres',
existing_type=postgresql.ARRAY(sa.VARCHAR()),
nullable=True)
op.alter_column('Artist', 'phone',
existing_type=sa.VARCHAR(length=120),
nullable=False)
op.alter_column('Artist', 'genres',
existing_type=postgresql.ARRAY(sa.VARCHAR()),
nullable=True)
# ### end Alembic commands ###
|
import time
from tkinter import TclError
from snake.controller import Controller, UserControl
class View:
def __init__(self):
self.bound = False
self.ai_high_score = 0
self.player_high_score = 0
try:
self.controller = Controller(load_population=True)
except ValueError:
self.controller = Controller()
self.ui = self.controller.ui
self.user_control = UserControl(self.ui)
def ai_round(self, neural_network):
neural_network.reset_lifespan()
ai_screen = self.ui.ai_screen
self.ui.snake.reset(self.ui.grid)
self.ui.canvas.delete('all')
while self.ui.snake.is_alive:
# print(neural_network.lifespan)
neural_network.food_position.append(self.ui.grid.food.get_coord())
neural_network.decrease_lifespan()
neural_network.increase_fitness()
if self.ui.graphics:
self.ui.draw_canvas()
ai_screen.display_high_score(f'High Score: {self.ai_high_score}')
self.ui.frame.update()
decision = neural_network.make_decision()
if decision == 'up':
self.ui.snake.up()
elif decision == 'down':
self.ui.snake.down()
elif decision == 'left':
self.ui.snake.left()
elif decision == 'right':
self.ui.snake.right()
time.sleep(self.ui.ai_tick)
self.ui.snake.move()
if self.ui.snake.is_apple_eaten:
neural_network.increase_fitness(amount=neural_network.apple_increase)
neural_network.reset_lifespan()
self.ui.snake.is_apple_eaten = False
self.ui.canvas.delete('all')
self.ui.grid.generate_food()
if self.ui.grid.score > self.ai_high_score:
self.ai_high_score = self.ui.grid.score
self.ui.grid.score = 0
def goto_ai_screen(self):
self.ui.top_frame.grid(row=0, column=0)
self.unbind()
self.ui.graphics = True
self.ui.close_button_text.set('Menu')
self.ui.current_screen = 'AI_SCREEN'
population = self.controller.population
try:
while True:
self.run_population(population=population)
if self.ui.close:
population.save_genetic_data()
self.ui.close = False
break
population.get_next_generation()
for each in self.ui.top_frame.pack_slaves():
each.pack_forget()
self.goto_starting_screen()
except TclError:
print('TclError at (goto_ai_screen)')
def run_population(self, population):
for neural_network in population.members:
self.ai_round(neural_network=neural_network)
print(f'Fittest: {population.get_fittest().get_fitness()}, Average Fitness: {population.get_average_fitness()}')
def goto_starting_screen(self, event=None):
self.ui.canvas.delete("all")
self.ui.top_frame.grid_forget()
self.ui.plot_screen.plot_widget.grid_forget()
self.ui.current_screen = 'STARTING_SCREEN'
starting_screen = self.controller.get_starting_screen()
starting_screen.create_buttons()
self.ui.canvas.unbind("Button-1")
self.ui.canvas.tag_bind(starting_screen.play_button, "<Button-1>", self.play_game)
self.ui.canvas.tag_bind(starting_screen.ai_button, "<Button-1>", self.play_ai_mode)
self.ui.canvas.tag_bind(starting_screen.fittest_display_button, "<Button-1>", self.goto_display_fittest)
self.ui.canvas.tag_bind(starting_screen.plot_display_button, "<Button-1>", self.goto_plot_screen)
self.ui.canvas.grid(row=1, column=0)
def goto_plot_screen(self, event):
self.ui.canvas.grid_forget()
self.ui.top_frame.grid_forget()
self.ui.plot_screen.show()
self.ui.plot_screen.plot_widget.bind("<Button-1>", self.goto_starting_screen)
def goto_game_screen(self):
self.bind()
self.ui.grid.score = 0
self.ui.frame.after(0, self.user_control.move_snake)
self.ui.snake.reset(self.ui.grid)
self.ui.current_screen = 'GAME_SCREEN'
self.ui.canvas.delete('all')
try:
# Player Game Loop:
self.player_game_loop()
self.ui.grid.generate_food()
self.goto_starting_screen()
except TclError:
print('TclError')
def display_fittest_performance(self):
self.unbind()
self.ui.grid.score = 0
neural_network = self.controller.load_fittest()
fittest_display_screen = self.ui.fittest_display_screen
fittest_display_screen.close = False
self.ui.canvas.bind("<Button-1>", fittest_display_screen.set_close)
self.ui.current_screen = 'AI_SCREEN'
self.ui.snake.reset(self.ui.grid)
self.ui.canvas.delete('all')
for each in self.controller.load_food_coord():
if fittest_display_screen.close:
self.goto_starting_screen()
break
neural_network.increase_fitness()
self.ui.grid.food.set_coord(each)
self.ui.fittest_display_screen.display_current_score(self.ui.grid.score)
self.ui.draw_canvas()
self.ui.fittest_display_screen.display_text(text=f'Fitness: {neural_network.fitness}')
self.ui.frame.update()
decision = neural_network.make_decision()
if decision == 'up':
self.ui.snake.up()
elif decision == 'down':
self.ui.snake.down()
elif decision == 'left':
self.ui.snake.left()
elif decision == 'right':
self.ui.snake.right()
time.sleep(self.ui.watching_tick)
self.ui.snake.move()
if self.ui.snake.is_apple_eaten:
neural_network.increase_fitness(amount=neural_network.apple_increase)
neural_network.reset_lifespan()
self.ui.snake.is_apple_eaten = False
self.ui.canvas.delete('all')
self.goto_starting_screen()
def player_game_loop(self):
while self.ui.snake.is_alive:
self.ui.game_screen.display_current_score(current_score=self.ui.grid.score)
self.ui.draw_canvas()
self.ui.game_screen.display_high_score(high_score=f'High Score: {self.player_high_score}')
self.ui.frame.update()
self.ui.frame.after(self.ui.tick, self.ui.snake.move())
self.ui.canvas.delete('all')
if self.ui.grid.score > self.player_high_score:
self.player_high_score = self.ui.grid.score
def play_game(self, event):
self.goto_game_screen()
def play_ai_mode(self, event):
self.goto_ai_screen()
def goto_display_fittest(self, event):
try:
self.display_fittest_performance()
except TclError:
print('TclError')
def bind(self):
if not self.bound:
self.bound = True
frame = self.controller.ui.frame
frame.bind("<KeyPress-Up>", self.user_control.up)
frame.bind("<KeyPress-Down>", self.user_control.down)
frame.bind("<KeyPress-Left>", self.user_control.left)
frame.bind("<KeyPress-Right>", self.user_control.right)
def unbind(self):
if self.bound:
self.bound = False
frame = self.controller.ui.frame
frame.unbind("<KeyPress-Up>")
frame.unbind("<KeyPress-Down>")
frame.unbind("<KeyPress-Left>")
frame.unbind("<KeyPress-Right>")
|
import os, sys, json
import argparse
from copy import deepcopy
from gi.repository import Gtk, Gdk
def sort_name (model, a, b, data):
na = model.get_value (a, 0)
nb = model.get_value (b, 0)
if na > nb:
return 1
else:
return -1
def sort_valid (model, a, b, data):
va = model.get_value (a, 1)
vb = model.get_value (b, 1)
if va > vb:
return 1
else:
return -1
class StoryEditor:
def __init__ (self):
builder = Gtk.Builder()
builder.add_from_file ("StoryEditor.glade")
self.window = builder.get_object ("window1")
group = Gtk.AccelGroup()
self.window.add_accel_group(group)
builder.get_object("fileopen").connect("activate", self.open_cb)
builder.get_object("fileopen").add_accelerator("activate", group, ord('o'), \
Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE)
builder.get_object("toolopen").connect("clicked", self.open_cb)
builder.get_object("filesave").connect("activate", self.save_cb)
builder.get_object("filesave").add_accelerator("activate", group, ord('s'), \
Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE)
builder.get_object("toolsave").connect("clicked", self.save_cb)
builder.get_object("filesaveas").connect("activate", self.saveas_cb)
builder.get_object("filesaveas").add_accelerator("activate", group, ord('s'), \
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE)
#builder.get_object("filequit").connect("activate", Gtk.main_quit)
builder.get_object("nodeadd").connect("clicked", self.node_add_cb)
builder.get_object("nodedelete").connect("clicked", self.node_delete_cb)
builder.get_object("nodecopy").connect("clicked", self.node_copy_cb)
builder.get_object("choiceadd").connect("clicked", self.choice_add_cb)
builder.get_object("choicedelete").connect("clicked", self.choice_delete_cb)
self.prompt_text = builder.get_object("textview1")
self.imageentry = builder.get_object("imageentry")
self.musicentry = builder.get_object("musicentry")
# Main Treeview
self.liststore = builder.get_object("liststore1")
self.treeview = builder.get_object("treeview1")
sel = self.treeview.get_selection()
sel.set_mode(Gtk.SelectionMode.BROWSE)
sel.connect("changed", self.activate_row_cb)
col = builder.get_object("treeviewcolumn1")
textrenderer = Gtk.CellRendererText()
textrenderer.set_property("editable", True)
textrenderer.connect("edited", self.rename_node_cb)
col.pack_start (textrenderer, True)
col.add_attribute(textrenderer, "text", 0)
col.add_attribute(textrenderer, "background", 2)
self.liststore.set_sort_func(0, sort_name)
# Choices Treeview
self.choicestore = builder.get_object ("liststore_choices")
self.choiceview = builder.get_object ("treeview_choices")
col = builder.get_object("treeviewcolumn3")
textrenderer = Gtk.CellRendererText()
textrenderer.set_property("editable", True)
textrenderer.connect("edited", self.rename_choices_node_cb)
col.pack_start (textrenderer, True)
col.add_attribute(textrenderer, "text", 0)
col.add_attribute(textrenderer, "background", 2)
self.liststore.set_sort_func(0, sort_name)
col = builder.get_object("treeviewcolumn4")
textrenderer = Gtk.CellRendererText()
textrenderer.set_property("editable", True)
textrenderer.connect("edited", self.rename_choices_text_cb)
col.pack_start (textrenderer, True)
col.add_attribute(textrenderer, "text", 1)
col.add_attribute(textrenderer, "background", 2)
self.window.show_all()
self.window.connect ("destroy", Gtk.main_quit)
self.window.connect ("delete-event", self.on_exit)
self.json_file = ''
self.node = ''
self.story_object = {}
self.original_object = self.story_object
self.newnode = False
def open_cb (self, caller):
fcd = Gtk.FileChooserDialog("Open...", None, Gtk.FileChooserAction.SAVE, \
("Cancel", Gtk.ResponseType.CANCEL, "Open", Gtk.ResponseType.ACCEPT))
fcd.set_select_multiple(False)
fcd.set_local_only(False)
filter1 = Gtk.FileFilter()
filter1.add_pattern("*.json")
filter1.set_name("JSON Files (*.json)")
filter2 = Gtk.FileFilter()
filter2.add_pattern("*")
filter2.set_name("All Files (*)")
fcd.add_filter(filter1)
fcd.add_filter(filter2)
fcd.set_filter(filter1)
response = fcd.run()
if response == Gtk.ResponseType.ACCEPT:
path = fcd.get_filename()
if os.path.exists(path):
self.load_file(path)
fcd.destroy()
def save_cb (self, caller):
if os.path.exists(self.json_file):
self.save_file (self.json_file)
else:
self.saveas_cb (caller)
def saveas_cb (self, caller):
self.save_dialog()
def save_dialog (self):
fcd = Gtk.FileChooserDialog("Save As...", None, Gtk.FileChooserAction.SAVE, \
("Cancel", Gtk.ResponseType.CANCEL, "Save", Gtk.ResponseType.ACCEPT))
fcd.set_select_multiple(False)
fcd.set_local_only(False)
filter1 = Gtk.FileFilter()
filter1.add_pattern("*.json")
filter1.set_name("JSON Files (*.json)")
filter2 = Gtk.FileFilter()
filter2.add_pattern("*")
filter2.set_name("All Files (*)")
fcd.add_filter(filter1)
fcd.add_filter(filter2)
fcd.set_filter(filter1)
response = fcd.run()
if response == Gtk.ResponseType.ACCEPT:
path = fcd.get_filename()
if not path.lower().endswith('.json'):
path = path+'.json'
self.save_file(path)
fcd.destroy()
return True
fcd.destroy()
return False
def on_exit (self, window, event):
self.commit_changes()
if self.story_object == self.original_object:
return False
else:
md = Gtk.Dialog("", self.window, Gtk.DialogFlags.DESTROY_WITH_PARENT | Gtk.DialogFlags.MODAL,
("Close without Saving", Gtk.ResponseType.REJECT, Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
"Save", Gtk.ResponseType.ACCEPT) )
icon = Gtk.Image.new_from_stock(Gtk.STOCK_DIALOG_WARNING, Gtk.IconSize.DIALOG)
box = Gtk.Box()
box.add(icon)
box.add(Gtk.Label("The current file has been modified.\nDo you want to save?"))
md.get_content_area().pack_start(box, False, False, 0)
md.show_all()
result = md.run()
if result == Gtk.ResponseType.ACCEPT:
md.destroy()
if os.path.exists(self.json_file):
self.save_file(self.json_file)
return False
return not self.save_dialog()
if result == Gtk.ResponseType.CANCEL:
md.destroy()
return True
md.destroy()
return False
def load_file (self, path):
self.json_file = path
f = open (path)
self.story_object = json.load (f)
self.original_object = deepcopy(self.story_object)
self.liststore.clear()
for key in self.story_object.keys():
it = self.liststore.append ()
print key
self.liststore.set_value (it, 0, key)
self.liststore.set_value (it, 2, 'white')
first = self.liststore.get_iter_first()
self.treeview.get_selection().select_iter(first)
self.validate_choices()
self.validate_current_node()
self.update_title()
print 'Story json loaded'
def save_file (self, path):
self.commit_changes()
try:
f = open (path, 'w')
json.dump (self.story_object, f, sort_keys=True, indent=2)
f.close()
self.json_file = path
self.original_object = deepcopy(self.story_object)
self.update_title()
print 'Saved'
except OSError:
pass
def update_title (self):
self.window.set_title('Story Editor - ' + self.json_file)
def node_add_cb (self, caller):
print self.node
self.commit_changes()
self.newnode = True
it = self.liststore.append()
path = self.liststore.get_path(it)
col = self.treeview.get_column(0)
self.clear_form()
self.treeview.set_cursor(path, col, True)
def node_copy_cb (self, caller):
self.commit_changes()
self.newnode = True
# Get the current node name
rows = self.treeview.get_selection().get_selected_rows()
tp = rows[1][0]
it = self.liststore.get_iter(tp)
nodename = self.liststore.get_value(it, 0)
# Make the new node
itnew = self.liststore.append()
self.liststore.set_value(itnew, 0, nodename)
path = self.liststore.get_path(itnew)
col = self.treeview.get_column(0)
self.treeview.set_cursor(path, col, True)
def node_delete_cb (self, caller):
rows = self.treeview.get_selection().get_selected_rows()
tp = rows[1][0]
it = self.liststore.get_iter(tp)
node = self.liststore.get_value(it, 0)
if node in self.story_object.keys():
self.story_object.pop(node)
self.liststore.remove(it)
self.validate_choices()
self.validate_current_node()
def rename_node_cb (self, caller, path, new_text):
it = self.liststore.get_iter(path)
node = self.liststore.get_value(it, 0)
# Trying to rename to a node that exists
if new_text in self.story_object.keys() and new_text != node:
if node not in self.story_object.keys():
self.liststore.remove(it)
print 'Invalid new name'
else:
self.newnode = False
print 'Invalid rename'
return
# Check if being renamed or is a new node
if node in self.story_object.keys() and not self.newnode:
self.story_object[new_text] = self.story_object.pop(node)
print 'Rename'
else:
self.newnode = False
if new_text == '' or new_text == None or new_text in self.story_object.keys():
self.liststore.remove(it)
print 'Blank new name'
return
self.story_object[new_text] = {}
print 'Create new node '+new_text
print self.story_object[new_text]
self.liststore.set_value(it, 0, new_text)
self.node = new_text
self.commit_changes()
self.validate_choices()
self.validate_current_node()
def choice_add_cb (self, caller):
it = self.choicestore.append()
path = self.choicestore.get_path(it)
col = self.choiceview.get_column(0)
self.choiceview.set_cursor(path, col, True)
def choice_delete_cb (self, caller):
rows = self.choiceview.get_selection().get_selected_rows()
if len(rows[1]) > 0:
tp = rows[1][0]
it = self.choicestore.get_iter(tp)
self.choicestore.remove(it)
self.validate_choices()
self.validate_current_node()
def rename_choices_node_cb (self, caller, path, new_text):
it = self.choicestore.get_iter(path)
node = self.choicestore.get_value(it, 0)
self.choicestore.set_value(it, 0, new_text)
self.commit_changes()
#self.set_node(new_text)
self.validate_choices()
self.validate_current_node()
def rename_choices_text_cb (self, caller, path, new_text):
it = self.choicestore.get_iter(path)
node = self.choicestore.get_value(it, 1)
self.choicestore.set_value(it, 1, new_text)
def clear_form (self):
self.musicentry.set_text('')
self.imageentry.set_text('')
self.prompt_text.get_buffer().set_text('')
self.choicestore.clear()
def commit_changes (self):
if self.node in self.story_object.keys():
buf = self.prompt_text.get_buffer()
self.story_object[self.node]['text'] = buf.get_text(buf.get_start_iter(), buf.get_end_iter(), True)
self.story_object[self.node]['music'] = self.musicentry.get_text()
self.story_object[self.node]['image'] = self.imageentry.get_text()
choices = []
for row in self.choicestore:
choices.append ({'node':row[0], 'text':row[1]})
self.story_object[self.node]['choices'] = choices
def set_node (self, node):
if not node in self.story_object.keys():
print 'Invalid set node'
return
story_node = self.story_object[node]
self.node = node
if 'text' in story_node.keys():
self.prompt_text.get_buffer().set_text (str(story_node['text']))
else:
self.prompt_text.get_buffer().set_text('')
if 'music' in story_node.keys():
self.musicentry.set_text(str(story_node['music']))
else:
self.musicentry.set_text('')
if 'image' in story_node.keys():
self.imageentry.set_text(str(story_node['image']))
else:
self.imageentry.set_text('')
self.choicestore.clear()
if 'choices' in story_node.keys():
for choice in story_node['choices']:
it = self.choicestore.append()
if 'node' in choice.keys():
self.choicestore.set_value(it, 0, str(choice['node']))
if 'text' in choice.keys():
self.choicestore.set_value(it, 1, str(choice['text']))
self.validate_current_node()
self.validate_choices()
def validate_choices (self):
for row in self.liststore:
node = self.story_object[row[0]]
valid = True
if 'choices' in node.keys():
choices = node['choices']
for choice in choices:
if 'node' in choice.keys():
if not choice['node'] in self.story_object.keys():
valid = False
else:
valid = False
row[1] = valid
colors = ['#FFB0B0', 'white']
row[2] = colors[valid]
def validate_current_node (self):
for row in self.choicestore:
if row[0] not in self.story_object.keys():
row[2] = '#FFB0B0'
else:
row[2] = 'white'
def activate_row_cb (self, caller):
if not self.newnode:
self.commit_changes()
rows = caller.get_selected_rows()
if len(rows[1]) > 0:
tp = rows[1][0]
it = self.liststore.get_iter(tp)
self.set_node (self.liststore.get_value (it, 0))
parser = argparse.ArgumentParser (description='Edit a json story file')
parser.add_argument ('infile', nargs='?')
args = parser.parse_args()
s = StoryEditor()
if args.infile != None:
if os.path.exists(args.infile):
s.load_file(args.infile)
Gtk.main()
|
import unittest
import tkinter as tk
from Logic.GameState import GameState
from Logic.Hand import Hand
from Logic.Card import Card
class UnitTests(unittest.TestCase):
def test_someone_has_blackjack_3(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "J"))
gameState.player_hand.add_card(Card("Hearts", "A"))
gameState.dealer_hand.add_card(Card("Spades", "A"))
gameState.dealer_hand.add_card(Card("Clubs", "Q"))
self.assertEqual(gameState.someone_has_blackjack(), "dp",
"Expected both the dealer and the player to have blackjack")
def test_someone_has_blackjack_2(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "2"))
gameState.player_hand.add_card(Card("Hearts", "2"))
gameState.dealer_hand.add_card(Card("Spades", "A"))
gameState.dealer_hand.add_card(Card("Clubs", "Q"))
self.assertEqual(gameState.someone_has_blackjack(), "d", "Expected the dealer to have blackjack")
def test_someone_has_blackjack_1(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "A"))
gameState.player_hand.add_card(Card("Hearts", "J"))
gameState.dealer_hand.add_card(Card("Spades", "2"))
gameState.dealer_hand.add_card(Card("Clubs", "2"))
self.assertEqual(gameState.someone_has_blackjack(), "p", "Expected the player to have blackjack")
def test_hit_method_4(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "J"))
gameState.player_hand.add_card(Card("Hearts", "8"))
gameState.player_hand.add_card(Card("Hearts", "J"))
gameState.dealer_hand.add_card(Card("Spades", "A"))
gameState.dealer_hand.add_card(Card("Clubs", "J"))
winner = gameState.hit()
self.assertEqual(winner, 'd', "Expected the dealer to have blackjack")
def test_hit_method_1(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "J"))
gameState.player_hand.add_card(Card("Hearts", "J"))
gameState.dealer_hand.add_card(Card("Spades", "2"))
gameState.dealer_hand.add_card(Card("Clubs", "2"))
winner = gameState.hit()
self.assertTrue(gameState.player_hand.get_value() > 20,
"Expected the value of the player's hand to be greater than 20")
self.assertEqual(gameState.dealer_hand.get_value(), 4,
"Expected the value of the dealer's hand to be equal to 4")
self.assertTrue(winner == 'd', "Expected the dealer to win")
def test_get_table_state_5(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "A"))
gameState.player_hand.add_card(Card("Hearts", "J"))
gameState.dealer_hand.add_card(Card("Spades", "A"))
gameState.dealer_hand.add_card(Card("Clubs", "K"))
table_state = gameState.get_table_state()
print(table_state)
expected_state = {
'player_cards': [Card("Diamonds", "A"), Card("Hearts", "J")],
'dealer_cards': [Card("Spades", "A"), Card("Clubs", "K")],
'has_winner': 'dp',
'blackjack': True,
}
self.assertEqual(str(expected_state['player_cards']), str(table_state['player_cards']),
"The player's cards did not match the expected state")
self.assertEqual(str(expected_state['dealer_cards']), str(table_state['dealer_cards']),
"The dealer's cards did not match the expected state")
self.assertEqual('dp', table_state['has_winner'], "The results were expected to be a tie")
self.assertEqual(True, table_state['blackjack'], "The winners were expected to have blackjack")
def test_get_table_state_4(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "K"))
gameState.player_hand.add_card(Card("Diamonds", "6"))
gameState.player_hand.add_card(Card("Hearts", "J"))
gameState.dealer_hand.add_card(Card("Spades", "2"))
gameState.dealer_hand.add_card(Card("Clubs", "2"))
table_state = gameState.get_table_state()
expected_state = {
'player_cards': [Card("Diamonds", "K"), Card("Diamonds", "6"), Card("Hearts", "J")],
'dealer_cards': [Card("Spades", "2"), Card("Clubs", "2")],
'has_winner': False,
'blackjack': False,
}
self.assertEqual(str(expected_state['player_cards']), str(table_state['player_cards']),
"The player's cards did not match the expected state")
self.assertEqual(str(expected_state['dealer_cards']), str(table_state['dealer_cards']),
"The dealer's cards did not match the expected state")
self.assertEqual(False, table_state['has_winner'], "The player was not expected to win")
self.assertEqual(False, table_state['blackjack'], "The winner was not expected to have blackjack")
def test_get_table_state_3(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "5"))
gameState.player_hand.add_card(Card("Diamonds", "6"))
gameState.player_hand.add_card(Card("Hearts", "J"))
gameState.dealer_hand.add_card(Card("Spades", "2"))
gameState.dealer_hand.add_card(Card("Clubs", "2"))
table_state = gameState.get_table_state()
expected_state = {
'player_cards': [Card("Diamonds", "5"), Card("Diamonds", "6"), Card("Hearts", "J")],
'dealer_cards': [Card("Spades", "2"), Card("Clubs", "2")],
'has_winner': 'p',
'blackjack': True,
}
self.assertEqual(str(expected_state['player_cards']), str(table_state['player_cards']),
"The player's cards did not match the expected state")
self.assertEqual(str(expected_state['dealer_cards']), str(table_state['dealer_cards']),
"The dealer's cards did not match the expected state")
self.assertEqual('p', str(table_state['has_winner']), "The player was expected to have won")
self.assertEqual(True, table_state['blackjack'], "The winner was expected to have blackjack")
def test_get_table_state_2(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "2"))
gameState.player_hand.add_card(Card("Hearts", "2"))
gameState.dealer_hand.add_card(Card("Spades", "A"))
gameState.dealer_hand.add_card(Card("Clubs", "J"))
table_state = gameState.get_table_state()
expected_state = {
'player_cards': [Card("Diamonds", "2"), Card("Hearts", "2")],
'dealer_cards': [Card("Spades", "A"), Card("Clubs", "J")],
'has_winner': 'd',
'blackjack': True,
}
self.assertEqual(str(expected_state['player_cards']), str(table_state['player_cards']),
"The player's cards did not match the expected state")
self.assertEqual(str(expected_state['dealer_cards']), str(table_state['dealer_cards']),
"The dealer's cards did not match the expected state")
self.assertEqual('d', str(table_state['has_winner']), "The dealer was expected to have won")
self.assertEqual(True, table_state['blackjack'], "The winner was expected to have blackjack")
def test_get_table_state_1(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "A"))
gameState.player_hand.add_card(Card("Hearts", "J"))
gameState.dealer_hand.add_card(Card("Spades", "2"))
gameState.dealer_hand.add_card(Card("Clubs", "2"))
table_state = gameState.get_table_state()
expected_state = {
'player_cards': [Card("Diamonds", "A"), Card("Hearts", "J")],
'dealer_cards': [Card("Spades", "2"), Card("Clubs", "2")],
'has_winner': 'p',
'blackjack': True,
}
self.assertEqual(str(expected_state['player_cards']), str(table_state['player_cards']),
"The player's cards did not match the expected state")
self.assertEqual(str(expected_state['dealer_cards']), str(table_state['dealer_cards']),
"The dealer's cards did not match the expected state")
self.assertEqual('p', str(table_state['has_winner']), "The player was expected to have won")
self.assertEqual(True, table_state['blackjack'], "The winner was expected to have blackjack")
def test_get_final_state_4(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "2"))
gameState.player_hand.add_card(Card("Hearts", "2"))
gameState.player_hand.add_card(Card("Hearts", "7"))
gameState.dealer_hand.add_card(Card("Spades", "A"))
gameState.dealer_hand.add_card(Card("Clubs", "A"))
final_state = gameState.calculate_final_state()
expected_final_state = {
'player_cards': [Card("Diamonds", "2"), Card("Hearts", "2"), Card("Hearts", "7")],
'dealer_cards': [Card("Spades", "A"), Card("Clubs", "A")],
'has_winner': 'd',
}
self.assertEqual(str(expected_final_state['player_cards']), str(final_state['player_cards']),
"The player's cards did not match the expected state")
self.assertEqual(str(expected_final_state['dealer_cards']), str(final_state['dealer_cards']),
"The dealer's cards did not match the expected state")
self.assertEqual('d', final_state['has_winner'])
def test_get_final_state_3(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "2"))
gameState.player_hand.add_card(Card("Hearts", "2"))
gameState.dealer_hand.add_card(Card("Spades", "A"))
gameState.dealer_hand.add_card(Card("Clubs", "J"))
final_state = gameState.calculate_final_state()
expected_final_state = {
'player_cards': [Card("Diamonds", "2"), Card("Hearts", "2")],
'dealer_cards': [Card("Spades", "A"), Card("Clubs", "J")],
'has_winner': 'd',
}
self.assertEqual(str(expected_final_state['player_cards']), str(final_state['player_cards']),
"The player's cards did not match the expected state")
self.assertEqual(str(expected_final_state['dealer_cards']), str(final_state['dealer_cards']),
"The dealer's cards did not match the expected state")
self.assertEqual('d', final_state['has_winner'], "The dealer was expected to win")
def test_get_final_state_2(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "6"))
gameState.player_hand.add_card(Card("Hearts", "5"))
gameState.player_hand.add_card(Card("Hearts", "J"))
gameState.dealer_hand.add_card(Card("Spades", "2"))
gameState.dealer_hand.add_card(Card("Clubs", "2"))
final_state = gameState.calculate_final_state()
expected_final_state = {
'player_cards': [Card("Diamonds", "6"), Card("Hearts", "5"), Card("Hearts", "J")],
'dealer_cards': [Card("Spades", "2"), Card("Clubs", "2")],
'has_winner': 'p',
}
self.assertEqual(str(expected_final_state['player_cards']), str(final_state['player_cards']),
"The player's cards did not match the expected state")
self.assertEqual(str(expected_final_state['dealer_cards']), str(final_state['dealer_cards']),
"The dealer's cards did not match the expected state")
self.assertEqual('p', final_state['has_winner'], "The player was expected to win")
def test_get_final_state_1(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.dealer_hand = Hand(dealer=True)
gameState.player_hand.add_card(Card("Diamonds", "A"))
gameState.player_hand.add_card(Card("Hearts", "J"))
gameState.dealer_hand.add_card(Card("Spades", "2"))
gameState.dealer_hand.add_card(Card("Clubs", "2"))
final_state = gameState.calculate_final_state()
expected_final_state = {
'player_cards': [Card("Diamonds", "A"), Card("Hearts", "J")],
'dealer_cards': [Card("Spades", "2"), Card("Clubs", "2")],
'has_winner': 'p',
}
self.assertEqual(str(expected_final_state['player_cards']), str(final_state['player_cards']),
"The player's cards did not match the expected state")
self.assertEqual(str(expected_final_state['dealer_cards']), str(final_state['dealer_cards']),
"The dealer's cards did not match the expected state")
self.assertEqual('p', final_state['has_winner'], "The player was expected to win")
def test_player_score_3(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.player_hand.add_card(Card("Diamonds", "A"))
gameState.player_hand.add_card(Card("Hearts", "J"))
expected_msg = "Score: 21"
msg = gameState.player_score_as_text()
self.assertEqual(expected_msg, msg, "Double check the output format of the string")
def test_player_score_2(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.player_hand.add_card(Card("Diamonds", "8"))
gameState.player_hand.add_card(Card("Hearts", "4"))
gameState.player_hand.add_card(Card("Clubs", "5"))
expected_msg = "Score: 17"
msg = gameState.player_score_as_text()
print(msg)
self.assertEqual(expected_msg, msg, "Double check the output format of the string")
def test_player_score_1(self):
root = tk.Tk()
gameState = GameState()
gameState.player_hand = Hand()
gameState.player_hand.add_card(Card("Diamonds", "2"))
gameState.player_hand.add_card(Card("Hearts", "2"))
expected_msg = "Score: 4"
msg = gameState.player_score_as_text()
print(msg)
self.assertEqual(expected_msg, msg, "Double check the output format of the string")
|
# coding: utf-8
import pandas
from numpy import isnan
country = "us"
spider = "gpmn_parks"
_type = "pollution"
source_name = "https://www.nps.gov"
in_file_name = "{0}_{1}_{2}_stations.txt".format(country, spider, _type)
out_file_name = "add_station_{0}_{1}_{2}.sql".format(country, spider, _type)
data_frame = pandas.read_csv(in_file_name, ";", dtype="str")
data_frame['elev'] = data_frame['elev'].astype(float)
# print(data_frame)
open(out_file_name, "w").close()
# print(data_frame)
for iitem in range(data_frame.shape[0]):
row = data_frame.iloc[iitem, ]
sqlfile = open(out_file_name, "a")
address = str(row.address)
if "'" in address:
address = address.replace("'", "''")
station_name = str(row.station_name)
if "'" in station_name:
station_name = row.station_name.replace("'", "''")
if isnan(row.elev):
elev = 'NULL'
else:
elev = "'{0}'".format(row.elev)
record = """
INSERT INTO station(lon, lat, address, code, source, name, country, spider, elev, type)
VALUES ({0}, {1}, '{2}', '{3}', '{4}', '{5}', '{6}', '{7}', {8}, '{9}');
""".format(row.lon, row.lat, address, row.station_id, source_name, station_name, country, spider, elev, _type)
# record_one = """
# INSERT INTO scrapper_station(lon, lat, address, source_id, source, st_name)
# VALUES ({0}, {1}, '{2}', '{3}', '{4}', '{5}');
# """.format(row.lon, row.lat, row.address, row.station_id, source_name, row.station_name)
#
# record_two = """
# INSERT INTO scrapper_map(lon, lat, address, source_id, source, st_name)
# VALUES ({0}, {1}, '{2}', '{3}', '{4}', '{5}');
# """.format(row.lon, row.lat, row.address, row.station_id, source_name, row.station_name)
sqlfile.write(record)
|
#!/Library/Frameworks/Python.framework/Versions/3.7/bin/python3
# To compile: python ./name.py
import sys, os
from tkinter import *
from tkinter import messagebox
import subprocess
#####------------------------------------------------(Constants)
#arguments=
#name=
#path=
#version=1.0
program_name="template"
def sep(): #print a separator line
print('---------------------------------------')
def welcome():
print('\033[1;31m***********************************\033[1;m')
print('\033[1;31m*******Welcome to my program*******\033[1;m')
print('\033[1;31m***********************************\033[1;m\n')
print('Usage: program [option]')
def goodbye():
print('\033[1;34m***********************************\033[1;m')
print('\033[1;34m*************GOOD BYE**************\033[1;m')
print('\033[1;34m***********************************\033[1;m')
exit()
def zero():
window.destroy()
goodbye()
def one():
#call a system process and pipes it to variable results_message
results_message = subprocess.Popen(["ls"], stdout = subprocess.PIPE, stderr = subprocess.STDOUT).communicate()[0]
results.delete("1.0", END)
results.insert("1.0", "Files in current directory :\n\n")
results.tag_add("start", "1.0", "1.30")
results.tag_config("start", background="black", foreground="purple")
return
def two():
print("Hello from two")
"""
results.delete("1.0", END)
results.insert("1.0", "This functions has called samba on 192.168.0.101\n\n")
os.system('open smb://192.168.0.101')
"""
return
def three():
print("Hello from three")
return
def four():
print("Hello from four")
return
def five():
print("Hello from five")
return
def six():
print("Hello from 6 ")
return
def seven():
print("Hello from 7")
return
def eight():
print("Hello from 8")
return
def nine():
print("Hello from 9")
return
def ten():
print("Hello from 10")
return
def printmenu():
a = """
PROGRAM MENU:
1- Not implemented
2- Not implemented
3- Not implemented
4- Not implemented
5- Not implemented
6- Not implemented
7- Not implemented
8- Not implemented
9- Not implemented
10-Not implemented
0-Exit
"""
print(a)
####GUI PROGRAMMING-----------------------------------(GUI ELEMENTS)
#This creates the window object
window = Tk()
#Size of window
window.geometry("800x600")
window.title("Welcome to " + program_name)
#-----------------------Text--------------------------
#Welcome Message
welcome = Text(window)
welcome.insert(INSERT, "Welcome to " + program_name)
welcome.place(bordermode=OUTSIDE, height=50, width=600)
results = Text(window)
results.insert(INSERT, "Program results : " )
results.place(bordermode=INSIDE, x=150, y=50)
#-----------------------Text End----------------------
#-----------------------Buttons-----------------------
#Size of window
#Button one
B1 = Button(window, text = "Function 1", command = one)
#Location of button in window
B1.place(x = 0, y = 50)
#Button two
B2 = Button(window, text = "Function 2", command = two)
#Location of button in window
B2.place(x = 0, y = 80)
#Button three
B3 = Button(window, text = "Function 3", command = three)
#Location of button in window
B3.place(x = 0, y = 110)
#Button four
B4 = Button(window, text = "Function 4", command = four)
#Location of button in window
B4.place(x = 0, y = 140)
#Button five
B5 = Button(window, text = "Function 5", command = five)
#Location of button in window
B5.place(x = 0, y = 170)
#Button six
B5 = Button(window, text = "Function 6", command = six)
#Location of button in window
B5.place(x = 0, y = 200)
#Button seven
B6 = Button(window, text = "Function 7", command = seven)
#Location of button in window
B6.place(x = 0, y = 230)
#Button eight
B7 = Button(window, text = "Function 8", command = eight)
#Location of button in window
B7.place(x = 0, y = 260)
#Button nine
B8 = Button(window, text = "Function 9", command = nine)
#Location of button in window
B8.place(x = 0, y = 290)
#Button ten
B9 = Button(window, text = "Function 10", command = ten)
#Location of button in window
B9.place(x = 0, y = 320)
#Button quit
B10 = Button(window, text = "Quit program", bg = "red", command = zero)
#Location of button in window
B10.place(x = 0, y = 500)
#-----------------------Buttons end--------------------
####GUI PROGRAMMING------------------------------(END GUI ELEMENTS)
#### Main ----------------------------------------(Main)
#This keeps alive window-----------------
window.mainloop()
|
#!/usr/bin/python3
# include required libraries
import csv
import xml.etree.ElementTree as ET
import sys
import re
# get file objects from cl
if len(sys.argv) == 3:
teixml_input_file = open(sys.argv[1])
csv_input_file = open(sys.argv[2])
else:
sys.exit("Must include files with TEI and reference URIs")
outfilename = teixml_input_file.name + 'out.tei'
# parse files
xml = ET.parse(teixml_input_file)
# https://docs.python.org/2/library/xml.etree.elementtree.html#parsing-xml-with-namespaces
root = xml.getroot()
# get all name nodes
names = root.findall('.//name')
# next() skips the first row of the CSV file.
terms = csv.reader(csv_input_file)
terms_for_matching = dict(terms)
# iterate csv and xml and make replacements
for node in names:
if node.text in terms_for_matching:
node.attrib['ref'] = terms_for_matching[node.text]
# write to output file
xml.write(outfilename)
input("\n\n*** Updated xml saved to {0}, press <enter>").format(outfilename)
|
class Solution:
def solve(self, A):
my_map = {}
running_sum = 0
for i in A:
running_sum += i
if my_map.get(running_sum) is not None or running_sum == 0:
return 1
else:
my_map[running_sum]=running_sum
return -1
print(Solution().solve([5, 17, -22, 11]))
|
import tensorflow as tf
from PIL import Image
import os
# os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
# os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
from network import encoder, decoder
from ops import *
from utils import *
class main:
def __init__(self):
self.content = tf.placeholder("float", [None, None, None, 3])
self.style = tf.placeholder("float", [None, None, None, 3])
lamda = 2
batch_size = 2
en = encoder("encoder")
de = decoder("decoder")
feature_bank_c = en(preprocess(tf.reverse(self.content, [-1])))
feature_bank_s = en(preprocess(tf.reverse(self.style, [-1])))
t = AdaIn(feature_bank_c["relu4_1"], feature_bank_s["relu4_1"])
self.styled_img = de(t)
feature_bank_g = en(preprocess(tf.reverse(self.styled_img, [-1])))
self.content_loss = content_loss(feature_bank_g["relu4_1"], t)
self.style_loss = style_loss(feature_bank_g, feature_bank_s)
self.Loss = self.content_loss + lamda * self.style_loss
self.Opt = tf.train.AdamOptimizer(1e-4).minimize(self.Loss)
self.sess = tf.Session()
self.sess.run(tf.global_variables_initializer())
content_list = os.listdir("./content/")
style_list = os.listdir("./style/")
saver = tf.train.Saver()
for i in range(80000):
content_batch_locs = np.random.randint(0, content_list.__len__(), batch_size)
style_batch_locs = np.random.randint(0, style_list.__len__(), batch_size)
content_batch = np.zeros([batch_size, 128, 128, 3])
style_batch = np.zeros([batch_size, 128, 128, 3])
for j in range(batch_size):
try:
content_batch[j, :, :, :] = resize_and_crop(np.array(Image.open("./content/" + content_list[content_batch_locs[j]])), 128)
style_batch[j, :, :, :] = resize_and_crop(np.array(Image.open("./style/" + style_list[style_batch_locs[j]])), 128)
except:
content_batch[j, :, :, :] = resize_and_crop(np.array(Image.open("./content/" + content_list[0])), 128)
style_batch[j, :, :, :] = resize_and_crop( np.array(Image.open("./style/" + style_list[0])), 128)
self.sess.run(self.Opt, feed_dict={self.content: content_batch, self.style: style_batch})
if i % 10 == 0:
[styled_img, Loss, c_loss, s_loss] = self.sess.run([self.styled_img, self.Loss, self.content_loss, self.style_loss], feed_dict={self.content: content_batch, self.style: style_batch})
print("Step: %d, Total_loss: %f, Content_loss: %f, Style_loss: %f"%(i, Loss, c_loss, s_loss))
Image.fromarray(np.uint8(mapping(styled_img[0, :, :, :]))).save("./result/"+str(i)+".jpg")
if i % 2000 == 0:
saver.save(self.sess, "./trained_para/model.ckpt")
def test(content_path, style_path, alpha=1.0):
c = np.array(Image.open(content_path))
c = np.reshape(c, [1, c.shape[0], c.shape[1], c.shape[2]])
s = np.array(Image.open(style_path))
s = np.reshape(s, [1, s.shape[0], s.shape[1], s.shape[2]])
content = tf.placeholder("float", [1, c.shape[1], c.shape[2], 3])
style = tf.placeholder("float", [1, s.shape[1], s.shape[2], 3])
en = encoder("encoder")
de = decoder("decoder")
feature_bank_c = en(preprocess(tf.reverse(content, [-1])))["relu4_1"]
feature_bank_s = en(preprocess(tf.reverse(style, [-1])))["relu4_1"]
t = AdaIn(feature_bank_c, feature_bank_s)
styled_img = de((1 - alpha) * feature_bank_c + alpha * t)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess, "./trained_para/model.ckpt")
[styled_img] = sess.run([styled_img],feed_dict={content: c, style: s})
Image.fromarray(np.uint8(styled_img[0, :, :, :])).show()
if __name__ == "__main__":
istraining = True
if istraining:
main()
else:
test()
|
from requests.packages.urllib3 import disable_warnings
from requests.packages.urllib3.exceptions import InsecureRequestWarning
from sampledata import getyaml
from src import loginOS, snmp, system
disable_warnings(InsecureRequestWarning)
# Login to Switch
data = getyaml.readyaml('data-device-mgmt.yaml')
# Iterate through the devices in data-device-mgmt.yaml file to update User password and create new SNMP Communities
for device in data['devices']:
baseurl = "https://{}/rest/v4/".format(device["ip_address"])
cookie_header = loginOS.login_os(device, baseurl)
try:
userFound = False
communityFound = False
communities = snmp.get_snmp_communities(baseurl, cookie_header)
print(communities['snmp_server_community_element'])
for community in communities['snmp_server_community_element']:
if community['community_name'] == device["past_snmp"]:
communityFound = True
print("Creating SNMP community string: {} in switch: {}.".format(
device["past_snmp"], device["ip_address"]))
result = snmp.create_snmp_community(baseurl, cookie_header, device["new_snmp"], community)
if result == 201:
snmp.delete_snmp_community(baseurl, cookie_header, device["past_snmp"])
if not communityFound:
print("SNMP community string: {} not found in switch: {}".format(device["past_snmp"], device["ip_address"]))
users = system.get_device_users(baseurl, cookie_header)
for current_user in users['device_management_user_element']:
if current_user['name'] == device['change_user']:
userFound = True
print("User {} found on {}. Updating user info".format(device['change_user'], device['ip_address']))
resp = system.update_device_user(baseurl, cookie_header, device['change_pass'], current_user)
new_user = device
if resp == 200:
print("User update successful, Validating new password by logging in.")
device1 = {"user": device['change_user'], "password": device['change_pass']}
test_cookie = loginOS.login_os(device1, baseurl)
loginOS.logout(baseurl, test_cookie)
if not userFound:
print("User {} not found on {}.".format(device["user"], device["ip_address"]))
except Exception as error:
print('Ran into exception: {}. Logging out..'.format(error))
# Logout from switch
loginOS.logout(baseurl, cookie_header)
|
from recommenders.cb_recommender import CBRecommender
from recommenders.cbf_recommender import CBFRecommender
from utils.recommendations_helper import RecommendationsHelper
class WeightedHybridRecommender:
def __init__(self):
self.MIN_NUM_OF_ITEMS = 20
self.MAIN_RECOMMENDER_WEIGHT = .8
self.SECOND_RECOMMENDER_WEIGHT = .2
def get_recommendations(self, user_id, movie_id, take, skip, genres, movie_type, rec_type, sim_type, sim_source,
order_by):
count = len(RecommendationsHelper.get_user_rated_movies(user_id))
recommendations = []
cb_order_columns = ['similarity', 'es_score']
cbf_order_columns = ['rating', 'es_score']
cb_order_by = [column for column in order_by if column in cb_order_columns]
cbf_order_by = [column for column in order_by if column in cbf_order_columns]
if count == 0:
cb_recommendations = CBRecommender.get_recommendations(movie_id, take, sim_source, genres, movie_type,
cb_order_by)
recommendations.extend(cb_recommendations['recommendations'])
elif count >= self.MIN_NUM_OF_ITEMS:
cbf_take = round(take * self.MAIN_RECOMMENDER_WEIGHT)
cb_take = round(take * self.SECOND_RECOMMENDER_WEIGHT)
cb_recommendations = CBRecommender.get_recommendations(movie_id, cb_take, sim_source, genres, movie_type,
cb_order_by)
if rec_type == 'item-based':
cbf_recommendations = CBFRecommender.get_recommendations_item_based(user_id, cbf_take, skip, genres,
movie_type, sim_type, sim_source,
cbf_order_by)
elif rec_type == 'user-based':
cbf_recommendations = CBFRecommender.get_recommendations_user_based(user_id, cbf_take, skip, genres,
movie_type, sim_type, sim_source,
cbf_order_by)
else:
cbf_recommendations = CBFRecommender.get_recommendations(user_id, cbf_take, skip, genres, movie_type,
sim_source, cbf_order_by)
recommendations.extend(cbf_recommendations['recommendations'])
recommendations.extend(cb_recommendations['recommendations'])
else:
cbf_take = round(take * self.SECOND_RECOMMENDER_WEIGHT)
cb_take = round(take * self.MAIN_RECOMMENDER_WEIGHT)
cb_recommendations = CBRecommender.get_recommendations(movie_id, cb_take, sim_source, genres, movie_type,
cb_order_by)
if rec_type == 'item-based':
cbf_recommendations = CBFRecommender.get_recommendations_item_based(user_id, cbf_take, skip, genres,
movie_type, sim_type, sim_source,
cbf_order_by)
elif rec_type == 'user-based':
cbf_recommendations = CBFRecommender.get_recommendations_user_based(user_id, cbf_take, skip, genres,
movie_type, sim_type, sim_source,
cbf_order_by)
else:
cbf_recommendations = CBFRecommender.get_recommendations(user_id, cbf_take, skip, genres, movie_type,
sim_source, cbf_order_by)
recommendations.extend(cbf_recommendations['recommendations'])
recommendations.extend(cb_recommendations['recommendations'])
return recommendations
|
# Generated by Django 2.1.7 on 2019-03-18 08:18
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('utils', '0001_initial'),
]
operations = [
migrations.AlterModelOptions(
name='comment',
options={'verbose_name': '评论', 'verbose_name_plural': '评论'},
),
migrations.AddField(
model_name='comment',
name='parent',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='parent_comment', to='utils.Comment'),
),
migrations.AddField(
model_name='comment',
name='reply_auth',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='reply_auth', to=settings.AUTH_USER_MODEL),
),
migrations.AddField(
model_name='comment',
name='root',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='root_comment', to='utils.Comment'),
),
migrations.AlterField(
model_name='comment',
name='auth',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='auth', to=settings.AUTH_USER_MODEL, verbose_name='用户'),
),
]
|
class Solution(object):
def subdomainVisits(self, cpdomains):
"""
一个网站域名，如"discuss.leetcode.com"，包含了多个子域名。
作为顶级域名，常用的有"com"，下一级则有"leetcode.com"，最低的一级为"discuss.leetcode.com"。
当我们访问域名"discuss.leetcode.com"时，也同时访问了其父域名"leetcode.com"以及顶级域名 "com"。
给定一个带访问次数和域名的组合，要求分别计算每个域名被访问的次数。其格式为访问次数+空格+地址，
例如："9001 discuss.leetcode.com"。
接下来会给出一组访问次数和域名组合的列表cpdomains 。
要求解析出所有域名的访问次数，输出格式和输入格式相同，不限定先后顺序。
:type cpdomains: List[str]
:rtype: List[str]
"""
if not cpdomains:
return []
lookup = {}
for item in cpdomains:
temp = item.split(" ")
temp_num = int(temp[0])
for i in range(len(temp[1])):
if i == 0:
duan_str = temp[1]
if duan_str in lookup:
lookup[duan_str] += temp_num
else:
lookup[duan_str] = temp_num
elif temp[1][i] == ".":
duan_str = temp[1][i+1:]
if duan_str in lookup:
lookup[duan_str] += temp_num
else:
lookup[duan_str] = temp_num
res = []
for key,val in lookup.items():
res.append(str(val) + " "+ key)
return res
a = Solution()
print(a.subdomainVisits(["9001 discuss.leetcode.com"]))
print(a.subdomainVisits(["900 google.mail.com", "50 yahoo.com", "1 intel.mail.com", "5 wiki.org"]))
|
import glob
import os
import sys
INPUT_DIR = sys.argv[0]
out_filename = "combined_seizure_reports.csv"
if os.path.exists(out_filename):
os.remove(out_filename)
read_files = glob.glob("INPUT_DIR/*.csv")
with open(out_filename, "w") as outfile:
for filename in read_files:
with open(filename) as infile:
for line in infile:
outfile.write('{},{}\n'.format(line.strip(), os.path.basename(filename))) |
# Hae ubuntun manuaalisivuilta monikielistä dataa ja tee niistä käännösmuisti
from clusters import MultiLangDocu
MyDocu = MultiLangDocu(["fi","en","de","fr","ru","sv"])
for theme in ["net-wireless","files","clock","prefs-language","prefs-display","media","accounts","shell-overview","tips","a11y","printing","bluetooth","color","keyboard","mouse","power"]:
print("STARTING " + theme)
MyDocu.ParseCluster(theme)
|
from .util import load_image, terminate
from .settings import FPS
import pygame
class Pause:
def __init__(self, game):
self.game = game
self.surface = self.game.surface
self.init_images()
self.resume = self.resume_images[0]
self.exit = self.exit_images[0]
self.main_menu = self.main_menu_images[0]
self.restart = self.restart_images[0]
self.background = load_image("start_background.png")
self.run()
def init_images(self):
resume = load_image("resume.png")
self.resume_images = [(resume, (412, 100)),
(pygame.transform.scale(resume, (211, 58)), (395, 100))]
restart = load_image("restart.png")
self.restart_images = [(restart, (412, 200)),
(pygame.transform.scale(restart, (211, 58)), (395, 200))]
exit = load_image("exit.png")
self.exit_images = [(exit, (412, 400)),
(pygame.transform.scale(exit, (211, 58)), (395, 400))]
main_menu = load_image("main_menu.png")
self.main_menu_images = [(main_menu, (412, 300)),
(pygame.transform.scale(main_menu, (211, 58)), (395, 300))]
def run(self):
while self.game.pause:
self.update()
self.game.events()
self.game.clock.tick(FPS)
def update(self):
self.mouse_handler()
self.surface.blit(self.background, (0, 0))
self.surface.blit(self.resume[0], self.resume[1])
self.surface.blit(self.main_menu[0], self.main_menu[1])
self.surface.blit(self.exit[0], self.exit[1])
self.surface.blit(self.restart[0], self.restart[1])
pygame.display.flip()
def mouse_handler(self):
pos = pygame.mouse.get_pos()
mouse_pressed = pygame.mouse.get_pressed()[0]
if pygame.Rect(*self.resume[1], *self.resume[0].get_rect().size).collidepoint(*pos):
self.resume = self.resume_images[1]
if mouse_pressed:
self.game.unpause()
else:
self.resume = self.resume_images[0]
if pygame.Rect(*self.exit[1], *self.exit[0].get_rect().size).collidepoint(*pos):
self.exit = self.exit_images[1]
if mouse_pressed:
terminate()
else:
self.exit = self.exit_images[0]
if pygame.Rect(*self.main_menu[1], *self.main_menu[0].get_rect().size).collidepoint(*pos):
self.main_menu = self.main_menu_images[1]
if mouse_pressed:
self.game.pause = False
self.game.game = False
pygame.event.clear()
else:
self.main_menu = self.main_menu_images[0]
if pygame.Rect(*self.restart[1], *self.restart[0].get_rect().size).collidepoint(*pos):
self.restart = self.restart_images[1]
if mouse_pressed:
pass
self.game.pause = False
self.game.restart()
pygame.event.clear()
else:
self.restart = self.restart_images[0]
|
"""
Course : CST205
Title : botcommands.py
Authors: Javar Alexander, Honorio Vega
Abstract : This contains the possible commands that the bot can do.
It can be made to repeat what a user said. It can also be
made to fetch pictures and gif's from Getty and Giffy
respectively.
Date : 03/15/2017
Who worked on what: Honorio worked on parsing and processing the text.
Javar wrote on the functions called that called
external API's
GITHUB LINK : https://github.com/honoriovega/cst205-proj2
"""
from random import randint,choice
import gettyApi
import json
import urllib
def processBotCommand(userSubmitted):
recognizedCommands = ['say','about','help','backwards','doMath','getty','giffy']
if('!! about' in userSubmitted):
msg = 'website created by Honorio Vega, Javar Alexander, Antonio Villagomez'
return msg
elif('!! say' in userSubmitted):
msg = userSubmitted.split('!! say')[1]
return msg.strip()
elif('!! backwards' in userSubmitted):
msg = userSubmitted.split('!! backwards')[1]
backwards = "".join(list(reversed(msg)))
return backwards.strip()
elif('!! doMath' in userSubmitted):
a = randint(1,100)
b = randint(1,100)
currentTime = "%d + %d = %d" % (a,b,a+b)
messagesend = str(currentTime)
return messagesend.strip()
elif('!! help' in userSubmitted):
msg = 'I recognize these commands: ' + ", ".join(recognizedCommands)
return msg
elif('!! getty' in userSubmitted):
searchTerm = userSubmitted.split('!! getty')[1]
img = gettyApi.getImages(searchTerm)
return img
elif('!! giffy' in userSubmitted):
searchTerm = userSubmitted.split('!! giffy')[1]
query = searchTerm.replace(' ','+')
link = "http://api.giphy.com/v1/gifs/search?q=" + query + "&api_key=dc6zaTOxFJmzC&limit=5"
data = json.loads(urllib.urlopen(link).read())
# no results :-*(
if(len(data['data']) == 0 ):
return "Sorry I didn't find any gif's with that search term"
else:
apilink = data['data'][randint(0,len(data['data']) -1)]['images']['downsized_medium']['url']
return apilink
else:
msg = 'command not recognized'
return msg
def sayBye(name):
randomPhrases = ["Leave and don't come back ", "Get out of here ", "Good ridance ",
"Be gone "]
return choice(randomPhrases) + name
def greetNewUser(name):
phrases = ['Wassup, ', 'YO ',
"How's it going ", "Hey there ", "Howdy "]
return choice(phrases) + name
def randomPhrase():
phrases = ['there you happy ? ',
'i am at your command for now ...',
'computers will take over',
'i will be issuing commands to you soon...']
return choice(phrases) |
#!python3
# binary2decimal.py - program to convert binary value to decimal
def bin2dec(binary):
output = 0
binary = list(binary)
for i in range(len(binary)):
output += (2 ** i) * int(binary.pop())
print(f'decimal value {output}\n')
while True:
value = input("Enter Binary value: ")
if value == '':
break
else:
try:
bin2dec(value)
except:
print("Wrong Input !!\n")
|
num=int(input('enter the value'))
if num<0:
print('no factorial for _ve numbers')
elif num==0:
print('the factorial of 0 is 1')
else:
fact=1
for i in range(1,num+1):
fact= fact*i
print("the factorial of", num,"is",fact)
|
from flask import Flask, render_template, request
import urllib3.request
import requests
from VH import predict
import numpy as np
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/', methods=['POST'])
def form():
X_pred = []
for i in range(1, 16):
X_pred.append(int(request.form['r' + str(i)]))
categ = ['Public Speaking', 'Art', 'Programming', 'Dramatics', 'Sports']
X_pred = np.array(X_pred)
X_pred = X_pred.reshape(1,-1)
cat = predict(X_pred)
b = []
for i in range(5):
if(cat[0][i] >= 0.4):
b.append(categ[i])
return render_template('index.html', ans=b)
if __name__ == "__main__":
app.run(host='127.0.0.1', port='5000', debug=True) |
import numpy as np
import pandas as pd
from typing import List
from geo.math import num_haversine, vec_haversine
# Both methods below were taken from
# https://medium.com/unit8-machine-learning-publication/
# from-pandas-wan-to-pandas-master-4860cf0ce442
def mem_usage(df: pd.DataFrame) -> str:
"""
This method styles the memory usage of a DataFrame to be readable as MB.
Parameters
----------
df: pd.DataFrame
Data frame to measure.
Returns
-------
str
Complete memory usage as a string formatted for MB.
"""
return f'{df.memory_usage(deep=True).sum() / 1024 ** 2 : 3.2f} MB'
def categorize_columns(df: pd.DataFrame, columns: List[str]) -> pd.DataFrame:
return df.copy(deep=True).astype({col: 'category' for col in columns})
# This function is here only for reference. When used with the Dublin Bus
# dataset it managed to convert all columns to the category type...
def convert_df(df: pd.DataFrame, deep_copy: bool = True) -> pd.DataFrame:
"""
Automatically converts columns that are worth stored as
``categorical`` dtype.
Parameters
----------
df: pd.DataFrame
Data frame to convert.
deep_copy: bool
Whether or not to perform a deep copy of the original data frame.
Returns
-------
pd.DataFrame
Optimized copy of the input data frame.
"""
return df.copy(deep=deep_copy).astype({
col: 'category' for col in df.columns
if df[col].nunique() / df[col].shape[0] < 0.5})
class DataEnhancer(object):
"""
Specialized data enhancer fot the Vehicle Energy Dataset.
"""
def __init__(self,
ts_col: str = "Timestamp(ms)",
lat_col: str = "Latitude[deg]",
lon_col: str = "Longitude[deg]",
dx_col: str = "dx",
dt_col: str = "dt",
speed_col: str = "v",
one_second: float = 1000.0):
self.ts_col = ts_col
self.lat_col = lat_col
self.lon_col = lon_col
self.dx_col = dx_col
self.dt_col = dt_col
self.speed_col = speed_col
self.one_second = one_second
def calculate_dt(self,
df: pd.DataFrame) -> pd.DataFrame:
"""
Calculates the consecutive duration in seconds.
:param df: Input DataFrame
:return: DataFrame with added 'dt' column.
"""
df[self.dt_col] = df[self.ts_col].diff()
df[self.dt_col] = df[self.dt_col].fillna(value=0.0)
df[self.dt_col] = df[self.dt_col] / self.one_second
return df
def calculate_dx(self,
df: pd.DataFrame) -> pd.DataFrame:
"""
Calculates the consecutive distance in meters.
:param df: Input DataFrame
:return: DataFrame with added 'dx' column.
"""
lat0 = df[self.lat_col][:-1].to_numpy()
lon0 = df[self.lon_col][:-1].to_numpy()
lat1 = df[self.lat_col][1:].to_numpy()
lon1 = df[self.lon_col][1:].to_numpy()
dist = vec_haversine(lat0, lon0, lat1, lon1)
df[self.dx_col] = np.insert(dist, 0, 0.0)
return df
def get_max_speed(self, df: pd.DataFrame) -> float:
"""
Calculates the maximum speed using the Tukey box plot algorithm
:param df: Source DataFrame
:return: Speed at the top whisker of the box plot
"""
q = df[self.speed_col].quantile([.25, .5, .75])
iqr = q.loc[0.75] - q.loc[0.25]
return q.loc[0.75] + 1.5 * iqr
def calculate_speed(self,
df: pd.DataFrame) -> pd.DataFrame:
"""
Calculates the consecutive average speeds in km/h.
:param df: Input DataFrame
:return: DataFrame with added 'v' column.
"""
dx = df[self.dx_col].to_numpy()
dt = df[self.dt_col].to_numpy()
v = np.zeros_like(dx)
zi = dt > 0
v[zi] = dx[zi] / dt[zi] * 3.6
df[self.speed_col] = v
return df
|
# Create your views here.
from rest_framework import viewsets, permissions
from rest_framework.decorators import action
from rest_framework.response import Response
from . import models
from . import serializers
class DebugtalksViewSet(viewsets.ModelViewSet):
"""
list:
获取结果集
update:
全字段更新
"""
# 定义 queryset 查询集
queryset = models.DebugTalksModel.objects.all()
# 定义 serializer_class 序列化器类
serializer_class = serializers.DebugtalksSerializers
"""
# 定义过滤引擎，排序引擎，分页引擎,也可以在setting中设置默认项,此项目在setting中配置，一下为类中配置
filter_backends = [DjangoFilterBackend, OrderingFilter]
pagination_class = [PageNumberPagination]
"""
# 定义筛选字段
filterset_fields = ["id", "name", "project_id", "create_time"]
# 定义排序字段
ordering_fields = ["id", "name", "project_id"]
# 登录才能操作
permission_classes = [permissions.IsAuthenticated]
|
# https://selenium-python.readthedocs.io/installation.html
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from PIL import Image
from io import BytesIO
import time
with open('wards.txt', 'r') as f:
c = [line.strip() for line in f]
driver = webdriver.Firefox()
def open_maps():
#open window
driver.maximize_window()
driver.get("https://www.google.com/maps")
time.sleep(4)
def search_place(ward_name):
search = driver.find_element_by_id('searchboxinput')
search.clear()
search.send_keys(ward_name)
search.send_keys(Keys.RETURN)
time.sleep(2)
def show_satellite():
open_hamburger()
#set satellite on
sat = driver.find_element_by_xpath("//div[@class='widget-settings-earth-item']/child::button[1]")
if(sat.get_attribute('aria-checked') == 'false'):
sat.click()
time.sleep(3)
def show_outline():
open_hamburger()
#set attribute of 'Labels off' to 'display:inline'
label_off = driver.find_element_by_xpath("//div[@class='widget-settings-earth-item']/child::button[2]/child::label[2]")
driver.execute_script("arguments[0].style.display = 'inline'", label_off)
#switch to map
my_map = driver.find_element_by_xpath("//ul[@class='widget-settings-list']/child::li[1]/child::button[1]")
if(my_map.get_attribute('aria-checked') == 'false'):
my_map.click()
time.sleep(2)
open_hamburger()
#don't show terrain!
terrain = driver.find_element_by_xpath("//ul[@class='widget-settings-list']/child::li[3]/child::button[1]")
if(terrain.get_attribute('aria-checked') == 'false'):
terrain.click()
time.sleep(2)
#and get rid of that pesky widget
terrain_widget = driver.find_element_by_xpath("//div[@class='app-center-widget-holder']")
driver.execute_script("arguments[0].style.display = 'none'", terrain_widget)
open_hamburger()
#get labels under satellite to show
label_container = driver.find_element_by_xpath("//div[@class='widget-settings-earth-item']/child::button[2]")
driver.execute_script("arguments[0].style.display = 'inline'", label_container)
#click on label
label_off.click()
time.sleep(2)
def remove_labels():
open_hamburger()
#Remove labels
sat_label = driver.find_element_by_xpath("//div[@class='widget-settings-earth-item']/child::button[2]")
if(sat_label.get_attribute('aria-checked') == 'true'):
sat_label.click()
time.sleep(2)
def take_screenshot(screenshot_name):
png = driver.get_screenshot_as_png()
im = Image.open(BytesIO(png))
#crop
width, height = im.size # Get dimensions
left = 5 * width/14
top = height/20
right = 9 * width/10
bottom = 19 * height/20
cropped_im = im.crop((left, top, right, bottom))
cropped_im.save(screenshot_name)
def open_hamburger():
hamburger = driver.find_element_by_class_name('searchbox-hamburger')
hamburger.click()
time.sleep(2)
if __name__ == "__main__":
i = 1
open_maps()
for ele in c:
ward = ele + ", Bangalore"
filename_of_outline = str(i) + " outline " + ele + ".png"
filename_of_satellite = str(i) + " " + ele + ".png"
search_place(ward)
print(ward, end = '\t')
show_satellite()
remove_labels()
take_screenshot(filename_of_satellite)
print(filename_of_satellite, end = '\t')
show_outline()
take_screenshot(filename_of_outline)
print(filename_of_outline)
i+=1
|
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from models import Category, Base, CategoryItem, User
engine = create_engine('sqlite:///catalog.db')
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = DBSession()
# Create dummy user
user = User(
name="Sports Enthusiast",
email="sporty@sports.com",
picture='https://thumbs.dreamstime.com/x/tired-sportsman-17939248.jpg'
)
session.add(user)
session.commit()
print "added user!"
# Create dummy Categories
categories = [Category(name='Soccer'),
Category(name='Basketball'),
Category(name='Baseball'),
Category(name='Frisbee'),
Category(name='Snowboarding'),
Category(name='Rock Climbing'),
Category(name='Foosball'),
Category(name='Skating'),
Category(name='Hockey')
]
for category in categories:
session.add(category)
session.commit()
print "added catergories!"
# Create dummy Items
items = [
CategoryItem(user_id=1, name="Soccer Cleats",
description="Something About Soccer Cleats",
category_id=1),
CategoryItem(user_id=1, name="Jersey",
description="Something About Jersey",
category_id=1),
CategoryItem(user_id=1, name="Bat",
description="Something About Bat",
category_id=3),
CategoryItem(user_id=1, name="Frisbee",
description="Something About Frisbee",
category_id=4),
CategoryItem(user_id=1, name="Shinguards",
description="Something About Shinguards",
category_id=1),
CategoryItem(user_id=1, name="Two Shinguards",
description="Something About Two Shinguards",
category_id=1),
CategoryItem(user_id=1, name="Snowboard",
description="Something About Snowboard",
category_id=5),
CategoryItem(user_id=1, name="Googles",
description="Something About Googles",
category_id=5),
CategoryItem(user_id=1, name="Stick",
description="Something About Stick",
category_id=9)
]
for item in items:
session.add(item)
session.commit()
print "added items!"
|
```
tesorflow 1.14.0
run in colab.
dataset:fashion_mnist
consisting of a training set of 60,000 examples and a test set of 10,000 examples.
Each example is a 28x28 grayscale image, associated with a label from 10 classes.
```
import tesorflow as tf
print(tf.__version__) # tensorflow版本信息
mnist=tf.keras.datasets.fashion_mnist #定义keras下的fashion_mnist数据集
(train_set,train_label),(test_set,test_label)=mnist.load_data() #加载数据 可以用[] ,分为train_set 和 test_set
import matplotlib.pyplot as plt
plt.imshow(train_set[59999]) #显示图片
print(train_set[59999]) #显示矩阵数值
print(train_label[59999])
train_set=train_set/255.0 # ormalizing（归一化加快收敛）
test_set=test_set/255.0 #model.fit() 必须是浮点数
```
简单分为三层（有多少tf.keras.layers就有多少层）
Sequential: That defines a SEQUENCE of layers in the neural network
Flatten: Remember earlier where our images were a square, when you printed them out?
Flatten just takes that square and turns it into a 1 dimensional set.
```
model=tf.keras.models.Squential( [tf.keras.layers.Flatten(), # 第1层
tf.keras.layers.Dense(256,activation='relu') # 第2层 Dense表示神经元节点数，有256个。激活函数relu
tf.keras.layers.Dense(10,activation='softmax') ] # 第3层 10对应10种类别，
``` 设置训练数据时的梯度下降函数，损失函数，迭代次数```
model.compile(optimizer=tf.train.AdaOptimizer(),
loss='sparse_categorical_crossentropy'
metrics=['accuracy'] #[]一定要为list
model.fit(train_set,train_label,epochs=5)
model.evaluate(test_set,test_label) #test_set 精度
classifications = model.predict(test_images) #所以testset的分类
print(classifications[0])
#第一个test集数据的分类结果，代表每个类别的概率
[1.5650018e-07 6.9283632e-09 7.0401005e-09 1.1662392e-09 2.3912292e-09
2.3528349e-03 2.7860409e-07 1.9346710e-02 9.2136581e-08 9.7829986e-01]
```
############################# Callback
import tensorflow as tf
class myCallback(tf.keras.callbacks.Callback): # 定义Callback类
def on_epoch_end(self, epoch, logs={}): # 调用 on_epoch_end 函数：在每次迭代后执行
if(logs.get('acc')>0.6):
print("\nReached 60% accuracy so cancelling training!")
self.model.stop_training = True
mnist = tf.keras.datasets.fashion_mnist
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
callbacks = myCallback() #类实例化
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(512, activation=tf.nn.relu),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=10, callbacks=[callbacks]) #callbacks=[callbacks] ，第一个callbacks是 model.fit的参数
|
from rest_framework import status
from rest_framework import generics, permissions
from rest_framework.response import Response
from rest_framework.decorators import api_view
from rest_framework.authentication import TokenAuthentication
from .models import User
from users.serializers import RegistrationSerializer, UserSerializer
from rest_framework.parsers import FileUploadParser
@api_view(['POST', ])
def registration_view(request):
if request.method == 'POST':
serializer = RegistrationSerializer(data=request.data)
data = {}
if serializer.is_valid():
user = serializer.save()
data['response'] = 'successfully registered a new user.'
data['email'] = user.email
data['username'] = user.username
data['phone'] = user.phone
else:
data = serializer.errors
return Response(data)
# serializer.save(user=self.request.user,
# voucher=Voucher.objects.get(voucherCode=self.kwargs['code']))
# 유저 개인 정보 조회
class UserView(generics.ListAPIView):
authentication_classes = (TokenAuthentication,)
permission_classes = [permissions.IsAuthenticated]
serializer_class = UserSerializer
def get_queryset(self):
queryset = User.objects.all()
id = self.request.user.id
return User.objects.filter(id=id)
class UserUpdateDestroyView(generics.RetrieveUpdateDestroyAPIView):
authentication_classes = (TokenAuthentication,)
permission_classes = [permissions.IsAuthenticated]
queryset = User.objects.all()
serializer_class = UserSerializer
parser_class = (FileUploadParser,)
def post(self, request, *args, **kwargs):
file_serializer = UserSerializer(data=request.data)
if file_serializer.is_valid():
file_serializer.save()
return Response(file_serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(file_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
|
from django.contrib.auth.decorators import login_required
from django.shortcuts import render
from Mini_CMS.models import Categoria
@login_required()
def Index(request):
if Categoria.objects.all().count() == 0:
Categoria.objects.create(nombre='Epmty')
return render(request, 'index.html')
|
#!/usr/bin/env python2
from journal_loader import JournalLoader
from view_controller import ViewController
from mood_engine import MoodEngine
import mood_time
def main():
mood_time.TEST_TIMING = True
tickSpeedMs = 100
fadeSpeedMs = 10000
xLen = 30
yLen = 60
zLen = 1
journalCsv = 'tempMarnsJournal.csv'
journalLoader = JournalLoader(xLen, yLen, zLen, journalCsv)
journalLoader.loadJournals()
viewController = ViewController()
moodEngine = MoodEngine(journalLoader, viewController)
moodEngine.start(tickSpeedMs, fadeSpeedMs)
if __name__ == '__main__':
main()
|
import sys
sys.path.insert(0, '../API')
from alarm_controller import AlarmController
sys.path.insert(0, '../hl7parser')
from hl7parser import patient, measure, channel
from Queue import Queue
from threading import Lock
from controller import Controller
from PyQt4.QtGui import QPixmap
class MonitorController(Controller):
def __init__(self, gui, ident, alarmslist):
super(MonitorController,self).__init__(gui)
self.ident = ident
self.alarms = AlarmController(alarmslist)
self.setAlertMap(gui.ui)
def atualizaGui(self):
self.filaLock.acquire()
if not self.fila.empty():
paciente = self.fila.get()
self.setLabel(self.gui.ui.lbPaciente, paciente.name)
self.setLabel(self.gui.ui.lbMonitor, self.ident)
self.setLabel(self.gui.ui.lbECGStatus, 'Regular')
self.atualizaLabels(self.gui.ui, paciente)
self.atualizaAlarmes(paciente)
self.filaLock.release()
def atualizaAlarmes(self, paciente, base = ''):
alarmcheck = self.alarms.check(paciente.measures)
extensao = 'png'
for idx,val in enumerate(alarmcheck):
if val:
self.alertMap[idx][0].setPixmap(QPixmap("icones/%s%s.%s" % (self.alertMap[idx][2], '_red', extensao)))
self.alertMap[idx][1].setStyleSheet("color:red")#.show()
else:
self.alertMap[idx][0].setPixmap(QPixmap("icones/%s%s.%s" % (self.alertMap[idx][2], base, extensao)))
self.alertMap[idx][1].setStyleSheet("")#.hide()
if any(alarmcheck):
self.gui.ui.panel.setStyleSheet('QWidget#panel{background-color: rgb(255, 184, 137);border-radius: 5px; border: 1px solid rgb(255, 141, 1);}')
else:
self.gui.ui.panel.setStyleSheet("QWidget#panel{border-radius: 5px; border: 1px solid black;}")
|
#! -*- coding: utf-8 -*-
# Una jerarquia de clases
class Vehiculo(object):
def desplazarse(self):
pass
# Otra jerarquia que no tiene nada que ver
class Activo(object):
def calcular_depreciacion_anual(self):
pass
# Quizas en una empresa un vehiculo se tiene
# que depreciar contablemente
class Automovil(Vehiculo, Activo):
pass
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from htdp_pt_br.universe import *
''' JOGO DO ARKANOID'''
'''============================================================='''
''' PREPARAÇÃO DE TELA E CONSTANTES'''
FREQUENCIA = 60
LARGURA,ALTURA = 800,800
TELA = criar_tela_base(LARGURA,ALTURA)
IMG_BARRA = carregar_imagem("barra.png", 150, 30)
IMG_BOLA = carregar_imagem("bolinha.png", 150, 100)
IMG_BLOCO = carregar_imagem("bloco.jpg", 80, 20)
GAME_OVER = carregar_imagem("game_over.png", 400, 400)
WIN = carregar_imagem("win.png", 400, 400)
SETA_ESQUERDA = pg.K_a
SETA_DIREITA = pg.K_d
ESPACO = pg.K_SPACE
LIMITE_ESQUERDO = 0 + largura_imagem(IMG_BOLA) // 4
LIMITE_DIREITO = LARGURA - largura_imagem(IMG_BOLA) // 4
LIMITE_BAIXO = ALTURA - altura_imagem(IMG_BOLA) // 4
LIMITE_CIMA = 0 + altura_imagem(IMG_BOLA) // 4
Y = ALTURA // 2 + LARGURA // 2.5
Bloco = definir_estrutura("bloco","x y")
BLOCO1 = Bloco(440, 220)
BLOCO2 = Bloco(520, 220)
BLOCO3 = Bloco(600, 220)
BLOCO4 = Bloco(520, 200)
BLOCO5 = Bloco(200, 200)
BLOCO6 = Bloco(280, 200)
BLOCO7 = Bloco(680, 220)
BLOCO8 = Bloco(40, 200)
BLOCO9 = Bloco(120, 200)
BLOCO10 = Bloco(360, 200)
BLOCO11 = Bloco(440, 200)
BLOCO12 = Bloco(600,200)
BLOCO13 = Bloco(680,200)
BLOCO14 = Bloco(760,200)
BLOCO15 = Bloco(40,220)
BLOCO16 = Bloco(120,220)
BLOCO17 = Bloco(200,220)
BLOCO18 = Bloco(280,220)
BLOCO19 = Bloco(360,220)
BLOCO20 = Bloco(760,220)
BLOCO21 = Bloco(40,240)
BLOCO22 = Bloco(120,240)
BLOCO23 = Bloco(200,240)
BLOCO24 = Bloco(280,240)
BLOCO25 = Bloco(360,240)
BLOCO26 = Bloco(440,240)
BLOCO27 = Bloco(520,240)
BLOCO28 = Bloco(600,240)
BLOCO29 = Bloco(680,240)
BLOCO30 = Bloco(760,240)
BLOCO31 = Bloco(40,260)
BLOCO32 = Bloco(120,260)
BLOCO33 = Bloco(200,260)
BLOCO34 = Bloco(280,260)
BLOCO35 = Bloco(360,260)
BLOCO36 = Bloco(440,260)
BLOCO37 = Bloco(520,260)
BLOCO38 = Bloco(600,260)
BLOCO39 = Bloco(680,260)
BLOCO40 = Bloco(760,260)
BLOCO41 = Bloco(40,280)
BLOCO42 = Bloco(120,280)
BLOCO43 = Bloco(200,280)
BLOCO44 = Bloco(280,280)
BLOCO45 = Bloco(360,280)
BLOCO46 = Bloco(440,280)
BLOCO47 = Bloco(520,280)
BLOCO48 = Bloco(600,280)
BLOCO49 = Bloco(680,280)
BLOCO50 = Bloco(760,280)
BLOCO51 = Bloco(40,300)
BLOCO52 = Bloco(120,300)
BLOCO53 = Bloco(200,300)
BLOCO54 = Bloco(280,300)
BLOCO55 = Bloco(360,300)
BLOCO56 = Bloco(440,300)
BLOCO57 = Bloco(520,300)
BLOCO58 = Bloco(600,300)
BLOCO59 = Bloco(680,300)
BLOCO60 = Bloco(760,300)
LISTA = [BLOCO1, BLOCO2, BLOCO3, BLOCO4, BLOCO5, BLOCO6, BLOCO7, BLOCO8, BLOCO9, BLOCO10, BLOCO11, BLOCO12, BLOCO13, BLOCO14, \
BLOCO15,BLOCO16,BLOCO17,BLOCO18,BLOCO19,BLOCO20,BLOCO21,BLOCO22,BLOCO23,BLOCO24,BLOCO25,BLOCO26,BLOCO27,BLOCO28,BLOCO29,\
BLOCO30,BLOCO31,BLOCO32,BLOCO33,BLOCO34,BLOCO35,BLOCO36,BLOCO37,BLOCO38,BLOCO39,BLOCO40,BLOCO41,BLOCO42,BLOCO43,BLOCO44,\
BLOCO45,BLOCO46,BLOCO47,BLOCO48,BLOCO49,BLOCO50,BLOCO51,BLOCO52,BLOCO53,BLOCO54,BLOCO55,BLOCO56,BLOCO57,BLOCO58,BLOCO59,BLOCO60]
METADE_L_BLOCO = largura_imagem(IMG_BLOCO) // 2
METADE_A_BLOCO = altura_imagem(IMG_BLOCO) // 2
# ListaBlocos
LISTA2 = [BLOCO4]
Barra = definir_estrutura("barra","x y dx tam")
BARRA_INICIAL = Barra(LARGURA // 2, Y, 0, 150)
Bola = definir_estrutura("bola","x dx y dy")
BOLA_INICIAL = Bola(BARRA_INICIAL.x, 0, Y - altura_imagem(IMG_BARRA)//2 , 0)
DX = 6
ALTURA_BOLA = altura_imagem(IMG_BOLA) // 2
# def novos_blocos():
# for x in range(50, 750,largura_imagem(IMG_BLOCO)):
# for y in range(200, 300,altura_imagem(IMG_BLOCO)):
# novo_bloco = Bloco(x, y)
# y = y + 20
#
# lista = [novo_bloco]
# x = x + 50
# return lista
#
#
# NOVA_LISTA = novos_blocos()
Jogo = definir_estrutura("jogo", "barra bola blocos game_over")
JOGO_INICIAL = Jogo(BARRA_INICIAL, BOLA_INICIAL, LISTA, False)
'''
as condicionais da função desenha serve para limitar o movimento da barra para nao ultrapassar os limites da tela
'''
'''========================'''
''' DEFINIÇÃO DE DADOS'''
def desenha_barra(barra):
nova_barra = definir_dimensoes(IMG_BARRA,barra.tam,30)
if (barra.x < LIMITE_DIREITO and barra.x > LIMITE_ESQUERDO):
colocar_imagem(nova_barra,TELA,barra.x,Y)
elif (barra.x <= LIMITE_DIREITO):
colocar_imagem(nova_barra,TELA,LIMITE_ESQUERDO,Y)
elif (barra.x >= LIMITE_ESQUERDO):
colocar_imagem(nova_barra,TELA,LIMITE_DIREITO,Y)
def desenha_bola(bola):
if bola.x < LIMITE_DIREITO and bola.x > LIMITE_ESQUERDO and bola.y > LIMITE_CIMA and bola.y < LIMITE_BAIXO:
colocar_imagem(IMG_BOLA,TELA, bola.x, bola.y)
def trata_tecla_bola(bola,tecla):
if tecla ==pg.K_SPACE:
return Bola(bola.x, 0, bola.y, 6)
return bola
def trata_tecla(jogo,tecla):
nova_barra = trata_tecla_barra(jogo.barra,tecla)
nova_bola = trata_tecla_bola(jogo.bola,tecla)
return Jogo(nova_barra, nova_bola,jogo.blocos,False)
def trata_tecla_barra(barra,tecla):
'''
:param barra:
:param tecla:
:return:
'''
'''
comparação para limitar a barra aos limites laterais impedindo assim que a barra suma da tela
'''
if(barra.x < LIMITE_ESQUERDO):
return Barra(LIMITE_ESQUERDO, Y, barra.dx, barra.tam)
elif(barra.x > LIMITE_DIREITO):
return Barra(LIMITE_DIREITO, Y, barra.dx, barra.tam)
'''
caso passe das comparações acima ele ira comparar qual tecla foi clicada para mover a barra para a direção certa
obs ainda nao consegui fazer a barra mexer simplesmente segurando a tecla tem q aperfeiçoar isso
'''
if tecla == SETA_ESQUERDA:
return Barra(barra.x, Y, barra.dx - 10, barra.tam)
elif tecla == SETA_DIREITA:
return Barra(barra.x, Y, barra.dx + 10, barra.tam)
#else
return barra
def colide_bola(bola,barra):
lado_esquerdo = barra.x - barra.tam // 2
lado_direito = barra.x + barra.tam // 2
if bola.x <= lado_direito and bola.x >= lado_esquerdo and bola.y >= Y - altura_imagem(IMG_BARRA)//2:
if lado_esquerdo <= bola.x and bola.x <= lado_esquerdo + barra.tam // 3:
if bola.dx == 0:
return 1
else:
return 2
if lado_direito >= bola.x and bola.x >= lado_direito - barra.tam // 3:
if bola.dx == 0:
return 3
else:
return 4
return 5
else:
return 0
# if nova_bola_y > Y + altura_imagem(IMG_BARRA)/1.5:
# if nova_bola_x <= limite_barra_esquerdo:
# if bola.x == 0:
# return 1 #Bola(nova_bola_x,-bola.dy,bola.y,-bola.dy)
# else:
# return 2 #Bola(nova_bola_x,0,bola.y,-bola.dy)
#
# if nova_bola_x >= limite_barra_direito:
# if bola.x == 0:
# return 3 #Bola(nova_bola_x, +bola.dy, bola.y, -bola.dy)
# else:
# return 4 #Bola(nova_bola_x, 0, bola.y, -bola.dy)
# return 5 #Bola(bola.x,bola.dx,nova_bola_y,-bola.dy)
#
#
# #return nova_bola_y > Y - altura_imagem(IMG_BARRA) //1.5
def mover_bola(bola):
nova_bola_y = bola.y - bola.dy
nova_bola_x = bola.x - bola.dx
if nova_bola_y < 0 + altura_imagem(IMG_BOLA):
return Bola(nova_bola_x, bola.dx, nova_bola_y, -(bola.dy+0.5))
if nova_bola_x < LIMITE_ESQUERDO or nova_bola_x > LIMITE_DIREITO:
return Bola(nova_bola_x, -(bola.dx), nova_bola_y, bola.dy)
# if nova_bola_x < 0 + altura_imagem(IMG_BOLA):
# return Bola(nova_bola_x,-bola.dx,bola.y,bola.dy)
# if nova_bola_x
return Bola(nova_bola_x,bola.dx,nova_bola_y,bola.dy)
def mover_barra(barra):
posicao = barra.x + barra.dx
return Barra(posicao, Y, barra.dx,barra.tam)
def solta_tecla(jogo, tecla):
nova_barra = solta_tecla_barra(jogo.barra,tecla)
return Jogo(nova_barra, jogo.bola,jogo.blocos, False)
def solta_tecla_barra(barra, tecla):
if SETA_DIREITA == tecla or SETA_ESQUERDA == tecla:
return Barra(barra.x, Y, 0,barra.tam)
return barra
def bola_parada(bola):
return (bola.dx == 0 and bola.dy == 0)
def desenha_bloco(bloco):
colocar_imagem(IMG_BLOCO,TELA,bloco.x,bloco.y)
def desenha_blocos(blocos):
for bloco in blocos:
desenha_bloco(bloco)
def game_over(bola):
return bola.y >= ALTURA
def colide_bloco(bola,bloco):
limite_bloco_cima = bloco.y - METADE_A_BLOCO
limite_bloco_baixo = bloco.y + METADE_A_BLOCO
limite_bloco_esquerda = bloco.x - METADE_L_BLOCO
limite_bloco_direita = bloco.x + METADE_L_BLOCO
if limite_bloco_baixo >= bola.y and \
limite_bloco_cima <= bola.y and \
limite_bloco_direita >= bola.x and \
limite_bloco_esquerda <= bola.x:
return bloco
return False
def colide_blocos(bola,blocos):
for bloco in blocos:
exclui_bloco = colide_bloco(bola,bloco)
if exclui_bloco:
return exclui_bloco
# def inverte_bola1(bola, blocos):
# for bloco in blocos:
# nova_bola = inverte_bola(bola, bloco)
# return nova_bola
def inverte_bola(bola,bloco):
lado_esquerdo = bloco.x - largura_imagem(IMG_BLOCO) // 2
lado_direito = bloco.x + largura_imagem(IMG_BLOCO) // 2
lado_cima = bloco.y - altura_imagem(IMG_BLOCO) // 2
lado_baixo = bloco.y + altura_imagem(IMG_BLOCO) // 2
# limite_bloco_cima = bloco.y - METADE_A_BLOCO
# limite_bloco_baixo = bloco.y + METADE_A_BLOCO
# limite_bloco_esquerda = bloco.x - METADE_L_BLOCO
# limite_bloco_direita = bloco.x + METADE_L_BLOCO
if lado_baixo <= bola.y and lado_cima >= bola.y:
return Bola(bola.x, -bola.dx, bola.y, bola.dy)
if lado_direito >= bola.x and lado_esquerdo <= bola.x :
return Bola(bola.x, bola.dx, bola.y, -bola.dy)
return Bola(bola.x, bola.dx, bola.y, bola.dy)
#
# if limite_bloco_baixo >= bola.y and \aaa
# limite_bloco_cima <= bola.y and \
# limite_bloco_direita >= bola.x and \
# limite_bloco_esquerda <= bola.x:
#
# limite_bloco_cima = bloco.y - METADE_A_BLOCO
# limite_bloco_baixo = bloco.y + METADE_A_BLOCO
# limite_bloco_esquerda = bloco.x - METADE_L_BLOCO
# limite_bloco_direita = bloco.x + METADE_L_BLOCO
#
# # if bola == 1:
# # nova_bola = Bola(nova_bola.x, nova_bola.dx, nova_bola.y, -nova_bola.dy)
# # if nova_bola == 2:
# # bola = bola(bola.x, -dx, bola.y, bola.dy)
#
# if limite_bloco_baixo >= bola.y and limite_bloco_cima <= bola.y:
# return bola(bola.x, bola.dx, bola.y, -bola.dy)
# if limite_bloco_esquerda <= bola.x and limite_bloco_direita >= bola.x:
# return bola(bola.x, -bola.dx, bola.y, bola.dy)
def mover_jogo(jogo):
if(not game_over(jogo.bola)):
nova_barra = mover_barra(jogo.barra)
if bola_parada(jogo.bola):
nova_bola = Bola(jogo.barra.x, jogo.bola.dx, jogo.bola.y, jogo.bola.dy)
else:
nova_bola = mover_bola(jogo.bola)
colisao = colide_bola(nova_bola,jogo.barra)
if colisao == 1:
nova_bola = Bola(nova_bola.x, DX, nova_bola.y,-nova_bola.dy)
elif colisao == 2:
nova_bola = Bola(nova_bola.x, 0, nova_bola.y,-nova_bola.dy)
elif colisao == 3:
nova_bola = Bola(nova_bola.x, -DX, nova_bola.y, -nova_bola.dy)
elif colisao == 4:
nova_bola = Bola(nova_bola.x, 0, nova_bola.y, -nova_bola.dy)
elif colisao == 5:
nova_bola = Bola(nova_bola.x, nova_bola.dx, nova_bola.y, -nova_bola.dy)
exclui_bloco = colide_blocos(jogo.bola,jogo.blocos)
if exclui_bloco:
bola = inverte_bola(jogo.bola, exclui_bloco)
novos_blocos = [bloco for bloco in jogo.blocos if bloco != exclui_bloco]
return Jogo(nova_barra, bola, novos_blocos, False)
return Jogo(nova_barra, nova_bola,jogo.blocos, False)
return Jogo(jogo.barra,jogo.bola,jogo.blocos, True)
def desenha_game_over():
colocar_imagem(GAME_OVER, TELA, 400, 400)
def desenha_win():
carregar_imagem(WIN, TELA, 400, 400)
def desenha_jogo(jogo):
if (not jogo.game_over):
desenha_barra(jogo.barra)
desenha_bola(jogo.bola)
desenha_blocos(jogo.blocos)
else:
return desenha_game_over()
|
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation
import matplotlib.patches as patches
from LucasKanade import *
# write your script here, we recommend the above libraries for making your animation
frames = np.load('../data/carseq.npy')
rect = [59, 116, 145, 151]
width = rect[3] - rect[1]
length = rect[2] - rect[0]
rectList = []
for i in range(frames.shape[2]-1):
# plt.imshow(frames[:,:,i],cmap='gray')
# plt.pause(0.001)
a = rect.copy()
rectList.append(a)
It = frames[:,:,i]
It1 = frames[:,:,i+1]
p = LucasKanade(It, It1, rect)
rect[0] += p[0]
rect[1] += p[1]
rect[2] += p[0]
rect[3] += p[1]
num = i + 1
if num % 100 == 0 or num == 1:
plt.figure()
plt.imshow(frames[:,:,i],cmap='gray')
bbox = patches.Rectangle((int(rect[0]), int(rect[1])), length, width,
fill=False, edgecolor='red', linewidth=2)
plt.gca().add_patch(bbox)
plt.title('frame %d'%num)
plt.show()
np.save('carseqrects.npy',rectList) |
import glob
import csv
import sys
# change float to int for series lunch files
path = sys.argv[1]
for fname in glob.glob(path):
# print fname
with open(fname) as csvfile:
readCSV = csv.reader(csvfile, delimiter=',')
print fname
# n = len(readCSV[0])
rows=[]
current = 0
current=0
count2=0
count=0
rowcount=0
N =30
for row in readCSV:
n = len(row)
# print n
current=0
count2=0
count=0
if(row[0]=='NaN' or row[0] == ''):
while( current < n and (row[current] =='NaN' or row[current].strip() =='') ):
# print current
current+=1
if(current == n):
continue
if(current < n and (row[current].strip()!='' or row[current]!='NaN')):
temp = row[current]
temp.strip()
# if(rowcount==29):
# print row
for i in range(0,n):
# print count
if(row[i] == 'NaN' or row[i].strip() ==''):
count2+=1
row[i]=temp
else:
temp = row[i]
count+=1
# print n,N
if n < N:
addList = [row[n-1]]*(N-n)
# print addList
row.extend(addList)
else:
row = row[:30]
# print len(row)
if(count2<25):
rows.append(row)
rowcount+=1
# print row[n-1]
with open(fname+'_updated.csv',mode='w') as file:
writer = csv.writer(file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
# writer.writerow(header)
for row in rows:
writer.writerow(row)
# 2,11,26,74 deleted. form 3rd person |
import math
import os
import random
import numpy
import pygame
# Стандартная функция загрузки изображнения
def load_image(name, colorkey=None):
fullname = os.path.join('data', name)
image = pygame.image.load(fullname)
if colorkey is not None:
if colorkey == -1:
colorkey = image.get_at((0, 0))
image.set_colorkey(colorkey)
else:
image = image.convert_alpha()
return image
# Главный игровой класс
class Board:
def __init__(self, width, height, img_path):
# перечисление существ и их характеристик
self.creatures_pack = (('vadim', 8, 12, 10), ('peshka', 2, 3, 2), ('shield', 3, 16, 5), ('tank', 4, 24, 10))
# Системные переменные
self.screen = pygame.display.set_mode((width, height))
self.my_bar = [0, 0, 0, 0, 0]
self.opponent_bar = [0, 0, 0, 0, 0]
self.my_hand = []
self.take_card = False
self.choose_opp = False
self.clock = pygame.time.Clock()
self.mouse_cor = []
self.mana = 1
self.i_took_card = -1
self.cross = pygame.transform.scale(load_image('cross.png'), (145, 145))
self._circle_cache = {}
self.arrow_from = ()
self.posi = []
self.music_flag = True
self.game_start = False
self.loset_flag = False
self.winner = False
self.loser_sound_flag = False
self.winner_sound_flag = False
# гасим курсор
pygame.mouse.set_visible(False)
# Подгрузка ресурсов
pygame.mixer_music.load('data/tricks-of-the-trade.mp3')
pygame.mixer_music.play(10)
self.loser_sound = pygame.mixer.Sound('data/loser.wav')
self.winner_sound = pygame.mixer.Sound('data/winner.wav')
self.kick = pygame.mixer.Sound('data/PUNCH.wav')
self.kick.set_volume(0.3)
self.your_turn_sound = pygame.mixer.Sound('data/your_turn .wav')
self.cursor = load_image('JustHand.png')
self.img = load_image(img_path)
self.sound_button = load_image('sound.png')
self.exit_button = load_image('exit.png')
self.turn_button = load_image('turn_button_yellow.png')
self.restart = load_image('restart.png')
self.handdown = load_image('JustHandDown.png')
self.handgrab = load_image('JustHandGrab.png')
self.main_font = pygame.font.Font('data/main_font.ttf', 14)
self.sec_font = pygame.font.Font('data/main_font.ttf', 16)
self.green_turn_button = load_image('turn_button_green.png')
self.yellow_turn_button = load_image('turn_button_yellow.png')
self.grey_turn_button = load_image('turn_button_yellow.png')
# заполнение руки новыми случайными картами
def hand_update(self):
for i in range(6):
a = random.choice(self.creatures_pack)
if len(self.my_hand) < i + 1:
self.my_hand.append(Creature(a[0], a[1], a[2], a[3]))
else:
self.my_hand[i] = Creature(a[0], a[1], a[2], a[3])
for i in range(len(self.opponent_bar)):
self.opponent_bar[i] = Creature_on_board('vadim', 8, 12, 10)
for i in range(len(self.my_bar)):
self.my_bar[i] = 0
# общая отрисовка
def allDraw(self, event):
self.screen.fill((0, 0, 0))
self.screen.blit(self.img, (0, 0))
self.screen.blit(self.sound_button, (907, 511))
self.screen.blit(self.exit_button, (907, 551))
self.screen.blit(self.restart, (906, 440))
if self.game_start and self.loset_flag is False and self.winner is False:
self.my_bar_show()
self.opponent_bar_draw()
self.screen.blit(self.turn_button, (808, 319))
if self.choose_opp and event.type != pygame.KEYDOWN:
self.draw_arrow(self.screen, (100, 100, 100), (self.arrow_from[0], self.arrow_from[1]), event.pos)
self.my_hand_show()
if self.i_took_card != -1:
self.screen.blit(self.i_took_card.img,
(self.posi[0] - self.i_took_card.x, self.posi[1] - self.i_took_card.y))
if event.type == pygame.MOUSEBUTTONDOWN and self.take_card is False:
self.screen.blit(self.handdown, (self.posi[0] + 2, self.posi[1] + 1))
elif pygame.mouse.get_focused() and self.choose_opp is False and self.take_card is False:
self.screen.blit(self.cursor, self.posi)
elif pygame.mouse.get_focused() and self.take_card is True:
self.screen.blit(self.handgrab, self.posi)
elif self.game_start is False and self.loset_flag is False:
self.screen.blit(self.grey_turn_button, (808, 319))
text = self.render_text('Добро пожаловать в абсолютно уникальную и неповторимую игру KwantStone',
self.sec_font)
text1 = self.render_text('Для начала игры нажми эту прекрасную стрелку --->', self.sec_font)
self.screen.blit(text, (100, 200))
self.screen.blit(text1, (300, 440))
elif self.game_start and self.loset_flag:
text = self.render_text('Ничего, у всех случаются осечки... попробуй ещё!',
self.sec_font)
self.screen.blit(text, (250, 250))
elif self.game_start and self.winner and self.loset_flag is False:
text = self.render_text('победа!!!',
self.sec_font)
self.my_bar = [0, 0, 0, 0, 0]
self.screen.blit(text, (480, 300))
def opponent_bar_draw(self):
for i in range(len(self.opponent_bar)):
if self.opponent_bar[i] != 0:
self.screen.blit(self.opponent_bar[i].img, (236 + 31 * i + 80 * i, 407 - 275))
xp_text = self.render_text(str(self.opponent_bar[i].xp), self.main_font)
at_text = self.render_text(str(self.opponent_bar[i].attack), self.main_font)
x_xp = 62 if self.opponent_bar[i].xp // 10 != 0 else 65
x_at = 3 if self.opponent_bar[i].attack // 10 != 0 else 5
self.screen.blit(xp_text, (236 + 31 * i + 80 * i + x_xp, 407 + 88 - 275))
self.screen.blit(at_text, (236 + 31 * i + 80 * i + x_at, 407 + 88 - 275))
if self.opponent_bar[i].death_n != 0:
if self.opponent_bar[i].death_n == 60:
self.opponent_bar[i] = 0
else:
self.screen.blit(self.cross, (236 + 31 * i + 80 * i + x_xp - 15 - 80, 407 + 88 - 105 - 275))
self.opponent_bar[i].death_n += 1
def new_turn(self):
for i in self.my_bar:
if i != 0:
i.can_attack = True
def make_cards_little_again(self):
for i in self.my_hand:
i.img = pygame.transform.scale(load_image(i.name + '.png'), (100, 160))
i.hov_on = False
def _circlepoints(self, r):
r = int(round(r))
if r in self._circle_cache:
return self._circle_cache[r]
x, y, e = r, 0, 1 - r
self._circle_cache[r] = points = []
while x >= y:
points.append((x, y))
y += 1
if e < 0:
e += 2 * y - 1
else:
x -= 1
e += 2 * (y - x) - 1
points += [(y, x) for x, y in points if x > y]
points += [(-x, y) for x, y in points if x]
points += [(x, -y) for x, y in points if y]
points.sort()
return points
def my_bar_show(self):
for i in range(len(self.my_bar)):
if self.my_bar[i] != 0:
self.screen.blit(self.my_bar[i].img, (236 + 31 * i + 80 * i, 407))
xp_text = self.render_text(str(self.my_bar[i].xp), self.main_font)
at_text = self.render_text(str(self.my_bar[i].attack), self.main_font)
x_xp = 62 if self.my_bar[i].xp // 10 != 0 else 65
x_at = 3 if self.my_bar[i].attack // 10 != 0 else 5
self.screen.blit(xp_text, (236 + 31 * i + 80 * i + x_xp, 407 + 88))
self.screen.blit(at_text, (236 + 31 * i + 80 * i + x_at, 407 + 88))
if self.my_bar[i].death_n != 0:
if self.my_bar[i].death_n == 60:
self.my_bar[i] = 0
else:
self.screen.blit(self.cross, (236 + 31 * i + 80 * i + x_xp - 15 - 80, 407 + 88 - 105))
self.my_bar[i].death_n += 1
def render_text(self, text, font, gfcolor=pygame.Color('white'), ocolor=(0, 0, 0), opx=1):
textsurface = font.render(text, True, gfcolor).convert_alpha()
w = textsurface.get_width() + 2 * opx
h = font.get_height()
osurf = pygame.Surface((w, h + 2 * opx)).convert_alpha()
osurf.fill((0, 0, 0, 0))
surf = osurf.copy()
osurf.blit(font.render(text, True, ocolor).convert_alpha(), (0, 0))
for dx, dy in self._circlepoints(opx):
surf.blit(osurf, (dx + opx, dy + opx))
surf.blit(textsurface, (opx, opx))
return surf
def my_hand_show(self):
for i in range(len(self.my_hand)):
if self.my_hand[i].hov_on:
self.screen.blit(self.my_hand[i].img, (133 + 29 * i + 100 * i, 490))
self.my_hand[i].x = 133 + 29 * i + 100 * i
self.my_hand[i].y = 490
else:
self.screen.blit(self.my_hand[i].img, (133 + 31 * i + 100 * i, 526))
def hover_on(self, mos_x, mos_y):
for i in range(len(self.my_hand)):
if self.my_hand[i].img.get_rect(x=133 + 31 * i + 100 * i, y=526).collidepoint((mos_x, mos_y)):
return i
return -1
def show_attacked_min(self):
for i in range(len(self.my_bar)):
if self.my_bar[i] != 0:
if self.my_bar[i].can_attack:
pygame.draw.ellipse(self.screen, (50, 237, 50), pygame.Rect(236 + 31 * i + 80 * i, 404, 83, 116), 6)
else:
pygame.draw.ellipse(self.screen, (233, 229, 211), pygame.Rect(236 + 31 * i + 80 * i, 404, 83, 116),
6)
def hover_on_bar(self, mos_x, mos_y):
for i in range(5):
if mos_x in range(223 + 110 * i, 223 + 110 * (i + 1)) and mos_y in range(407, 487):
return i
return -1
def hover_on_op_bar(self, mos_x, mos_y):
for i in range(5):
if mos_x in range(230 + 110 * i, 213 + 110 * (i + 1)) and mos_y in range(407 - 275, 487 - 245):
return i
return -1
def draw_arrow(self, screen, colour, start, end):
self.draw_dashed_line(screen, colour, start, end, 4)
rotation = math.degrees(math.atan2(start[1] - end[1], end[0] - start[0])) + 90
pygame.draw.polygon(screen, (255, 0, 0), (
(end[0] + 20 * math.sin(math.radians(rotation)), end[1] + 20 * math.cos(math.radians(rotation))),
(
end[0] + 20 * math.sin(math.radians(rotation - 120)),
end[1] + 20 * math.cos(math.radians(rotation - 120))),
(end[0] + 20 * math.sin(math.radians(rotation + 120)),
end[1] + 20 * math.cos(math.radians(rotation + 120)))))
def draw_dashed_line(self, surf, color, start_pos, end_pos, width=100, dash_length=8):
x1, y1 = start_pos
x2, y2 = end_pos
dl = dash_length
if (x1 == x2):
ycoords = [y for y in range(y1, y2, dl if y1 < y2 else -dl)]
xcoords = [x1] * len(ycoords)
elif (y1 == y2):
xcoords = [x for x in range(x1, x2, dl if x1 < x2 else -dl)]
ycoords = [y1] * len(xcoords)
else:
a = abs(x2 - x1)
b = abs(y2 - y1)
c = round(math.sqrt(a ** 2 + b ** 2))
dx = dl * a / c
dy = dl * b / c
xcoords = [x for x in numpy.arange(x1, x2, dx if x1 < x2 else -dx)]
ycoords = [y for y in numpy.arange(y1, y2, dy if y1 < y2 else -dy)]
next_coords = list(zip(xcoords[1::2], ycoords[1::2]))
last_coords = list(zip(xcoords[0::2], ycoords[0::2]))
for (x1, y1), (x2, y2) in zip(next_coords, last_coords):
start = (round(x1), round(y1))
end = (round(x2), round(y2))
pygame.draw.line(surf, color, start, end, width)
class Creature:
def __init__(self, name, attack, xp, manacost):
self.manacost = manacost
self.attack = attack
self.xp = xp
self.name = name
self.img = pygame.transform.scale(load_image(self.name + '.png'), (100, 160))
self.hov_on = False
self.x = 0
self.y = 0
class Creature_on_board(Creature):
def __init__(self, name, attack, xp, manacost):
super().__init__(name, attack, xp, manacost)
self.img = pygame.transform.scale(load_image(self.name + '_on_board.png'), (80, 110))
self.at_n = 0
self.death_n = 0
self.can_attack = False
def atack(self, num_of_enem_creature, board, event):
self.xp -= board.opponent_bar[num_of_enem_creature].attack
board.opponent_bar[num_of_enem_creature].xp -= self.attack
self.can_attack = False
if self.xp <= 0:
self.death_n += 1
if board.opponent_bar[num_of_enem_creature].xp <= 0:
board.opponent_bar[num_of_enem_creature].death_n += 1
# Класс манабар, для будущих наработок
class Manabar:
def __init__(self, num):
self.num = min(10, num)
pygame.init()
clock = pygame.time.Clock()
board = Board(1000, 700, 'background.png')
KwantStone = True
while KwantStone:
if board.music_flag:
for i in [board.loser_sound,
board.winner_sound,
board.kick,
board.your_turn_sound]:
i.set_volume(1)
else:
for i in [board.loser_sound,
board.winner_sound,
board.kick,
board.your_turn_sound]:
i.set_volume(0)
if len(board.my_hand) == 0 and board.my_bar.count(
0) == 5 and board.game_start and board.take_card is False and board.winner is False:
board.loset_flag = True
board.loser_sound_flag = True
if board.loser_sound_flag and board.music_flag:
board.loser_sound.play()
board.loser_sound_flag = False
if board.opponent_bar.count(0) == 5 and board.game_start:
board.winner = True
if board.winner_sound and board.music_flag:
board.winner_sound.play()
board.winner_sound_flag = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
KwantStone = False
# Условие для рисовки стрелки
if event.type == pygame.MOUSEBUTTONDOWN and board.hover_on_bar(event.pos[0], event.pos[1]) != -1 and \
board.my_bar[board.hover_on_bar(event.pos[0], event.pos[1])] != 0 and board.my_bar[
board.hover_on_bar(event.pos[0], event.pos[1])].can_attack:
if board.my_bar[board.hover_on_bar(event.pos[0], event.pos[1])].death_n == 0:
board.num = board.hover_on_bar(event.pos[0], event.pos[1])
board.choose_opp = True
board.arrow_from = 223 + 110 * board.num + 55, 407
board.draw_arrow(board.screen, (100, 100, 100), (223 + 110 * board.num + 55, 407), event.pos)
board.at_min = board.my_bar[board.hover_on_bar(event.pos[0], event.pos[1])]
# Если выбирал существо противника для атаки, но не быбрал
if event.type == pygame.MOUSEBUTTONUP and board.choose_opp and board.hover_on_op_bar(event.pos[0],
event.pos[1]) == -1:
board.choose_opp = False
elif event.type == pygame.MOUSEBUTTONUP and board.choose_opp and board.hover_on_op_bar(event.pos[0],
event.pos[
1]) != -1 and board.at_min != 0 and board.at_min.can_attack:
if board.opponent_bar[board.hover_on_op_bar(event.pos[0], event.pos[1])]:
if board.opponent_bar[board.hover_on_op_bar(event.pos[0], event.pos[1])].death_n == 0:
board.choose_opp = False
board.attacked_minion = board.opponent_bar[board.hover_on_op_bar(event.pos[0], event.pos[1])]
board.at_min.atack(board.hover_on_op_bar(event.pos[0], event.pos[1]), board, event)
board.kick.play(maxtime=500)
else:
board.choose_opp = False
else:
board.choose_opp = False
if event.type == pygame.MOUSEBUTTONDOWN:
if board.restart.get_rect(x=906, y=440).collidepoint(event.pos):
board.hand_update()
board.game_start = True
board.loset_flag = False
board.winner = False
elif board.turn_button.get_rect(x=808, y=319).collidepoint(event.pos) and board.game_start:
board.new_turn()
board.your_turn_sound.play()
elif board.exit_button.get_rect(x=907, y=551).collidepoint(event.pos):
KwantStone = False
elif board.sound_button.get_rect(x=907, y=511).collidepoint(event.pos):
if board.music_flag is False:
pygame.mixer_music.play(100)
board.music_flag = True
else:
pygame.mixer_music.pause()
board.music_flag = False
board.turn_button = board.green_turn_button
for i in board.my_bar:
if i != 0:
if i.can_attack:
board.turn_button = board.yellow_turn_button
break
if event.type == pygame.MOUSEMOTION and not board.take_card:
num = board.hover_on(event.pos[0], event.pos[1])
if num != -1:
board.make_cards_little_again()
board.my_hand[num].img = pygame.transform.scale(load_image(board.my_hand[num].name + '.png'),
(135, 210))
board.my_hand[num].hov_on = True
else:
board.make_cards_little_again()
if event.type == pygame.MOUSEBUTTONDOWN and board.hover_on(event.pos[0], event.pos[1]) != -1:
num = board.hover_on(event.pos[0], event.pos[1])
board.i_took_card = board.my_hand.pop(num)
board.take_card = True
board.i_took_card.img = pygame.transform.scale(board.i_took_card.img, (100, 160))
board.i_took_card.x = event.pos[0] - (133 + 31 * num + 100 * num)
board.i_took_card.y = event.pos[1] - 526
if event.type == pygame.MOUSEBUTTONUP:
num = board.hover_on_bar(event.pos[0], event.pos[1])
if board.i_took_card != -1 and num != -1 and board.my_bar[num] == 0:
if board.my_bar[num] == 0:
name, at, xp, manacost = board.i_took_card.name, board.i_took_card.attack, board.i_took_card.xp, board.i_took_card.manacost
board.my_bar[num] = Creature_on_board(name, at, xp, manacost)
board.i_took_card = -1
board.take_card = False
elif board.i_took_card != -1 and (
board.hover_on_bar(event.pos[0], event.pos[1]) == -1 or board.my_bar[num] != -1):
board.my_hand.append(
Creature(board.i_took_card.name, board.i_took_card.attack, board.i_took_card.xp,
board.i_took_card.manacost))
board.take_card = False
board.i_took_card = -1
if event.type == pygame.MOUSEMOTION and board.take_card:
if event.pos[1] < 510 and 0 in board.my_bar:
board.i_took_card.img = load_image(board.i_took_card.name + '_on_board.png')
if event.type == pygame.MOUSEMOTION:
board.posi = event.pos
board.allDraw(event)
board.show_attacked_min()
board.my_bar_show()
board.my_hand_show()
if board.choose_opp and event.type != pygame.KEYDOWN:
board.draw_arrow(board.screen, (100, 100, 100), (board.arrow_from[0], board.arrow_from[1]), event.pos)
if board.i_took_card != -1:
board.screen.blit(board.i_took_card.img,
(board.posi[0] - board.i_took_card.x, board.posi[1] - board.i_took_card.y))
if event.type == pygame.MOUSEBUTTONDOWN and board.take_card is False:
board.screen.blit(board.handdown, (board.posi[0] + 2, board.posi[1] + 1))
elif pygame.mouse.get_focused() and board.choose_opp is False and board.take_card is False:
board.screen.blit(board.cursor, board.posi)
elif pygame.mouse.get_focused() and board.take_card is True:
board.screen.blit(board.handgrab, board.posi)
board.clock.tick(40)
pygame.display.flip()
|
#! /usr/bin/env python
import urllib
def read_text():
quotes = open('/home/rodrigo/Documentos/python/doc')
contents_of_file = quotes.read()
# print(contents_of_file)
quotes.close()
check_profanity_function(contents_of_file)
def check_profanity_function(text):
connection = urllib.urlopen('http://www.wdylike.appspot.com/?q=' + text)
output = connection.read()
#print(output)
connection.close()
if "true" in output:
print(">>>>>>ALERT>>>>>>>Profanity Alert")
elif "false" in output:
print(">>>>>>Document all right>>>>>>>>>")
else:
print(">>>>>>Document not inspect>>>>>>>")
read_text()
|
from lib.dateutil.relativedelta import relativedelta
import hashlib
import time
# Time convert usage
# date(relativedelta(seconds=1207509))
attrs = ['years', 'months', 'days', 'hours', 'minutes', 'seconds']
date = lambda delta: [
'%d %s' % (
getattr(delta, attr), getattr(delta, attr) > 1 and
attr or attr[:-1]
) for attr in attrs if getattr(delta, attr)]
def relative(**kwargs):
return date(relativedelta(**kwargs))
def hrt(tmp_time):
return relative(seconds=int(time.time()) - int(tmp_time))
def hash(string):
return str(hashlib.md5(string).hexdigest())
def chunks(l, n):
""" Yield successive n-sized chunks from l. """
for i in xrange(0, len(l), n):
yield l[i:i + n]
def split_len(seq, length):
return [seq[i:i + length] for i in range(0, len(seq), length)]
def add_commas(number):
return "{:,d}".format(number)
def remove_spaces(string):
""" Remove triple/double and leading/ending spaces """
while ' ' in string:
string = string.replace(' ', ' ')
return string.strip()
|
import argparse
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
def load_graph(frozen_graph_filename):
# We load the protobuf file from the disk and parse it to retrieve the
# unserialized graph_def
with tf.gfile.GFile(frozen_graph_filename, "rb") as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
# Then, we can use again a convenient built-in function to import a graph_def into the
# current default Graph
with tf.Graph().as_default() as graph:
tf.import_graph_def(
graph_def,
input_map=None,
return_elements=None,
name="prefix",
op_dict=None,
producer_op_list=None
)
return graph
if __name__ == '__main__':
# Let's allow the user to pass the filename as an argument
parser = argparse.ArgumentParser()
parser.add_argument("--frozen_model_filename", default="results/frozen_model.pb", type=str, help="Frozen model file to import")
args = parser.parse_args()
# We use our "load_graph" function
graph = load_graph(args.frozen_model_filename)
# We can verify that we can access the list of operations in the graph
# for op in graph.get_operations():
# print(op.name)
# We access the input and output nodes
# x = graph.get_tensor_by_name('prefix/Model/v1:0')
# y = graph.get_tensor_by_name('prefix/Model/v2:0')
# a= graph.get_tensor_by_name('prefix/Model/a:0')
x = graph.get_tensor_by_name('prefix/x:0')
y = graph.get_tensor_by_name('prefix/y:0')
keep_prob = graph.get_tensor_by_name('prefix/keep:0')
acc= graph.get_tensor_by_name('prefix/Accuracy/acc:0')
# We launch a Session
# Network Parameters
n_input = 784 # MNIST data input (img shape: 28*28)
n_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units
mnist = input_data.read_data_sets("/notebooks/DNN_thhuang/CNN_MNIST/MNIST_data", one_hot=True)
#x = tf.placeholder(tf.float32, [None, n_input])
#y = tf.placeholder(tf.float32, [None, n_classes])
#keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)
with tf.Session(graph=graph) as sess:
# #sum=sess.run(a, feed_dict={x: 1, y:6})
# print(sum)
print("Testing Accuracy: %.4f"%(sess.run(acc, feed_dict={x: mnist.test.images[:],y: mnist.test.labels[:], keep_prob: 1.})))
print("Loading is successful!") |
def solution():
N, K = input().split()
K = int(K)
mArr = input().split()
count = 1
for i in range(K):
mArr.pop()
while True:
if len(mArr) >= K-1:
count += 1
for j in range(K-1):
mArr.pop()
elif len(mArr) == 0:
break
else:
count += 1
break
print(count)
solution()
|
print('##############')
print('# D #')
print('# I #')
print('# L #')
print('# U #')
print('# X #')
print('##############')
print('\n')
name = 'Diluxshan'
print('My name is '+name+ '. Hello '+name+'.')
name = 'Pavi'
print('My name is '+name+ '. Hello '+name+'.')
capital='Sabaragamuwa University'
print(capital.upper().isupper())
for x in range(0,10):
name = input(print("Enter Your Name:" ))
print("Hello "+ name)
# albha= 'albcdehf'
# print(albha.isalpha())
#cdcwdjjnv |
from Tkinter import *
class Demo(Frame):
def __init__(self,parent):
Frame.__init__(self)
self.frameParent=parent
self.frame1=Frame(
self.frameParent,
)
self.frame1.grid(
row=0,
column=0,
)
self.frame2=Frame(
self.frameParent,
)
self.frame2.grid(
row=0,
column=1,
)
self.frame3 = Frame(
self.frameParent,
)
self.frame3.grid(
row=1,
column=0,
columnspan=99,
)
self.createWidgets()
def createWidgets(self):
# one attribute to rule them all
# self.varFieldName_Key = []
# iterate to list all fields
irow=0
for numField in range(1):
# column 'No.'
icol=0
# label for button 1
label1 = Label(
self.frame1,
text='Radiobutton 1: '
)
label1.grid(
row=irow,
column=icol,
pady=5,
)
icol+=1
# radiobutton 1
# self.varFieldName_Key.append(numField)
# self.varFieldName_Key[numField] = IntVar
self.varFieldName_Key = IntVar()
# self.radiobuttonFieldName_Key.append('')
# self.radiobuttonFieldName_Key[numField] = Radiobutton(
self.radiobuttonFieldName_Key1 = Radiobutton(
self.frame1,
selectcolor='white',
# variable=self.varFieldName_Key[numField],
variable=self.varFieldName_Key,
# value=numField+1,
value=5,
bg='tan',
relief=FLAT,
command=self.handler1,
)
# self.radiobuttonFieldName_Key[numField].grid(
self.radiobuttonFieldName_Key1.grid(
row=irow,
column=icol,
padx=2,
pady=5
)
irow+=1
icol=0
# label for button 2
label2 = Label(
self.frame2,
text='Radiobutton 2:',
)
label2.grid(
row=irow,
column=icol,
padx=2,
pady=5,
)
# radiobutton 2
icol+=1
# self.varFieldName_Key.append(numField)
# self.varFieldName_Key[numField] = IntVar
# self.radiobuttonFieldName_Key.append('')
# self.radiobuttonFieldName_Key[numField] = Radiobutton(
self.radiobuttonFieldName_Key2 = Radiobutton(
self.frame2,
selectcolor='white',
variable=self.varFieldName_Key,
# value=numField+2,
value=10,
bg='tan',
relief=FLAT,
command=self.handler1,
)
# self.radiobuttonFieldName_Key[numField].grid(
self.radiobuttonFieldName_Key2.grid(
row=irow,
column=icol,
padx=2,
pady=5
)
# increment row
irow+=1
buttonQuit = Button(
self.frame3,
text='Quit',
width=20,
command=(lambda: self.frameParent.destroy()),
)
buttonQuit.grid(
row=99,
column=0,
columnspan=3,
pady=20,
)
# ---- handlers go here
def handler1(self):
if self.varFieldName_Key.get() == 1:
print '\n** Radiobutton1 is SET.'
elif self.varFieldName_Key.get() == 2:
print '\n** Radiobutton2 is set.'
else:
print '\n** Buttons are NOT set!'
stateButton = self.varFieldName_Key.get()
print ' state of self.varFieldName_Key.get():',stateButton
print ' resetting button'
if self.varFieldName_Key:
self.varFieldName_Key.set(0)
print ' >> Button has been cleared'
else:
self.varFieldName_Key.set(1)
print ' >> Button has been set'
stateButton = self.varFieldName_Key.get()
print ' NEW state of self.varFieldName_Key.get():',stateButton
# try test to see if this affects radiobuttons' assignments; it does not
# self.varFieldName_Key.set(3)
# print ' altered state of self.varFieldName_Key:',self.varFieldName_Key.get()
# below is not allowed, no attribute 'get' for this Radiobutton instance
# temp = self.radiobuttonFieldName_Key1.get()
# print ' >>> temp = ',temp
def handler2(self):
if self.varFieldName_Key:
print '\n Radiobutton2 is SET.'
else:
print '\n Radiobutton2 is NOT SET.'
stateButton2 = self.varFieldName_Key.get()
print 'state of button2:',stateButton2
root=Tk()
app=Demo(root)
app.master.title('demo: radiobuttons')
app.mainloop() |
import game, socket, threading, collections, pygame, extentions, logging, json
module_logger=logging.getLogger("jt3.server")
debug, info, warning, error, critical = module_logger.debug, module_logger.info, module_logger.warning, module_logger.error, module_logger.critical
class ServerGame(game.Game):
def start_connections(self):
self.clientcontrollers=collections.OrderedDict()
self.sock=socket.socket(socket.AF_INET, # Internet
socket.SOCK_DGRAM) # UDP
self.sock.bind((self.ip, self.port))
threading.Thread(target=self.handle_connections, daemon=True).start()
threading.Thread(target=self.handle_send, daemon=True).start()
def run_in_background(self):
threading.Thread(target=self.update_loop, daemon=True).start()
def handle_connections(self):
while self.running:
data, addr = self.sock.recvfrom(1024)
data=data.decode("utf-8")
if addr not in self.clientcontrollers:
debug("New client connected: "+str(addr))
self.clientcontrollers[addr]=ClientHandler(self, addr)
self.clientcontrollers[addr].handle_controlsframe(data)
def handle_send(self):
clock=pygame.time.Clock()
while self.running:
client=0
while client<len(self.clientcontrollers.values()):
list(self.clientcontrollers.values())[client].send_update_packet()
clock.tick(extentions.configuration["server_send_rate"]/len(self.clientcontrollers.values()))
client+=1
def update_loop(self):
clock=pygame.time.Clock()
while self.running:
clock.tick(extentions.configuration["server_physics_rate"])
self.update((1/clock.get_fps()) if clock.get_fps()!=0 else 0)
def update(self, dt):
to_remove=[]
for key, entity in self.entities:
entity.update(dt)
if entity.destroy==True:
to_remove.append(key)
for k in to_remove:
del self.entities[k]
class ClientHandler(object):
def __init__(self, server, addr):
self.addr=addr
self.server=server
self.sending_update_lock=threading.Lock()
def handle_controlsframe(self, frame):
data=json.loads(frame)
if data["up"]:
print("Up")
def send_update_packet(self):
for k, v in self.server.entities:
self.server.sock.sendto(self.server.pack_all_entities().encode("utf-8"), self.addr) |
import pytest
from helpers.cluster import ClickHouseCluster
from helpers.mock_servers import start_mock_servers
import os
METADATA_SERVER_HOSTNAME = "resolver"
METADATA_SERVER_PORT = 8080
cluster = ClickHouseCluster(__file__)
node = cluster.add_instance(
"node",
with_minio=True,
main_configs=["configs/use_environment_credentials.xml"],
env_variables={
"AWS_EC2_METADATA_SERVICE_ENDPOINT": f"{METADATA_SERVER_HOSTNAME}:{METADATA_SERVER_PORT}",
},
)
def start_metadata_server():
script_dir = os.path.join(os.path.dirname(__file__), "metadata_servers")
start_mock_servers(
cluster,
script_dir,
[
(
"server_with_session_tokens.py",
METADATA_SERVER_HOSTNAME,
METADATA_SERVER_PORT,
)
],
)
@pytest.fixture(scope="module", autouse=True)
def start_cluster():
try:
cluster.start()
start_metadata_server()
yield
finally:
cluster.shutdown()
def test_credentials_from_metadata():
node.query(
f"INSERT INTO FUNCTION s3('http://{cluster.minio_host}:{cluster.minio_port}/{cluster.minio_bucket}/test1.jsonl') SELECT * FROM numbers(100)"
)
assert (
"100"
== node.query(
f"SELECT count() FROM s3('http://{cluster.minio_host}:{cluster.minio_port}/{cluster.minio_bucket}/test1.jsonl')"
).strip()
)
expected_logs = [
"Calling EC2MetadataService to get token",
"Calling EC2MetadataService resource, /latest/meta-data/iam/security-credentials with token returned profile string myrole",
"Calling EC2MetadataService resource resolver:8080/latest/meta-data/iam/security-credentials/myrole with token",
"Successfully pulled credentials from EC2MetadataService with access key",
]
node.query("SYSTEM FLUSH LOGS")
for expected_msg in expected_logs:
assert node.contains_in_log(
"AWSEC2InstanceProfileConfigLoader: " + expected_msg
)
|
import time
nazev=input("Zadejte nazev knihy (bez pripony)\n")
start=time.time()
kniha=open(nazev+".txt","r")
slova2=kniha.read().split(" ")
kniha.close()
dalsi,slova,Slovo=[],[],None
for i in range(len(slova2)):
a=slova2[i].split("\n")
for i in range(len(a)):
dalsi.append(a.pop(0))
for i in range(len(dalsi)):
Slovo="".join(dalsi.pop(0)).lower()
slova.append(Slovo)
DPslova={}
for i in range(len(slova)):
slovo=slova.pop(0).lower()
if slovo in DPslova:
DPslova[slovo]+=1
else:
DPslova[slovo]=1
if "" in DPslova:
DPslova[""]=0
for i in range(3):
umisteni=0
for i in DPslova:
if DPslova[i] > umisteni:
umisteni=DPslova[i]
for i in DPslova:
if umisteni == DPslova[i]:
print(i+" "+str(DPslova[i]))
DPslova[i]=0
b=time.time()
input(str(b-start)+" sec")
|
# -*- coding: utf-8 -*-
'''
Created on Jun 19, 2017
@author: dzh
'''
from ..model.constant import YP_USER_HOST, APIKEY, VERSION_V1, USER, VERSION_V2
from .ypapi import YunpianApi, CommonResultHandler
class UserApi(YunpianApi):
'''用户接口 https://www.yunpian.com/api2.0/user.html'''
def _init(self, clnt):
super(UserApi, self)._init(clnt)
self.host(clnt.conf(YP_USER_HOST, 'https://sms.yunpian.com'))
def get(self, param=None, must=[APIKEY]):
'''查账户信息
参数名 类型 是否必须 描述 示例
apikey String 是 用户唯一标识 9b11127a9701975c734b8aee81ee3526
Args:
param: (Optional)
Results:
Result
'''
param = {} if param is None else param
r = self.verify_param(param, must)
if not r.is_succ():
return r
handle = CommonResultHandler(lambda rsp: {VERSION_V1:rsp.get(USER), VERSION_V2:rsp}[self.version()])
return self.path('get.json').post(param, handle, r)
def set(self, param=None, must=[APIKEY]):
'''修改账户信息
参数名 类型 是否必须 描述 示例
apikey String 是 用户唯一标识 9b11127a9701975c734b8aee81ee3526
emergency_contact String 否 紧急联系人 zhangshan
emergency_mobile String 否 紧急联系人手机号 13012345678
alarm_balance Long 否 短信余额提醒阈值。 一天只提示一次 100
Args:
param: emergency_contact emergency_mobile alarm_balance
Results:
Result
'''
param = {} if param is None else param
r = self.verify_param(param, must)
if not r.is_succ():
return r
h = CommonResultHandler(lambda rsp: {VERSION_V2:rsp}[self.version()])
return self.path('set.json').post(param, h, r)
|
characters = "Bste!hetsi ogEAxpelrt x "
document = "AlgoExpert is the Best!"
def generateDocument(characters, document):
for character in document:
doc_freq = count_char_freq(character, document)
char_freq = count_char_freq(character, characters)
if doc_freq > char_freq:
return False
return True
def count_char_freq(character, target):
frequency = 0
for char in target:
if char == character:
frequency += 1
return frequency
def generate_document(characters, document):
character_counts = {}
for character in characters:
if character not in character_counts:
character_counts[character] = 0
character_counts[character] += 1
for character in document:
if character not in character_counts or character_counts[character] == 0:
return False
character_counts[character] -= 1
return True
print(generate_document(characters, document))
# print(generateDocument(characters, document))
|
from django.db import models
from django.contrib.auth.models import AbstractUser
from django.utils.translation import ugettext_lazy as _
class User(AbstractUser):
GENDER = [
('M', 'Male'),
('F', 'Female')
]
USER_TYPE = [
('B', 'Basic'),
('P', 'Premium')
]
security_questions = (
('first_kissed', 'What is the first name of the person you first kissed?'),
('failing_grade', 'What is the last name of the teacher who gave you your first failing grade?'),
('wedding_reception', 'What is the name of the place your wedding reception was held?'),
('primary_school', 'What was the name of your elementary / primary school?'),
('sibling_live', 'In what city or town does your nearest sibling live?'),
('time_born','What time of the day were you born? (hh:mm)'),
('pets_name','What is your pet'+"'"+'s name?'),
('father_born', 'In what year was your father born?'),
('favorite', 'What is your favorite _____?')
)
middle_name = models.CharField(max_length = 30)
gender = models.CharField(max_length = 1, choices = GENDER)
date_of_birth = models.DateField(null = True)
address = models.CharField(max_length = 200)
contact_number = models.CharField(max_length = 200)
profile_picture = models.FileField(upload_to ='user/profile_pictures', null = True, blank = True)
profile_background = models.FileField(upload_to ='user/profile_background', null = True, blank = True)
cover_photo = models.FileField(upload_to ='user/cover_photo', null = True, blank = True)
captcha = models.CharField(max_length = 500)
security_question = models.CharField(max_length = 30, choices = security_questions)
security_answer = models.CharField(max_length = 100)
user_type_expiration = models.DateTimeField(null = True)
user_type = models.CharField(max_length = 1, choices = USER_TYPE)
is_confirmed = models.BooleanField(default = False)
class Follow(models.Model):
following = models.ForeignKey(User, related_name = 'following')
follower = models.ForeignKey(User, related_name = 'follower')
date_followed = models.DateTimeField(auto_now_add = True)
class User_Post(models.Model):
message = models.CharField(max_length = 500)
sender = models.ForeignKey(User, related_name = 'sender')
recipient = models.ForeignKey(User, related_name = 'recipient')
sender_delete = models.BooleanField(default = False)
recipient_delete = models.BooleanField(default = False)
sender_hide = models.BooleanField(default = False)
recipient_hide = models.BooleanField(default = False)
date_sent = models.DateTimeField(auto_now_add = True) |
from sys import maxsize
class Contact:
def __init__(self, id=None, fname=None, mname=None, lname=None, nname=None, photo=None, title=None, company=None, addr=None, home=None, mobile=None, work=None, fax=None, email=None, email2=None, email3=None, homepage=None, bmonth=None, bday=None, amonth=None, aday=None, byear=None, ayear=None, address2=None, phone2=None, notes=None, all_phones=None, all_emails=None, groups=None):
self.id = id
self.fname = fname
self.mname = mname
self.lname = lname
self.nname = nname
self.photo = photo
self.title = title
self.company = company
self.addr = addr
self.home = home
self.mobile = mobile
self.work = work
self.fax = fax
self.email = email
self.email2 = email2
self.email3 = email3
self.homepage = homepage
self.bmonth = bmonth
self.bday = bday
self.amonth = amonth
self.aday = aday
self.byear = byear
self.ayear = ayear
self.address2 = address2
self.phone2 = phone2
self.notes = notes
self.all_phones = all_phones
self.all_emails = all_emails
self.groups = groups
def __repr__(self):
return("%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s" % (self.id, self.fname, self.mname, self.lname, self.nname, self.photo, self.title, self.company, self.addr, self.home, self.work, self.mobile, self.email, self.email2, self.email3, self.homepage, self.bmonth, self.bday, self.amonth, self.aday, self.byear, self.ayear, self.address2, self.phone2, self.notes))
def __eq__(self, other):
return((self.id is None or other.id is None or self.id == other.id) and
self.fname == other.fname and
self.lname == other.lname)
def id_or_max(self):
if self.id:
return int(self.id)
else:
return maxsize
|
first_name = 'Dušan'
last_name = 'Tanasić'
output = 'Hello ' + first_name + ' ' + last_name
output = 'Hello {} {}'.format(first_name, last_name)
output = 'Hello {0} {1}'.format(first_name, last_name)
# Only in python 3.X
output = f'Hello {first_name} {last_name}'
print(output)
|
import urllib.request
from time import sleep
from http.client import IncompleteRead
from config import *
URL = "http://cube.rider.biz/visualcube.php"
def replace_at_index(string, index, letter):
return string[:index] + letter + string[index + 1:]
vcube_skel = {
'outer': "wwwwwwtttwwtttwwtttwwwwww"*3 + "sssssstttsstttsstttssssss"*3,
'inner': "ttttttwwwttwwwttwwwtttttt"*3 + "ttttttsssttsssttssstttttt"*3,
'full': "w"*75 + "s"*75
}
skel_idxs = {
'c': {
'UBL': [0], 'UBR': [4], 'UFL': [20], 'UFR': [24],
'LUB': [100], 'LUF': [104], 'LDB': [120], 'LDF': [124],
'FUL': [50], 'FUR': [54], 'FDL': [70], 'FDR': [74],
'RUF': [25], 'RUB': [29], 'RDF': [45], 'RDB': [49],
'BUL': [129], 'BUR': [125], 'BDL': [149], 'BDR': [145],
'DBL': [95], 'DBR': [99], 'DFL': [75], 'DFR': [79],
},
'e': {
'UB': [2], 'UL': [10], 'UR': [14], 'UF': [22],
'LU': [102], 'LB': [110], 'LF': [114], 'LD': [122],
'FU': [52], 'FL': [60], 'FR': [64], 'FD': [72],
'RU': [27], 'RF': [35], 'RB': [39], 'RD': [47],
'BU': [127], 'BL': [139], 'BR': [135], 'BD': [147],
'DB': [97], 'DL': [85], 'DR': [89], 'DF': [77],
},
'x': {
'Ubl': [6], 'Ubr': [8], 'Ufl': [16], 'Ufr': [18],
'Lub': [106], 'Luf': [108], 'Ldb': [116], 'Ldf': [118],
'Ful': [56], 'Fur': [58], 'Fdl': [66], 'Fdr': [68],
'Ruf': [31], 'Rub': [33], 'Rdf': [41], 'Rdb': [43],
'Bul': [133], 'Bur': [131], 'Bdl': [143], 'Bdr': [141],
'Dbl': [91], 'Dbr': [93], 'Dfl': [81], 'Dfr': [83],
},
't': {
'Ub': [7], 'Ul': [11], 'Ur': [13], 'Uf': [17],
'Lu': [107], 'Lb': [111], 'Lf': [113], 'Ld': [117],
'Fu': [57], 'Fl': [61], 'Fr': [63], 'Fd': [67],
'Ru': [32], 'Rf': [36], 'Rb': [38], 'Rd': [42],
'Bu': [132], 'Bl': [138], 'Br': [136], 'Bd': [142],
'Db': [92], 'Dl': [86], 'Dr': [88], 'Df': [82],
},
'w': {
'UBl': [1,128], 'ULf': [15,103], 'URb': [9,28], 'UFr': [23,53],
'LUb': [5,101], 'LBd': [115,144], 'LFu': [55,109], 'LDf': [80,123],
'FUl': [21,51], 'FLd': [65,119], 'FRu': [30,59], 'FDr': [73,78],
'RUf': [19,26], 'RFd': [40,69], 'RBu': [34,130], 'RDb': [48,94],
'BUr': [3,126], 'BLu': [105,134], 'BRd': [44,140], 'BDl': [96,148],
'DBr': [98,146], 'DLb': [90,121], 'DRf': [46,84], 'DFl': [71,76],
},
}
arrow_idxs = {
'c': {
'UBL': 'U0', 'UBR': 'U4', 'UFL': 'U20', 'UFR': 'U24',
'LUB': 'L0', 'LUF': 'L4', 'LDB': 'L20', 'LDF': 'L24',
'FUL': 'F0', 'FUR': 'F4', 'FDL': 'F20', 'FDR': 'F24',
'RUF': 'R0', 'RUB': 'R4', 'RDF': 'R20', 'RDB': 'R24',
'BUL': 'B4', 'BUR': 'B0', 'BDL': 'B24', 'BDR': 'B20',
'DBL': 'D20', 'DBR': 'D24', 'DFL': 'D0', 'DFR': 'D4',
},
'e': {
'UB': 'U2', 'UL': 'U10', 'UR': 'U14', 'UF': 'U22',
'LU': 'L2', 'LB': 'L10', 'LF': 'L14', 'LD': 'L22',
'FU': 'F2', 'FL': 'F10', 'FR': 'F14', 'FD': 'F22',
'RU': 'R2', 'RF': 'R10', 'RB': 'R14', 'RD': 'R22',
'BU': 'B2', 'BL': 'B14', 'BR': 'B10', 'BD': 'B22',
'DB': 'D22', 'DL': 'D10', 'DR': 'D14', 'DF': 'D2',
},
'x': {
'Ubl': 'U6', 'Ubr': 'U8', 'Ufl': 'U16', 'Ufr': 'U18',
'Lub': 'L6', 'Luf': 'L8', 'Ldb': 'L16', 'Ldf': 'L18',
'Ful': 'F6', 'Fur': 'F8', 'Fdl': 'F16', 'Fdr': 'F18',
'Ruf': 'R6', 'Rub': 'R8', 'Rdf': 'R16', 'Rdb': 'R18',
'Bul': 'B8', 'Bur': 'B6', 'Bdl': 'B18', 'Bdr': 'B16',
'Dbl': 'D16', 'Dbr': 'D18', 'Dfl': 'D6', 'Dfr': 'D8',
},
't': {
'Ub': 'U7', 'Ul': 'U11', 'Ur': 'U13', 'Uf': 'U17',
'Lu': 'L7', 'Lb': 'L11', 'Lf': 'L13', 'Ld': 'L17',
'Fu': 'F7', 'Fl': 'F11', 'Fr': 'F13', 'Fd': 'F17',
'Ru': 'R7', 'Rf': 'R11', 'Rb': 'R13', 'Rd': 'R17',
'Bu': 'B7', 'Bl': 'B13', 'Br': 'B11', 'Bd': 'B17',
'Db': 'D17', 'Dl': 'D11', 'Dr': 'D13', 'Df': 'D7',
},
'w': {
'UBl': 'U1', 'ULf': 'U15', 'URb': 'U9', 'UFr': 'U23',
'LUb': 'L1', 'LBd': 'L15', 'LFu': 'L9', 'LDf': 'L23',
'FUl': 'F1', 'FLd': 'F15', 'FRu': 'F9', 'FDr': 'F23',
'RUf': 'R1', 'RFd': 'R15', 'RBu': 'R9', 'RDb': 'R23',
'BUr': 'B1', 'BLu': 'B9', 'BRd': 'B15', 'BDl': 'B23',
'DBr': 'D23', 'DLb': 'D15', 'DRf': 'D9', 'DFl': 'D1',
},
}
def arrow_cycle(pce_type, p1, p2):
arrow = "-s8-d,"
return (arrow_idxs[pce_type][buffers[pce_type]] + arrow_idxs[pce_type][p1] + arrow
+ arrow_idxs[pce_type][p1] + arrow_idxs[pce_type][p2] + arrow
+ arrow_idxs[pce_type][p2] + arrow_idxs[pce_type][buffers[pce_type]] + arrow)
def generate_url(pce_type, p1, p2):
skel = "w"*75 + "s"*75
targets = (buffers[pce_type], p1, p2)
target_clrs = ('r','m','m')
for i in range(3):
for idx in skel_idxs[pce_type][targets[i]]:
skel = replace_at_index(skel, idx, target_clrs[i])
params = [
"fmt=png",
"pzl=5",
"size=400",
"r=y25x-34",
"cc=l",
"bg=t",
"fo=80",
"co=15",
"fc=" + skel,
"arw=" + arrow_cycle(pce_type, p1, p2)
]
return f"{URL}?{'&'.join(params)}"
def buffer_idx(pce_type):
i = 0
while i < len(pieces[pce_type]):
if buffers[pce_type] in pieces[pce_type][i]:
break
i += 1
return i
def download_imgs():
for pce_type in ['e']:
counter = 0
pces = pieces[pce_type]
for i in range(len(pces)):
for j in range(len(pces)):
if i == j:
continue
for k in range(len(pces[i])):
for l in range(len(pces[j])):
p1 = pces[i][k]
p2 = pces[j][l]
if pce_type in ('x','t','w') and (p1 == buffers[pce_type] or p2 == buffers[pce_type]):
continue
elif pce_type in ('c','e') and (p1 in pces[buffer_idx(pce_type)] or p2 in pces[buffer_idx(pce_type)]):
continue
url = generate_url(pce_type, p1, p2)
filepath = f"images/{pce_type}/{buffers[pce_type]} {p1} {p2}.png"
try:
urllib.request.urlretrieve(url, filepath)
counter += 1
print(f"saved ({buffers[pce_type]} {p1} {p2}) to images/{pce_type} [{counter}]")
except ConnectionResetError:
sleep(5)
except IncompleteRead:
continue
if __name__ == "__main__":
"""
pce_type = input("piece type: ")
p1, p2 = input("targets: ").split()
print(generate_url(pce_type, p1, p2))
"""
download_imgs()
|
# Generadores:
#De numeros primos:
from math import sqrt
def primos(ini, fin, salto=1):
def esPrimo(numero):
for i in range(2, round(sqrt(numero))+1):
if numero % i == 0:
return False
return True
# Codigo principal del generador:
i = ini
while i < fin:
if esPrimo(i):
yield i
i+=salto
# Los primos del 200 al 300
L = [i for i in primos(200,300)]
print(L)
|
"""
The :mod:`classifier` is a high-level interface to train a short-text data.
Members of :mod:`classifier` include :class:`TextModel` and its utility
functions. :class:`TextModel` is obtained in training and then used in prediction.
The standard method to get a :class:`TextModel` instance is via function
:func:`train_text` or :func:`train_converted_text`, which trains
text data (refer to :ref:`dataset`) or LIBSVM-format data, respectively.
>>> from libshorttext.classifier import *
>>> # train a model and save it to a file
>>> m, svm_file = train_text('train_file')
>>> # save the model to a file
>>> m.save('model_path')
After obtaining a :class:`TextModel`, users can use :func:`predict_text` or
:func:`predict_single_text` to predict the label of a new short text.
>>> from libshorttext.classifier import *
>>> # load a model from a file
>>> m = TextModel('model_path')
>>> # predict a sentence
>>> result = predict_single_text('This is a sentence.', m)
Another class in module :mod:`classifier` is :class:`PredictionResult`, which is a
wrapper of prediction results. Both :func:`predict_text` and
:func:`predict_single_text` return a :class:`PredictionResult` object.
:mod:`classifier` does not access the low-level LIBLINEAR's train and predict
utilities directly. All jobs are passed to a submodule called :mod:`learner`,
which is a middle-level classifier and communicates between :mod:`classifier`
and LIBLINEAR. Users can also use the :mod:`learner` module directly without
:mod:`classifier` to achieve more complicated usages.
"""
from .classifier_impl import *
del classifier_impl
|
# Generated by Django 3.0.7 on 2020-06-18 06:37
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='actor',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('nombre', models.TextField()),
('pais', models.TextField()),
('edad', models.TextField()),
('fechaNac', models.TextField()),
],
),
]
|
"""Admin error classes."""
from ..core.error import BaseError
class AdminError(BaseError):
"""Base class for Admin-related errors."""
class AdminSetupError(AdminError):
"""Admin server setup or configuration error."""
|
# https://www.codewars.com/kata/568d0dd208ee69389d000016
#
# After a hard quarter in the office you decide to get some rest on a vacation.
# So you will book a flight for you and your girlfriend and try to leave all
# the mess behind you.
#
# You will need a rental car in order for you to get around in your vacation.
# The manager of the car rental makes you some good offers.
#
# Every day you rent the car costs $40. If you rent the car for 7 or more days,
# you get $50 off your total. Alternatively, if you rent the car for 3 or more
# days, you get $20 off your total.
#
# Write a code that gives out the total amount for different days(d).
def rental_car_cost(d):
corr = 0
if d >= 3:
corr = 20
if d >= 7:
corr = 50
return d*40-corr
|
# -*- coding: utf-8 -*-
from google.appengine.ext import db
from google.appengine.api import memcache
from utils import FrontendHandler, need_auth
from models import Account, AccountOperation
from filters import do_label_for_acc_oper
class HistoryController(FrontendHandler):
@need_auth()
def account_ops(self, **kwargs):
kwargs['html'] = 'history'
kwargs['tab'] = 'history_%s' % kwargs['currency']
return self.render_response('frontend/history_account_operations.html', **kwargs)
@need_auth()
def account_ops_list(self, **kwargs):
currency = 'BTC' if kwargs['currency'] == 'btc' else 'ARS'
descriptions = {AccountOperation.MONEY_IN : 'Deposito de %s' % currency,
AccountOperation.MONEY_OUT : 'Retiro de %s' % currency,
AccountOperation.BTC_SELL : 'Venta de Bitcoin',
AccountOperation.BTC_BUY : 'Compra de Bitcoin'}
query = AccountOperation.all().filter('account =', db.Key(self.user))
query = query.filter('currency =', currency)
query = query.order('-created_at')
deposits = {'aaData':[]}
for aop in query:
row = []
row.append(aop.created_at.strftime("%Y-%m-%d %H:%M:%S"))
row.append(descriptions[aop.operation_type])
row.append('%.8f' % aop.amount )
if aop.commission_rate is not None:
row.append('%.3f' % aop.commission_rate )
else:
row.append('---')
row.append( do_label_for_acc_oper(aop) )
deposits['aaData'].append(row)
return self.render_json_response(deposits)
pass |
cnt = 0
for i in range(3,1000000,2):
in_cnt = 0
for j in range(2,i):
if i % j == 0:
in_cnt += 1
break
if in_cnt == 0:
cnt += 1
if cnt >= 10001-1:
break
print(i)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.