Datasets:

codeparrot

/

codeparrot-valid-v2-near-dedup

like 1

The-WebOps-Club/odia-forum

pybbm_tag/views.py

1

2818

from django.shortcuts import render from pybb.models import * from pybbm_tag.models import Tag from pybb.views import ForumView,AddPostView,EditPostView,TopicView def add_tag(request,**kwargs): # check permissions before calling this function # in kwargs we expect the LABEL of the tag to add(not object) and the TOPIC object(not name). topic = kwargs['topic'] tagname = kwargs['tag'] lst = Tag.objects.filter(label = tagname) if not lst.count() == 0: lst[0].topics.add(topic) lst[0].save() else: tag = Tag(label = tagname,desc="Empty") tag.save() tag.topics.add(topic) def remove_all_tags(request,**kwargs): topic = kwargs['topic'] for i in Tag.objects.filter(topics__in = [topic]): i.topics.remove(topic) def remove_tag(request,**kwargs): # check permissions before calling this function. topic = kwargs['topic'] tagname = kwargs['tag'] lst = Tag.objects.filter(label = tagname) lst[0].topics.remove(topic) # tag additions to the views that are affected by tags. class AddPostViewWrapper(AddPostView): def post(self, request, *args, **kwargs): try: ret = super(AddPostViewWrapper, self).post(request, *args, **kwargs) taglist = request.POST['taglist'].split('+') #import pdb;pdb.set_trace() for i in taglist: add_tag(request, topic=self.object.topic, tag=i) except KeyError: pass return ret def get_context_data(self,**kwargs): ctx = super(AddPostViewWrapper, self).get_context_data(**kwargs) if ctx['forum']: ctx['taglist_input'] = 1 return ctx class ForumViewWrapper(ForumView): def get_context_data(self): ctx = super(ForumViewWrapper, self).get_context_data() topic_list = ctx['topic_list'] tags = [] for i in topic_list: tags.append(Tag.objects.filter(topics__in = [i])) ctx['tags'] = Tag.objects.all() return ctx class TopicViewWrapper(TopicView): def get_context_data(self): ctx = super(TopicViewWrapper, self).get_context_data() ctx['tags'] = Tag.objects.all() return ctx class EditPostViewWrapper(EditPostView): def post(self, request, *args, **kwargs): ret = super(EditPostViewWrapper, self).post(request, *args, **kwargs) try: taglist = request.POST['taglist'].split('+') remove_all_tags(request, topic=self.object.topic) for i in taglist: add_tag(request, topic=self.object.topic, tag=i) except KeyError: pass return ret def make_tag_string(self,topic): str = "" for i in Tag.objects.filter(topics__in = [topic]): str+=(i.label+"+") if len(str) > 0: str = str[:-1] return str def get_context_data(self, **kwargs): ctx = super(EditPostViewWrapper, self).get_context_data(**kwargs) post = ctx['post'] if post.topic.user == self.request.user: ctx['taglist_input'] = 1 ctx['taglist_initial'] = self.make_tag_string(post.topic) return ctx

gpl-2.0

lichengshuang/createvhost

others/webvirtmgr/delServer.py

1

1305

#!/usr/bin/python #-*-encoding:utf-8-*- #author: asher #date: 20160429 on train D909 # this scripts useed for add server ip to webvirtmgr # if not , each server must add by website,it's too slow, and very not interesting. # use this , it's make you feel very happy import sqlite3 try: conn = sqlite3.connect('../webvirtmgr.sqlite3') cur = conn.cursor() print "Input the server ip address like:" ips = raw_input("Ips 172.23.32:").strip() ips1 = int(raw_input("Input start last ip num: 1:>").strip()) ips2 = int(raw_input("Input end ip num: 100:>").strip()) # jifang = str(raw_input("DataCenter like:jxq:>").strip()) # login = str(raw_input("User:admin or others:>").strip()) # password = str(raw_input("Password:>").strip()) while True: if ips1 <= ips2: ips1 = str(ips1) newip = ips + "." + ips1 # jifang1 = jifang + "_" + newip print "Del %s into database\n" % newip cur.execute("delete from servers_compute where hostname == '%s'" % newip) ips1 = int(ips1) ips1 += 1 conn.commit() else: break finally: allservers = cur.execute("select id,name,hostname,login,type from servers_compute").fetchall() for i in allservers: print i conn.close()

apache-2.0

louisq/staticguru

utility/artifact_archiver.py

1

4495

""" The MIT License (MIT) Copyright (c) 2016 Louis-Philippe Querel l_querel@encs.concordia.ca Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ import glob import os import shutil from Logging import logger """ The purpose of this utility is to clone the artifacts that have been generated through the build process to preserve them This version would probably only work for maven run projects """ FILTERED_EXTENSIONS = ('*.jar', '*.tar.*', '*.zip', '*.rpm') # todo replace with an abstract solution that could be reused for the other modules to log the version that was ran artifact_archiver_version = 1 def archive(repo_path, archive_path, repo_id, commit, filter_extensions=True): # Determine if we can access the path where the archive should be if not _determine_access(archive_path): logger.error("Failed to save to archive %s" % archive_path) return False temp_archive = os.path.join(repo_path, "%s-temp" % commit) temp_archive_compress_file_no_ext = os.path.join(temp_archive, commit) temp_archive_compress_file = "%s.tar.gz" % temp_archive_compress_file_no_ext archive_repo_path = os.path.join(archive_path, repo_id) archive_compress_file = "%s.tar.gz" % os.path.join(archive_repo_path, commit) _clear_archive(temp_archive, archive_compress_file) target_directories = _identify_target_directories(repo_path) _clone_files_in_targets(repo_path, temp_archive, target_directories, filter_extensions=filter_extensions) _compress_files(temp_archive, temp_archive_compress_file_no_ext) _move_compress_file_to_archive(archive_repo_path, temp_archive_compress_file) # Delete the temporary folder _clear_archive_temp(temp_archive) return True def _determine_access(archive_path): return os.path.exists(archive_path) def _clear_archive(archive_temp, archive_compress_file): _clear_archive_temp(archive_temp) if os.path.exists(archive_compress_file): os.remove(archive_compress_file) def _clear_archive_temp(temp_archive): if os.path.exists(temp_archive): shutil.rmtree(temp_archive) def _identify_target_directories(repo_path): folder = "target" nesting = "**/" target_directories = glob.glob(r'%s%s' % (repo_path, folder)) compound_nesting = "" # We need to navigate the repository to find project target folders for count in range(5): compound_nesting += nesting target_directories += glob.glob(r'%s%s%s' % (repo_path, compound_nesting, folder)) return target_directories def _clone_files_in_targets(repo_path, temp_archive, target_directories, filter_extensions): # Determine if we need to filter any of the files if filter_extensions: ignore = shutil.ignore_patterns(FILTERED_EXTENSIONS) else: ignore = None for path in target_directories: folder = path[len(repo_path):] shutil.copytree(path, "%s/%s" % (temp_archive, folder), ignore=ignore, symlinks=True) def _compress_files(archive_temp, temp_archive_compress_file_no_ext): # If the compression is changed the file extension needs to be changed as well in the parent method shutil._make_tarball(temp_archive_compress_file_no_ext, archive_temp, compress="gzip") def _move_compress_file_to_archive(repo_archive_path, temp_archive_compress_file): if not os.path.exists(repo_archive_path): os.makedirs(repo_archive_path) shutil.move(temp_archive_compress_file, repo_archive_path)

mit

MCFlowMace/Wordom

src/setup.py

1

1423

#! /usr/bin/env python # System imports from distutils.core import * from distutils import sysconfig # Third-party modules - we depend on numpy import numpy # in order to check whether lapack are present ... import numpy.distutils.system_info as sysinfo # Obtain the numpy include directory. This works across numpy versions. try: numpy_include = numpy.get_include() except AttributeError: numpy_include = numpy.get_numpy_include() # wordom extension module if len(sysinfo.get_info('lapack')) == 0: _wordom = Extension("_wordom", ["wordom.i","fileio.c","tools.c","qcprot.c", "xdrfile.c", "xdrfile_xtc.c"], ) else: _wordom = Extension("_wordom", ["wordom.i","fileio.c","tools.c","qcprot.c", "xdrfile.c", "xdrfile_xtc.c"], include_dirs = [numpy_include], extra_compile_args = ["-D LAPACK"], libraries = [ 'lapack', 'blas' ] ) # NumyTypemapTests setup setup( name = "wordom", description = "wordom is a molecular structure and data manipulation program/library", author = "Michele Seeber & colleagues", url = "http://wordom.sf.net", author_email= "mseeber@gmail.com", license = "GPL", version = "0.23", ext_modules = [_wordom], py_modules = ['wordom'] )

gpl-3.0

montefra/dodocs

dodocs/__init__.py

1

1068

"""Main function Copyright (c) 2015 Francesco Montesano MIT Licence """ import os import sys from dodocs.cmdline import parse import dodocs.logger as dlog __version__ = "0.0.1" def main(argv=None): """ Main code Parameters ---------- argv : list of strings, optional command line arguments """ args = parse(argv=argv) dlog.setLogger(args) # make sure to reset the subcommand name log = dlog.getLogger() if "func" in args: args.func(args) log.debug("Finished") return 0 else: # defaults profile to list if args.subparser_name == 'profile' and args.profile_cmd is None: main(sys.argv[1:] + ["list"]) else: # in the other cases suggest to run -h msg = ("Please provide a valid command.\n" "Type\n " + os.path.split(sys.argv[0])[1]) if args.subparser_name is not None: msg += " " + args.subparser_name msg += ' -h' log.error(msg) return 1

mit

mozilla/kitsune

kitsune/wiki/permissions.py

1

4844

import logging from django.conf import settings log = logging.getLogger("k.wiki") # Why is this a mixin if it can only be used for the Document model? # Good question! My only good reason is to keep the permission related # code organized and contained in one place. class DocumentPermissionMixin(object): """Adds of permission checking methods to the Document model.""" def allows(self, user, action): """Check if the user has the permission on the document.""" # If this is kicking up a KeyError it's probably because you typoed! return getattr(self, "_allows_%s" % action)(user) def _allows_create_revision(self, user): """Can the user create a revision for the document?""" # For now (ever?), creating revisions isn't restricted at all. return True def _allows_edit(self, user): """Can the user edit the document?""" # Document editing isn't restricted until it has an approved # revision. if not self.current_revision: return True # Locale leaders and reviewers can edit in their locale. locale = self.locale if _is_leader(locale, user) or _is_reviewer(locale, user): return True # And finally, fallback to the actual django permission. return user.has_perm("wiki.change_document") def _allows_delete(self, user): """Can the user delete the document?""" # Locale leaders can delete documents in their locale. locale = self.locale if _is_leader(locale, user): return True # Fallback to the django permission. return user.has_perm("wiki.delete_document") def _allows_archive(self, user): """Can the user archive the document?""" # Just use the django permission. return user.has_perm("wiki.archive_document") def _allows_edit_keywords(self, user): """Can the user edit the document's keywords?""" # If the document is in the default locale, just use the # django permission. # Editing keywords isn't restricted in other locales. return self.locale != settings.WIKI_DEFAULT_LANGUAGE or user.has_perm("wiki.edit_keywords") def _allows_edit_needs_change(self, user): """Can the user edit the needs change fields for the document?""" # If the document is in the default locale, just use the # django permission. # Needs change isn't used for other locales (yet?). return self.locale == settings.WIKI_DEFAULT_LANGUAGE and user.has_perm( "wiki.edit_needs_change" ) def _allows_mark_ready_for_l10n(self, user): """"Can the user mark the document as ready for localization?""" # If the document is localizable and the user has the django # permission, then the user can mark as ready for l10n. return self.is_localizable and user.has_perm("wiki.mark_ready_for_l10n") def _allows_review_revision(self, user): """Can the user review a revision for the document?""" # Locale leaders and reviewers can review revisions in their # locale. locale = self.locale if _is_leader(locale, user) or _is_reviewer(locale, user): return True # Fallback to the django permission. return user.has_perm("wiki.review_revision") def _allows_delete_revision(self, user): """Can the user delete a document's revisions?""" # Locale leaders and reviewers can delete revisions in their # locale. locale = self.locale if _is_leader(locale, user) or _is_reviewer(locale, user): return True # Fallback to the django permission. return user.has_perm("wiki.delete_revision") def _is_leader(locale, user): """Checks if the user is a leader for the given locale. Returns False if the locale doesn't exist. This will should only happen if we forgot to insert a new locale when enabling it or during testing. """ from kitsune.wiki.models import Locale try: locale_team = Locale.objects.get(locale=locale) except Locale.DoesNotExist: log.warning("Locale not created for %s" % locale) return False return user in locale_team.leaders.all() def _is_reviewer(locale, user): """Checks if the user is a reviewer for the given locale. Returns False if the locale doesn't exist. This will should only happen if we forgot to insert a new locale when enabling it or during testing. """ from kitsune.wiki.models import Locale try: locale_team = Locale.objects.get(locale=locale) except Locale.DoesNotExist: log.warning("Locale not created for %s" % locale) return False return user in locale_team.reviewers.all()

bsd-3-clause

aussendorf/bareos-fd-python-plugins

plugin/BareosFdPluginBaseclass.py

1

5778

#This file is now part of the main Bareos repo. Do not use this version, use the package bareos-filedaemon-python-plugin instead #!/usr/bin/env python # -*- coding: utf-8 -*- # Baseclass for Bareos python plugins # Functions taken and adapted from bareos-fd.py # (c) Bareos GmbH & Co. KG, Maik Aussendorf # AGPL v.3 from bareosfd import * from bareos_fd_consts import * from io import open from os import O_WRONLY, O_CREAT class BareosFdPluginBaseclass: ''' Bareos python plugin base class ''' def __init__(self, context, plugindef): DebugMessage(context, 100, "Constructor called in module " + __name__ + "\n"); events = []; events.append(bEventType['bEventJobEnd']); events.append(bEventType['bEventEndBackupJob']); events.append(bEventType['bEventEndFileSet']); events.append(bEventType['bEventHandleBackupFile']); RegisterEvents(context, events); # get some static Bareos values self.fdname = GetValue(context, bVariable['bVarFDName']); self.jobId = GetValue(context, bVariable['bVarJobId']); self.client = GetValue(context, bVariable['bVarClient']); self.level = GetValue(context, bVariable['bVarLevel']); self.jobName = GetValue(context, bVariable['bVarJobName']); self.workingdir = GetValue(context, bVariable['bVarWorkingDir']); DebugMessage(context, 100, "FDName = " + self.fdname + " - BareosFdPluginBaseclass\n"); DebugMessage(context, 100, "WorkingDir = " + self.workingdir + " jobId: " + str(self.jobId) + "\n"); def parse_plugin_definition(self,context, plugindef): DebugMessage(context, 100, "plugin def parser called with " + plugindef + "\n"); # Parse plugin options into a dict self.options = dict(); plugin_options = plugindef.split(":"); for current_option in plugin_options: key,sep,val = current_option.partition("="); DebugMessage(context, 100, "key:val: " + key + ':' + val + "\n"); if val == '': continue; else: self.options[key] = val; # you should overload this method with your own and do option checking here, return bRCs['bRC_Error'], if options are not ok # or better call super.parse_plugin_definition in your own class and make sanity check on self.options afterwards return bRCs['bRC_OK']; def plugin_io(self, context, IOP): DebugMessage(context, 100, "plugin_io called with " + str(IOP) + "\n"); FNAME = IOP.fname; if IOP.func == bIOPS['IO_OPEN']: try: if IOP.flags & (O_CREAT | O_WRONLY): self.file = open(FNAME, 'wb'); else: self.file = open(FNAME, 'rb'); except: IOP.status = -1; return bRCs['bRC_Error']; return bRCs['bRC_OK']; elif IOP.func == bIOPS['IO_CLOSE']: self.file.close(); return bRCs['bRC_OK']; elif IOP.func == bIOPS['IO_SEEK']: return bRCs['bRC_OK']; elif IOP.func == bIOPS['IO_READ']: IOP.buf = bytearray(IOP.count); IOP.status = self.file.readinto(IOP.buf); IOP.io_errno = 0 return bRCs['bRC_OK']; elif IOP.func == bIOPS['IO_WRITE']: IOP.status = self.file.write(IOP.buf); IOP.io_errno = 0 return bRCs['bRC_OK']; def handle_plugin_event(self, context, event): if event == bEventType['bEventJobEnd']: DebugMessage(context, 100, "handle_plugin_event called with bEventJobEnd\n"); elif event == bEventType['bEventEndBackupJob']: DebugMessage(context, 100, "handle_plugin_event called with bEventEndBackupJob\n"); elif event == bEventType['bEventEndFileSet']: DebugMessage(context, 100, "handle_plugin_event called with bEventEndFileSet\n"); else: DebugMessage(context, 100, "handle_plugin_event called with event" + str(event) + "\n"); return bRCs['bRC_OK']; def start_backup_file(self,context, savepkt): DebugMessage(context, 100, "start_backup called\n"); # Base method, we do not add anything, overload this method with your implementation to add files to backup fileset return bRCs['bRC_Skip']; def end_backup_file(self, context): DebugMessage(context, 100, "end_backup_file() entry point in Python called\n") return bRCs['bRC_OK']; def start_restore_file(self, context, cmd): DebugMessage(context, 100, "start_restore_file() entry point in Python called with" + str(cmd) + "\n") return bRCs['bRC_OK']; def end_restore_file(self,context): DebugMessage(context, 100, "end_restore_file() entry point in Python called\n") return bRCs['bRC_OK']; def restore_object_data(self, context, ROP): DebugMessage(context, 100, "restore_object_data called with " + str(ROP) + "\n"); return bRCs['bRC_OK']; def create_file(self,context, restorepkt): DebugMessage(context, 100, "create_file() entry point in Python called with" + str(restorepkt) + "\n") restorepkt.create_status = bCFs['CF_EXTRACT']; return bRCs['bRC_OK']; def check_file(self,context, fname): DebugMessage(context, 100, "check_file() entry point in Python called with" + str(fname) + "\n") return bRCs['bRC_OK']; def handle_backup_file(self,context, savepkt): DebugMessage(context, 100, "handle_backup_file called with " + str(savepkt) + "\n"); return bRCs['bRC_OK']; # vim: ts=4 tabstop=4 expandtab shiftwidth=4 softtabstop=4

agpl-3.0

juanka1331/VAN-applied-to-Nifti-images

final_scripts/tests_over_3dmask_generator.py

1

1589

import sys import os from lib.data_loader import utils_mask3d sys.path.append(os.path.dirname(os.getcwd())) from lib.utils import output_utils from lib.data_loader import mri_atlas from lib.data_loader import pet_atlas from lib.data_loader import PET_stack_NORAD from lib.data_loader import MRI_stack_NORAD from lib.utils.os_aux import create_directories import settings region = 75 #images = "MRI" images = "PET" path_folder3D = os.path.join(settings.path_to_project, "folder3D") path_folder_masks3d = os.path.join(path_folder3D, "masks3D") path_mask = os.path.join( path_folder_masks3d, "{1}_region:{0}".format(region, images)) create_directories([path_folder3D, path_folder_masks3d]) atlas = None reshape_kind = None colour_kind = None stack_dict = None if images == "MRI": stack_dict = MRI_stack_NORAD.get_gm_stack() reshape_kind = "A" colour_kind = "Greys" atlas = mri_atlas.load_atlas_mri() elif images == "PET": stack_dict = PET_stack_NORAD.get_full_stack() reshape_kind = "F" colour_kind = "jet" total_size = stack_dict['total_size'] imgsize = stack_dict['imgsize'] voxels_index = stack_dict['voxel_index'] map_region_voxels = atlas[region] # index refered to nbground voxels no_bg_region_voxels_index = voxels_index[map_region_voxels] mask3d = utils_mask3d.generate_region_3dmaskatlas( no_bg_region_voxels_index=no_bg_region_voxels_index, reshape_kind=reshape_kind, imgsize=imgsize, totalsize=total_size) output_utils.from_3d_image_to_nifti_file( path_to_save=path_mask, image3d=mask3d)

gpl-2.0

stevenwudi/Kernelized_Correlation_Filter

CNN_training.py

1

3640

import numpy as np from keras.optimizers import SGD from models.CNN_CIFAR import cnn_cifar_batchnormalisation, cnn_cifar_small, cnn_cifar_nodropout, \ cnn_cifar_small_batchnormalisation from models.DataLoader import DataLoader from scripts.progress_bar import printProgress from time import time, localtime # this is a predefined dataloader loader = DataLoader(batch_size=32) # construct the model here (pre-defined model) model = cnn_cifar_small_batchnormalisation(loader.image_shape) print(model.name) nb_epoch = 200 early_stopping = True early_stopping_count = 0 early_stopping_wait = 3 train_loss = [] valid_loss = [] learning_rate = [0.0001, 0.001, 0.01] # let's train the model using SGD + momentum (how original). sgd = SGD(lr=learning_rate[-1], decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='mean_squared_error', optimizer=sgd) # load validation data from the h5py file (heavy lifting here) x_valid, y_valid = loader.get_valid() best_valid = np.inf for e in range(nb_epoch): print("epoch %d" % e) loss_list = [] time_list = [] time_start = time() for i in range(loader.n_iter_train): time_start_batch = time() X_batch, Y_batch = loader.next_train_batch() loss_list.append(model.train_on_batch(X_batch, Y_batch)) # calculate some time information time_list.append(time() - time_start_batch) eta = (loader.n_iter_train - i) * np.array(time_list).mean() printProgress(i, loader.n_iter_train-1, prefix='Progress:', suffix='batch error: %0.5f, ETA: %0.2f sec.'%(np.array(loss_list).mean(), eta), barLength=50) printProgress(i, loader.n_iter_train - 1, prefix='Progress:', suffix='batch error: %0.5f' % (np.array(loss_list).mean()), barLength=50) train_loss.append(np.asarray(loss_list).mean()) print('training loss is %f, one epoch uses: %0.2f sec' % (train_loss[-1], time() - time_start)) valid_loss.append(model.evaluate(x_valid, y_valid)) print('valid loss is %f' % valid_loss[-1]) if best_valid > valid_loss[-1]: early_stopping_count = 0 print('saving best valid result...') best_valid = valid_loss[-1] model.save('./models/CNN_Model_OBT100_multi_cnn_best_valid_'+model.name+'.h5') else: # we wait for early stopping loop until a certain time early_stopping_count += 1 if early_stopping_count > early_stopping_wait: early_stopping_count = 0 if len(learning_rate) > 1: learning_rate.pop() print('decreasing the learning rate to: %f'%learning_rate[-1]) model.optimizer.lr.set_value(learning_rate[-1]) else: break lt = localtime() lt_str = str(lt.tm_year)+"."+str(lt.tm_mon).zfill(2)+"." \ +str(lt.tm_mday).zfill(2)+"."+str(lt.tm_hour).zfill(2)+"."\ +str(lt.tm_min).zfill(2)+"."+str(lt.tm_sec).zfill(2) np.savetxt('./models/train_loss_'+model.name+'_'+lt_str+'.txt', train_loss) np.savetxt('./models/valid_loss_'+model.name+'_'+lt_str+'.txt', valid_loss) model.save('./models/CNN_Model_OBT100_multi_cnn_'+model.name+'_final.h5') print("done") #### we show some visualisation here import matplotlib.pyplot as plt import matplotlib.patches as mpatches train_loss = np.loadtxt('./models/train_loss_'+model.name+'_'+lt_str+'.txt') valid_loss = np.loadtxt('./models/valid_loss_'+model.name+'_'+lt_str+'.txt') plt.plot(train_loss, 'b') plt.plot(valid_loss, 'r') blue_label = mpatches.Patch(color='blue', label='train_loss') red_label = mpatches.Patch(color='red', label='valid_loss') plt.legend(handles=[blue_label, red_label])

gpl-3.0

Cubitect/ASMModSuit

ASMVillageMarker.py

1

5318

import SRenderLib from asmutils import * def create_mod(util): print '\nSearching for mappings for ASMVillageMarker...' SRenderLib.setup_lib(util) lines = util.readj('World') pos = findOps(lines,0,[['.field','protected',';'],['.field','protected','Z'],['.field','protected',';'],['.field','protected',';']]) util.setmap('VillageCollection',betweenr(lines[pos],'L',';')) util.setmap('World.villageCollectionObj',endw(lines[pos],2)) pos = findOps(lines,pos+1,[['.method','public','()L'+util.getmap('VillageCollection')]]) if pos is not None: util.setmap('World.getVillageCollection',endw(lines[pos],3)) lines = util.readj('VillageCollection') pos = findOps(lines,0,[['.method','public','()Ljava/util/List']]) util.setmap('VillageCollection.getVillageList',endw(lines[pos],3)) pos = findOps(lines,pos+1,[['.method','public',')L']]) util.setmap('Village',betweenr(lines[pos],')L',';')) lines = util.readj('Village') pos = findOps(lines,0,[['.method','public','()L']]) util.setmap('Village.getCenter',endw(lines[pos],3)) util.setmap('BlockPos',betweenr(lines[pos],')L',';')) pos = findOps(lines,pos+1,[['.method','public','()I']]) util.setmap('Village.getVillageRadius',endw(lines[pos],3)) pos = findOps(lines,pos+1,[['.method','public','()Ljava/util/List']]) util.setmap('Village.getVillageDoorInfoList',endw(lines[pos],3)) pos = findOps(lines,pos+1,[['.method','public',')L']]) util.setmap('VillageDoorInfo',betweenr(lines[pos],')L',';')) lines = util.readj('VillageDoorInfo') pos = findOps(lines,0,[['.method','public','()L']]) util.setmap('VillageDoorInfo.getDoorBlockPos',endw(lines[pos],3)) lines = util.readj('BlockPos') pos = findOps(lines,0,[['.super']]) util.setmap('Vec3i',endw(lines[pos],1)) lines = util.readj('Vec3i') pos = findOps(lines,0, [['.method','public','()I'],['stack 1 locals 1']]) util.setmap('Vec3i.getX',endw(lines[pos-1],3)) pos = findOps(lines,pos+1,[['.method','public','()I'],['stack 1 locals 1']]) util.setmap('Vec3i.getY',endw(lines[pos-1],3)) pos = findOps(lines,pos+1,[['.method','public','()I'],['stack 1 locals 1']]) util.setmap('Vec3i.getZ',endw(lines[pos-1],3)) print 'Applying ASMVillageMarker patch...' util.setmap('ASMVillageMarker','villagemarker/ASMVillageMarker') lines = util.readt('ASMVillageMarker') lines = '\1'.join(lines) lines = lines.replace('net/minecraft/server/integrated/IntegratedServer', util.getmap('IntegratedServer')) lines = lines.replace('net/minecraft/client/entity/EntityPlayerSP', util.getmap('EntityPlayerSP')) lines = lines.replace('net/minecraft/client/Minecraft', util.getmap('Minecraft')) lines = lines.replace('net/minecraft/world/WorldServer', util.getmap('WorldServer')) lines = lines.replace('net/minecraft/util/math/BlockPos', util.getmap('BlockPos')) lines = lines.replace('net/minecraft/village/VillageCollection', util.getmap('VillageCollection')) lines = lines.replace('net/minecraft/village/VillageDoorInfo', util.getmap('VillageDoorInfo')) lines = lines.replace('net/minecraft/village/Village', util.getmap('Village')) lines = lines.replace('thePlayer', util.getmap('Minecraft.thePlayer')) lines = lines.replace('dimension', util.getmap('Entity.dimension')) lines = lines.replace('isSingleplayer', util.getmap('Minecraft.isSingleplayer')) lines = lines.replace('worldServerForDimension', util.getmap('MinecraftServer.worldServerForDimension')) lines = lines.replace('getVillageDoorInfoList', util.getmap('Village.getVillageDoorInfoList')) lines = lines.replace('getVillageCollection', util.getmap('World.getVillageCollection')) lines = lines.replace('getVillageRadius', util.getmap('Village.getVillageRadius')) lines = lines.replace('getVillageList', util.getmap('VillageCollection.getVillageList')) lines = lines.replace('getDoorBlockPos', util.getmap('VillageDoorInfo.getDoorBlockPos')) lines = lines.replace('getIntegratedServer', util.getmap('Minecraft.getIntegratedServer')) lines = lines.replace('getMinecraft', util.getmap('Minecraft.getMinecraft')) lines = lines.replace('getCenter', util.getmap('Village.getCenter')) lines = lines.replace('getX', util.getmap('Vec3i.getX')) lines = lines.replace('getY', util.getmap('Vec3i.getY')) lines = lines.replace('getZ', util.getmap('Vec3i.getZ')) lines = lines.split('\1') util.write2mod('ASMVillageMarker',lines) print 'Injecting render call...' lines = util.readj('EntityRenderer') pos = 0 while True: pos = findOps(lines,pos+1,[['ldc','culling']]) if pos is None: break pos = findOps(lines,pos+1,[['dload'],['dload'],['dload']]) playerX = endw(lines[pos-2],1) playerY = endw(lines[pos-1],1) playerZ = endw(lines[pos ],1) pos = findOps(lines,pos+1,[['ldc','aboveClouds']]) pos = goBackTo(lines,pos,['invokevirtual']) lines.insert(pos+1,'dload '+playerX+'\n') lines.insert(pos+2,'dload '+playerY+'\n') lines.insert(pos+3,'dload '+playerZ+'\n') lines.insert(pos+4,'invokestatic Method '+util.getmap('ASMVillageMarker')+' render (DDD)V\n') util.write2mod('EntityRenderer',lines)

gpl-3.0

shadowmint/nwidget

lib/cocos2d-0.5.5/test/test_menu_items.py

1

2268

# This code is so you can run the samples without installing the package import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..')) # testinfo = "s, q" tags = "menu items, ToggleMenuItem, MultipleMenuItem, MenuItem, EntryMenuItem, ImageMenuItem, ColorMenuItem" from pyglet import image from pyglet.gl import * from pyglet import font from cocos.director import * from cocos.menu import * from cocos.scene import * from cocos.layer import * from operator import setslice def printf(*args): sys.stdout.write(''.join([str(x) for x in args])+'\n') class MainMenu(Menu): def __init__( self ): super( MainMenu, self ).__init__("Test Menu Items") # then add the items item1= ToggleMenuItem('ToggleMenuItem: ', self.on_toggle_callback, True ) resolutions = ['320x200','640x480','800x600', '1024x768', '1200x1024'] item2= MultipleMenuItem('MultipleMenuItem: ', self.on_multiple_callback, resolutions) item3 = MenuItem('MenuItem', self.on_callback ) item4 = EntryMenuItem('EntryMenuItem:', self.on_entry_callback, 'value', max_length=8) item5 = ImageMenuItem('imagemenuitem.png', self.on_image_callback) colors = [(255, 255, 255), (129, 255, 100), (50, 50, 100), (255, 200, 150)] item6 = ColorMenuItem('ColorMenuItem:', self.on_color_callback, colors) self.create_menu( [item1,item2,item3,item4,item5,item6] ) def on_quit( self ): pyglet.app.exit() def on_multiple_callback(self, idx ): print 'multiple item callback', idx def on_toggle_callback(self, b ): print 'toggle item callback', b def on_callback(self ): print 'item callback' def on_entry_callback (self, value): print 'entry item callback', value def on_image_callback (self): print 'image item callback' def on_color_callback(self, value): print 'color item callback:', value def main(): pyglet.font.add_directory('.') director.init( resizable=True) director.run( Scene( MainMenu() ) ) if __name__ == '__main__': main()

apache-2.0

jpwhite3/python-whirlwind-tour

examples/lab4.py

1

1539

from __future__ import print_function import sys import re import glob import argparse def eprint(*args, **kwargs): # Print to STDERR instead of STDOUT print(*args, file=sys.stderr, **kwargs) def grep(expression, filepath, ignorecase=False, invert=False): raw_expression = re.escape(expression) with open(filepath) as file: for line in file: # Enable case matching? if ignorecase: matches = re.search(raw_expression, line, re.I) else: matches = re.search(raw_expression, line) # Invert matches if need be and print if matches and not invert: print(line) elif invert and not matches: print(line) def main(): parser = argparse.ArgumentParser(description='This is a pure Python based clone of the GREP command') parser.add_argument('expression', action="store", type=str, help="Regular expression to match against") parser.add_argument('filepath', action="store", type=str, help="Path to file to search in. supports wildcard globs") parser.add_argument('-i', action="store_true", default=False, dest="ignorecase", help="Ignore case") parser.add_argument('-v', action="store_true", default=False, dest="invert", help="Show lines that don't match") args = parser.parse_args() file_list = glob.glob(args.filepath) for f in file_list: if len(file_list) > 1: eprint("\nResults for file: %s" % f) eprint("-"*(len(f)+18)) grep(args.expression, f, ignorecase=args.ignorecase, invert=args.invert) if __name__ == '__main__': main()

cc0-1.0

bcarr092/pyCovertAudio

src/pyCovertAudio/BFSKModulator.py

1

2146

from pyCovertAudio_lib import * from BaseModulator import BaseModulator from SignalFunctions import SignalFunctions class BFSKModulator(BaseModulator): def __init__( self, bitsPerSymbol, sampleRate, samplesPerSymbol, symbolExpansionFactor, separationIntervals, configuration ): BaseModulator.__init__( self, bitsPerSymbol, sampleRate, samplesPerSymbol, symbolExpansionFactor, separationIntervals, configuration ) ( self.symbol0Frequency, self.symbol1Frequency, self.deltaFrequency, self.bandwidth ) = \ python_BFSK_determine_frequencies( self.samplesPerSymbol, self.sampleRate, self.carrierFrequency, self.separationIntervals ) def modulate(self, symbolSequence, signal, sentinel=None): symbolSignalLength = self.samplesPerSymbol * self.symbolExpansionFactor for symbol in symbolSequence: symbolFrequency = self.carrierFrequency if(symbol == 1): symbolFrequency += self.symbol1Frequency else: symbolFrequency += self.symbol0Frequency x = \ SignalFunctions.modulateFSK( symbolSignalLength, self.sampleRate, [symbolFrequency] ) signal.extend(x[: self.samplesPerSymbol]) signal.extend( [0.0 for i in range( (self.symbolExpansionFactor - 1) * self.samplesPerSymbol)] ) def toString(self): return ( "Modulator:\n\tAlgorithm:\t\t\tBFSK\n\tSymbol 0 frequency:\t\t" "%.02f\n\tSymbol 1 frequency:\t\t%.02f\n\tMin frequency" " separation:\t%.02f\n\tBandwidth:\t\t\t%.02f\n%s" % ( self.symbol0Frequency, self.symbol1Frequency, self.deltaFrequency, self.bandwidth, BaseModulator.toString(self) ) )

apache-2.0

dhhagan/PAM

Python/PAM.py

1

5037

#PAM.py import re import glob, os, time from numpy import * from pylab import * def analyzeFile(fileName,delim): cols = {} indexToName = {} lineNum = 0 goodLines = 0 shortLines = 0 FILE = open(fileName,'r') for line in FILE: line = line.strip() if lineNum < 1: lineNum += 1 continue elif lineNum == 1: headings = line.split(delim) i = 0 for heading in headings: heading = heading.strip() cols[heading] = [] indexToName[i] = heading i += 1 lineNum += 1 lineLength = len(cols) else: data = line.split(delim) if len(data) == lineLength: goodLines += 1 i = 0 for point in data: point = point.strip() cols[indexToName[i]] += [point] i += 1 lineNum += 1 else: shortLines += 1 lineNum += 1 continue FILE.close return cols, indexToName, lineNum, shortLines def numericalSort(value): numbers = re.compile(r'(\d+)') parts = numbers.split(value) parts[1::2] = map(int, parts[1::2]) return parts def popDate(fileName): run = fileName.split('.')[0] runNo = run.split('_')[-1] return runNo def getFile(date,regex):#Works files = [] files = sorted((glob.glob('*'+regex+'*')),key=numericalSort,reverse=False) if date.lower() == 'last': files = files.pop() else: files = [item for item in files if re.search(date,item)] return files def plotConc(data,ozone,times): # This function plots data versus time import datetime as dt from matplotlib import pyplot as plt from matplotlib.dates import date2num #time = [dt.datetime.strptime(time,"%m/%d/%Y %I:%M:%S %p") for time in times] time = [dt.datetime.strptime(time,"%m/%d/%Y %I:%M:%S %p") for time in times] x = date2num(time) legend1 = [] legend2 = [] fig = plt.figure('Gas Concentration Readings for East St.Louis') ax1 = fig.add_subplot(111) ax2 = twinx() for key,value in data.items(): ax1.plot_date(x,data[key],'-',xdate=True) legend1.append(key) for key, value in ozone.items(): ax2.plot_date(x,ozone[key],'-.',xdate=True) legend2.append(key) title('Gas Concentrations for East St. Louis', fontsize = 12) ax1.set_ylabel(r'$Concentration(ppb)$', fontsize = 12) ax2.set_ylabel(r'$Concentration(ppb)$', fontsize = 12) xlabel(r"$Time \, Stamp$", fontsize = 12) ax1.legend(legend1,loc='upper right') ax2.legend(legend2,loc='lower right') grid(True) return def plotBankRelays(data,relays,times): # This function plots data versus time import datetime as dt from matplotlib import pyplot as plt from matplotlib.dates import date2num time = [dt.datetime.strptime(time,"%m/%d/%Y %I:%M:%S %p") for time in times] x = date2num(time) #x1 = [date.strftime("%m-%d %H:%M:%S") for date in time] legend1 = [] legend2 = [] #plt.locator_params(axis='x', nbins=4) fig = plt.figure('VAPS Thermocouple Readings: Chart 2') ax1 = fig.add_subplot(111) ax2 = twinx() for key,value in data.items(): ax1.plot_date(x,data[key],'-',xdate=True) legend1.append(key) for key,value in relays.items(): ax2.plot_date(x,relays[key],'--',xdate=True) legend2.append(key) title('VAPS Temperatures: Chart 2', fontsize = 12) ax1.set_ylabel(r'$Temperature(^oC)$', fontsize = 12) ax2.set_ylabel(r'$Relay \, States$', fontsize = 12) ax1.set_xlabel(r"$Time \, Stamp$", fontsize = 12) #print [num2date(item) for item in ax1.get_xticks()] #ax1.set_xticks(x) #ax1.set_xticklabels([date.strftime("%m-%d %H:%M %p") for date in time]) #ax1.legend(bbox_to_anchor=(0.,1.02,1.,.102),loc=3,ncol=2,mode="expand",borderaxespad=0.) ax1.legend(legend1,loc='upper right') ax2.legend(legend2,loc='lower right') #ax1.xaxis.set_major_formatter(FormatStrFormatter(date.strftime("%m-%d %H:%M:%S"))) plt.subplots_adjust(bottom=0.15) grid(True) return def goodFiles(files,goodHeaders,delim): # Good irregFiles = 0 goodFiles = [] for file in files: lineNo = 0 falseCount = 0 FILE = open(file,'r') for line in FILE: line = line.strip() if lineNo == 5: # Check all the headings to make sure the file is good head = line.split(delim) for item in head: if item in goodHeaders: continue else: falseCount += 1 if falseCount == 0: goodFiles.append(file) else: irregFiles += 1 lineNo += 1 else: lineNo += 1 continue FILE.close return goodFiles, irregFiles

mit

ypid/series60-remote

pc/lib/log.py

1

1490

# -*- coding: utf-8 -*- # Copyright (c) 2008 - 2009 Lukas Hetzenecker <LuHe@gmx.at> from PyQt4.QtCore import * from PyQt4.QtGui import * import logging class QtStreamHandler(logging.Handler): def __init__(self, parent, main): logging.Handler.__init__(self) self.parent = parent self.main = main self.textWidget = parent self.formater = logging.Formatter("%(message)s") def setFormatter(self, format): self.formater = format def createLock(self): self.mutex = QMutex() def acquire(self): self.mutex.lock() def release(self): self.mutex.unlock() def emit(self,record): self.textWidget.appendPlainText(self.formater.format(record)) self.textWidget.moveCursor(QTextCursor.StartOfLine) self.textWidget.ensureCursorVisible() class QtOutput(object): def __init__(self, parent, out=None, color=None): self.textWidget = parent self.out = out self.color = color def write(self, m): self.textWidget.moveCursor(QTextCursor.End) if self.color: tc = self.textWidget.textColor() self.textWidget.setTextColor(self.color) self.textWidget.insertPlainText( m ) if self.color: self.textWidget.setTextColor(tc) if self.out: if isinstance(m, unicode): self.out.write(m.encode("utf8")) else: self.out.write(m)

gpl-2.0

virt-who/virt-who

virtwho/manager/subscriptionmanager/subscriptionmanager.py

1

16260

# -*- coding: utf-8 -*- from __future__ import print_function """ Module for communication with subscription-manager, part of virt-who Copyright (C) 2011 Radek Novacek <rnovacek@redhat.com> This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ import os import json from six.moves.http_client import BadStatusLine from six import string_types import rhsm.connection as rhsm_connection import rhsm.certificate as rhsm_certificate import rhsm.config as rhsm_config from virtwho.config import NotSetSentinel from virtwho.manager import Manager, ManagerError, ManagerFatalError, ManagerThrottleError from virtwho.virt import AbstractVirtReport from virtwho.util import generate_correlation_id class SubscriptionManagerError(ManagerError): pass class SubscriptionManagerUnregisteredError(ManagerFatalError): pass # Mapping between strings returned from getJob and report statuses STATE_MAPPING = { 'FINISHED': AbstractVirtReport.STATE_FINISHED, 'CANCELED': AbstractVirtReport.STATE_CANCELED, 'FAILED': AbstractVirtReport.STATE_FAILED, 'RUNNING': AbstractVirtReport.STATE_PROCESSING, 'WAITING': AbstractVirtReport.STATE_PROCESSING, 'CREATED': AbstractVirtReport.STATE_PROCESSING, } class NamedOptions(object): """ Object used for compatibility with RHSM """ pass class SubscriptionManager(Manager): sm_type = "sam" """ Class for interacting subscription-manager. """ def __init__(self, logger, options): self.logger = logger self.options = options self.cert_uuid = None self.rhsm_config = None self.cert_file = None self.key_file = None self.readConfig() self.connection = None self.correlation_id = generate_correlation_id() def readConfig(self): """ Parse rhsm.conf in order to obtain consumer certificate and key paths. """ self.rhsm_config = rhsm_config.initConfig( rhsm_config.DEFAULT_CONFIG_PATH) consumer_cert_dir = self.rhsm_config.get("rhsm", "consumerCertDir") cert = 'cert.pem' key = 'key.pem' self.cert_file = os.path.join(consumer_cert_dir, cert) self.key_file = os.path.join(consumer_cert_dir, key) def _check_owner_lib(self, kwargs, config): """ Try to check values of env and owner. These values has to be equal to values obtained from Satellite server. :param kwargs: dictionary possibly containing valid username and password used for connection to rhsm :param config: Configuration of virt-who :return: None """ if config is None: return # Check 'owner' and 'env' only in situation, when these values # are set and rhsm_username and rhsm_password are not set if 'username' not in kwargs and 'password' not in kwargs and \ 'owner' in config.keys() and 'env' in config.keys(): pass else: return uuid = self.uuid() consumer = self.connection.getConsumer(uuid) if 'environment' in consumer: environment = consumer['environment'] else: return if environment: environment_name = environment['name'] owner = self.connection.getOwner(uuid) owner_id = owner['key'] if config['owner'] != owner_id: raise ManagerError( "Cannot send data to: %s, because owner from configuration: %s is different" % (owner_id, config['owner']) ) if config['env'] != environment_name: raise ManagerError( "Cannot send data to: %s, because Satellite env: %s differs from configuration: %s" % (owner_id, environment_name, config['env']) ) def _connect(self, config=None): """ Connect to the subscription-manager. """ kwargs = { 'host': self.rhsm_config.get('server', 'hostname'), 'ssl_port': int(self.rhsm_config.get('server', 'port')), 'handler': self.rhsm_config.get('server', 'prefix'), 'proxy_hostname': self.rhsm_config.get('server', 'proxy_hostname'), 'proxy_port': self.rhsm_config.get('server', 'proxy_port'), 'proxy_user': self.rhsm_config.get('server', 'proxy_user'), 'proxy_password': self.rhsm_config.get('server', 'proxy_password'), 'insecure': self.rhsm_config.get('server', 'insecure') } kwargs_to_config = { 'host': 'rhsm_hostname', 'ssl_port': 'rhsm_port', 'handler': 'rhsm_prefix', 'proxy_hostname': 'rhsm_proxy_hostname', 'proxy_port': 'rhsm_proxy_port', 'proxy_user': 'rhsm_proxy_user', 'proxy_password': 'rhsm_proxy_password', 'insecure': 'rhsm_insecure' } rhsm_username = None rhsm_password = None if config: try: rhsm_username = config['rhsm_username'] rhsm_password = config['rhsm_password'] except KeyError: pass if rhsm_username == NotSetSentinel: rhsm_username = None if rhsm_password == NotSetSentinel: rhsm_password = None # Testing for None is necessary, it might be an empty string for key, value in kwargs.items(): try: from_config = config[kwargs_to_config[key]] if from_config is not NotSetSentinel and from_config is \ not None: if key is 'ssl_port': from_config = int(from_config) kwargs[key] = from_config except KeyError: continue if rhsm_username and rhsm_password: self.logger.debug("Authenticating with RHSM username %s", rhsm_username) kwargs['username'] = rhsm_username kwargs['password'] = rhsm_password else: self.logger.debug("Authenticating with certificate: %s", self.cert_file) if not os.access(self.cert_file, os.R_OK): raise SubscriptionManagerUnregisteredError( "Unable to read certificate, system is not registered or you are not root") kwargs['cert_file'] = self.cert_file kwargs['key_file'] = self.key_file self.logger.info("X-Correlation-ID: %s", self.correlation_id) if self.correlation_id: kwargs['correlation_id'] = self.correlation_id self.connection = rhsm_connection.UEPConnection(**kwargs) try: if not self.connection.ping()['result']: raise SubscriptionManagerError( "Unable to obtain status from server, UEPConnection is likely not usable." ) except rhsm_connection.RateLimitExceededException as e: raise ManagerThrottleError(e.retry_after) except BadStatusLine: raise ManagerError("Communication with subscription manager interrupted") self._check_owner_lib(kwargs, config) return self.connection def sendVirtGuests(self, report, options=None): """ Update consumer facts with info about virtual guests. `guests` is a list of `Guest` instances (or it children). """ guests = report.guests self._connect() # Sort the list guests.sort(key=lambda item: item.uuid) serialized_guests = [guest.toDict() for guest in guests] self.logger.info('Sending update in guests lists for config ' '"%s": %d guests found', report.config.name, len(guests)) self.logger.debug("Domain info: %s", json.dumps(serialized_guests, indent=4)) # Send list of guest uuids to the server try: self.connection.updateConsumer(self.uuid(), guest_uuids=serialized_guests, hypervisor_id=report.hypervisor_id) except rhsm_connection.GoneException: raise ManagerError("Communication with subscription manager failed: consumer no longer exists") except rhsm_connection.RateLimitExceededException as e: raise ManagerThrottleError(e.retry_after) report.state = AbstractVirtReport.STATE_FINISHED def hypervisorCheckIn(self, report, options=None): """ Send hosts to guests mapping to subscription manager. """ connection = self._connect(report.config) is_async = self._is_rhsm_server_async(report, connection) serialized_mapping = self._hypervisor_mapping(report, is_async, connection) self.logger.debug("Host-to-guest mapping being sent to '{owner}': {mapping}".format( owner=report.config['owner'], mapping=json.dumps(serialized_mapping, indent=4))) # All subclasses of ConfigSection use dictionary like notation, # but RHSM uses attribute like notation if options: named_options = NamedOptions() for key, value in options['global'].items(): setattr(named_options, key, value) else: named_options = None try: try: result = self.connection.hypervisorCheckIn( report.config['owner'], report.config['env'], serialized_mapping, options=named_options) # pylint:disable=unexpected-keyword-arg except TypeError: # This is temporary workaround until the options parameter gets implemented # in python-rhsm self.logger.debug( "hypervisorCheckIn method in python-rhsm doesn't understand options parameter, ignoring" ) result = self.connection.hypervisorCheckIn(report.config['owner'], report.config['env'], serialized_mapping) except BadStatusLine: raise ManagerError("Communication with subscription manager interrupted") except rhsm_connection.RateLimitExceededException as e: raise ManagerThrottleError(e.retry_after) except rhsm_connection.GoneException: raise ManagerError("Communication with subscription manager failed: consumer no longer exists") except rhsm_connection.ConnectionException as e: if hasattr(e, 'code'): raise ManagerError("Communication with subscription manager failed with code %d: %s" % (e.code, str(e))) raise ManagerError("Communication with subscription manager failed: %s" % str(e)) if is_async is True: report.state = AbstractVirtReport.STATE_CREATED report.job_id = result['id'] else: report.state = AbstractVirtReport.STATE_FINISHED return result def _is_rhsm_server_async(self, report, connection=None): """ Check if server has capability 'hypervisor_async'. """ if connection is None: self._connect(report.config) self.logger.debug("Checking if server has capability 'hypervisor_async'") is_async = hasattr(self.connection, 'has_capability') and self.connection.has_capability('hypervisors_async') if is_async: self.logger.debug("Server has capability 'hypervisors_async'") else: self.logger.debug("Server does not have 'hypervisors_async' capability") return is_async def _hypervisor_mapping(self, report, is_async, connection=None): """ Return mapping of hypervisor """ if connection is None: self._connect(report.config) mapping = report.association serialized_mapping = {} ids_seen = [] if is_async: hosts = [] # Transform the mapping into the async version for hypervisor in mapping['hypervisors']: if hypervisor.hypervisorId in ids_seen: self.logger.warning("The hypervisor id '%s' is assigned to 2 different systems. " "Only one will be recorded at the server." % hypervisor.hypervisorId) hosts.append(hypervisor.toDict()) ids_seen.append(hypervisor.hypervisorId) serialized_mapping = {'hypervisors': hosts} else: # Reformat the data from the mapping to make it fit with # the old api. for hypervisor in mapping['hypervisors']: if hypervisor.hypervisorId in ids_seen: self.logger.warning("The hypervisor id '%s' is assigned to 2 different systems. " "Only one will be recorded at the server." % hypervisor.hypervisorId) guests = [g.toDict() for g in hypervisor.guestIds] serialized_mapping[hypervisor.hypervisorId] = guests ids_seen.append(hypervisor.hypervisorId) return serialized_mapping def check_report_state(self, report): # BZ 1554228 job_id = str(report.job_id) self._connect(report.config) self.logger.debug('Checking status of job %s', job_id) try: result = self.connection.getJob(job_id) except BadStatusLine: raise ManagerError("Communication with subscription manager interrupted") except rhsm_connection.RateLimitExceededException as e: raise ManagerThrottleError(e.retry_after) except rhsm_connection.ConnectionException as e: if hasattr(e, 'code'): raise ManagerError("Communication with subscription manager failed with code %d: %s" % (e.code, str(e))) raise ManagerError("Communication with subscription manager failed: %s" % str(e)) state = STATE_MAPPING.get(result['state'], AbstractVirtReport.STATE_FAILED) report.state = state if state not in (AbstractVirtReport.STATE_FINISHED, AbstractVirtReport.STATE_CANCELED, AbstractVirtReport.STATE_FAILED): self.logger.debug('Job %s not finished', job_id) else: # log completed job status result_data = result.get('resultData', {}) if not result_data: self.logger.warning("Job status report without resultData: %s", result) return if isinstance(result_data, string_types): self.logger.warning("Job status report encountered the following error: %s", result_data) return for fail in result_data.get('failedUpdate', []): self.logger.error("Error during update list of guests: %s", str(fail)) self.logger.debug("Number of mappings unchanged: %d", len(result_data.get('unchanged', []))) self.logger.info("Mapping for config \"%s\" updated", report.config.name) def uuid(self): """ Read consumer certificate and get consumer UUID from it. """ if not self.cert_uuid: try: certificate = rhsm_certificate.create_from_file(self.cert_file) self.cert_uuid = certificate.subject["CN"] except Exception as e: raise SubscriptionManagerError("Unable to open certificate %s (%s):" % (self.cert_file, str(e))) return self.cert_uuid

gpl-2.0

kata198/usrsvc

usrsvcmod/Monitoring/ActivityFile.py

1

3670

''' Copyright (c) 2016 Tim Savannah All Rights Reserved. This software is licensed under the terms of the GPLv3. This may change at my discretion, retroactively, and without notice. You should have received a copy of this with the source distribution as a file titled, LICENSE. The most current license can be found at: https://github.com/kata198/usrsvc/LICENSE This location may need to be changed at some point in the future, in which case you are may email Tim Savannah <kata198 at gmail dot com>, or find them on the current website intended for distribution of usrsvc. ActivityFileMonitor - Asserts that a specific file or directory should be modified within a certain threshold ''' # vim:set ts=4 shiftwidth=4 softtabstop=4 expandtab : import os import time from func_timeout import FunctionTimedOut from . import MonitoringBase from ..logging import logMsg, logErr # TODO: We need to implement the check here as launching and joining on a thread, so that we don't lockup all monitoring if someone # uses an NFS file on a disconnected device or anything else that will result in an indefinite uninterruptable ("D") state. class ActivityFileMonitor(MonitoringBase): ''' ActivityFileMonitor - Class for doing activity file monitoring ''' def __init__(self, programName, activityFile, activityFileLimit): MonitoringBase.__init__(self) self.programName = programName self.activityFile = activityFile self.activityFileLimit = activityFileLimit @classmethod def createFromConfig(cls, programConfig): if not programConfig.Monitoring.activityfile: return None return cls(programConfig.name, programConfig.Monitoring.activityfile, programConfig.Monitoring.activityfile_limit) def shouldRestart(self, program=None): ''' Returns True if activity file has not been modified within the threshold specified by activityfile_limit (should restart), otherwise False. @param program - unused. ''' activityFile = self.activityFile activityFileLimit = self.activityFileLimit programName = self.programName if not activityFile: # Yes this is checked twice if created through createFromConfig, but it may be called otherwise so better safe. return False try: # If activity file is not present, this is a fail and we restart. if not os.path.exists(activityFile): self.setReason('Restarting %s because activity file ( %s ) does not exist\n' %(programName, activityFile,)) return True # Gather the mtime and see if we are past the threshold lastModified = os.stat(activityFile).st_mtime now = time.time() threshold = float(now - self.activityFileLimit) if lastModified < threshold: self.setReason('Restarting %s because it has not modified activity file ( %s ) in %.4f seconds. Limit is %d seconds.\n' %(programName, activityFile, float(now - lastModified), activityFileLimit) ) return True except FunctionTimedOut: logErr('MONITOR: ActivityFile timed out on %s\n' %(programName,)) raise except Exception as e: # If we got an exception, just log and try again next round. logErr('Got an exception in activity file monitoring. Not restarting program. Program="%s" activityfile="%s"\nlocals: %s\n' %(programName, activityFile, str(locals()))) return False # vim:set ts=4 shiftwidth=4 softtabstop=4 expandtab :

lgpl-2.1

stefanoteso/musm-adt17

musm/pc.py

1

4018

import numpy as np import gurobipy as gurobi from .problem import Problem class PC(Problem): _ATTRIBUTES = [ ('cpu', 37), ('hd', 10), ('manufacturer', 8), ('ram', 10), ('monitor', 8), ('pctype', 3), ] _ATTR_TO_COSTS = { 'pctype': [50, 0, 80], 'manufacturer': [100, 0, 100, 50, 0, 0, 50, 50], 'cpu' : [ 1.4*100, 1.4*130, 1.1*70, 1.1*90, 1.2*80, 1.2*50, 1.2*60, 1.2*80, 1.2*90, 1.2*100, 1.2*110, 1.2*120, 1.2*130, 1.2*140, 1.2*170, 1.5*50, 1.5*60, 1.5*80, 1.5*90, 1.5*100, 1.5*110, 1.5*130, 1.5*150, 1.5*160, 1.5*170, 1.5*180, 1.5*220, 1.4*27, 1.4*30, 1.4*40, 1.4*45, 1.4*50, 1.4*55, 1.4*60, 1.4*70, 1.6*70, 1.6*73, ], 'monitor': [ 0.6*100, 0.6*104, 0.6*120, 0.6*133, 0.6*140, 0.6*150, 0.6*170, 0.6*210 ], 'ram': [ 0.8*64, 0.8*128, 0.8*160, 0.8*192, 0.8*256, 0.8*320, 0.8*384, 0.8*512, 0.8*1024, 0.8*2048 ], 'hd': [ 4*8, 4*10, 4*12, 4*15, 4*20, 4*30, 4*40, 4*60, 4*80, 4*120 ], } def __init__(self, **kwargs): super().__init__(sum(attr[1] for attr in self._ATTRIBUTES)) self.cost_matrix = np.hstack([ np.array(self._ATTR_TO_COSTS[attr], dtype=float) for attr, _ in self._ATTRIBUTES ]).reshape((1, -1)) / 2754.4 def _add_constraints(self, model, x): base, offs = 0, {} for attr, size in self._ATTRIBUTES: offs[attr] = base x_attr = [x[z] for z in range(base, base + size)] model.addConstr(gurobi.quicksum(x_attr) == 1) base += size def implies(head, body): # NOTE here we subtract 1 from head and body bits because the bit # numbers in the constraints were computed starting from one, to # work in MiniZinc, while Gurobi expects them to start from zero head = 1 - x[head - 1] body = gurobi.quicksum([x[i - 1] for i in body]) return model.addConstr(head + body >= 1) # Manufacturer -> Type implies(offs['manufacturer'] + 2, [offs['pctype'] + i for i in [1, 2]]) implies(offs['manufacturer'] + 4, [offs['pctype'] + 1]) implies(offs['manufacturer'] + 6, [offs['pctype'] + 2]) implies(offs['manufacturer'] + 7, [offs['pctype'] + i for i in [1, 3]]) # Manufacturer -> CPU implies(offs['manufacturer'] + 1, [offs['cpu'] + i for i in range(28, 37+1)]) implies(offs['manufacturer'] + 2, [offs['cpu'] + i for i in list(range(1, 4+1)) + list(range(6, 27+1))]) implies(offs['manufacturer'] + 7, [offs['cpu'] + i for i in list(range(1, 4+1)) + list(range(6, 27+1))]) implies(offs['manufacturer'] + 4, [offs['cpu'] + i for i in range(5, 27+1)]) implies(offs['manufacturer'] + 3, [offs['cpu'] + i for i in range(6, 27+1)]) implies(offs['manufacturer'] + 5, [offs['cpu'] + i for i in range(6, 27+1)]) implies(offs['manufacturer'] + 8, [offs['cpu'] + i for i in range(6, 27+1)]) implies(offs['manufacturer'] + 6, [offs['cpu'] + i for i in range(16, 27+1)]) # Type -> RAM implies(offs['pctype'] + 1, [offs['ram'] + i for i in range(1, 9+1)]) implies(offs['pctype'] + 2, [offs['ram'] + i for i in [2, 5, 8, 9]]) implies(offs['pctype'] + 3, [offs['ram'] + i for i in [5, 8, 9, 10]]) # Type -> HD implies(offs['pctype'] + 1, [offs['hd'] + i for i in range(1, 6+1)]) implies(offs['pctype'] + 2, [offs['hd'] + i for i in range(5, 10+1)]) implies(offs['pctype'] + 3, [offs['hd'] + i for i in range(5, 10+1)]) # Type -> Monitor implies(offs['pctype'] + 1, [offs['monitor'] + i for i in range(1, 6+1)]) implies(offs['pctype'] + 2, [offs['monitor'] + i for i in range(6, 8+1)]) implies(offs['pctype'] + 3, [offs['monitor'] + i for i in range(6, 8+1)])

mit

hikelee/launcher

launcher/templatetags/helpers.py

1

6201

""" sentry.templatetags.sentry_helpers ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :copyright: (c) 2010-2014 by the Sentry Team, see AUTHORS for more details. :license: BSD, see LICENSE for more details. """ from __future__ import absolute_import import functools import os.path from collections import namedtuple from datetime import timedelta import pytz import six from django import template from django.conf import settings from django.template.defaultfilters import stringfilter from django.utils import timezone from django.utils.html import escape from django.utils.safestring import mark_safe from django.utils.translation import ugettext as _ from six.moves import range from six.moves.urllib.parse import quote from launcher.utils.strings import soft_break as _soft_break,soft_hyphenate,to_unicode,truncatechars SentryVersion=namedtuple('SentryVersion',[ 'current', 'latest', 'update_available', 'build', ]) register=template.Library() truncatechars=register.filter(stringfilter(truncatechars)) truncatechars.is_safe=True @register.filter def multiply(x,y): def coerce(value): if isinstance(value,(six.integer_types,float)): return value try: return int(value) except ValueError: return float(value) return coerce(x)*coerce(y) @register.filter def pprint(value,break_after=10): """ break_after is used to define how often a <span> is inserted (for soft wrapping). """ value=to_unicode(value) return mark_safe( u'<span></span>'. join([escape(value[i:(i+break_after)]) for i in range(0,len(value),break_after)]) ) @register.filter def is_url(value): if not isinstance(value,six.string_types): return False if not value.startswith(('http://','https://')): return False if ' ' in value: return False return True # seriously Django? @register.filter def subtract(value,amount): return int(value)-int(amount) @register.filter def absolute_value(value): return abs(int(value) if isinstance(value,six.integer_types) else float(value)) @register.filter def has_charts(group): from launcher.utils.db import has_charts if hasattr(group,'_state'): db=group._state.db or 'default' else: db='default' return has_charts(db) @register.filter def as_sorted(value): return sorted(value) @register.filter def small_count(v,precision=1): if not v: return 0 z=[ (1000000000,_('b')), (1000000,_('m')), (1000,_('k')), ] v=int(v) for x,y in z: o,p=divmod(v,x) if o: if len(six.text_type(o))>2 or not p: return '%d%s'%(o,y) return ('%.{}f%s'.format(precision))%(v/float(x),y) return v @register.filter def num_digits(value): return len(six.text_type(value)) @register.filter def to_str(data): return six.text_type(data) @register.filter def is_none(value): return value is None @register.filter def timesince(value,now=None): from django.template.defaultfilters import timesince if now is None: now=timezone.now() if not value: return _('never') if value<(now-timedelta(days=5)): return value.date() value=(' '.join(timesince(value,now).split(' ')[0:2])).strip(',') if value==_('0 minutes'): return _('just now') if value==_('1 day'): return _('yesterday') return value+_(' ago') @register.filter def duration(value): if not value: return '0s' # value is assumed to be in ms value=value/1000.0 hours,minutes,seconds=0,0,0 if value>3600: hours=value/3600 value=value%3600 if value>60: minutes=value/60 value=value%60 seconds=value output=[] if hours: output.append('%dh'%hours) if minutes: output.append('%dm'%minutes) if seconds>1: output.append('%0.2fs'%seconds) elif seconds: output.append('%dms'%(seconds*1000)) return ''.join(output) @register.filter def date(dt,arg=None): from django.template.defaultfilters import date if not timezone.is_aware(dt): dt=dt.replace(tzinfo=timezone.utc) return date(dt,arg) @register.filter def trim_schema(value): return value.split('//',1)[-1] @register.filter def with_metadata(group_list,request): group_list=list(group_list) if request.user.is_authenticated() and group_list: project=group_list[0].project bookmarks=set( project.bookmark_set.filter( user=request.user, group__in=group_list, ).values_list('group_id',flat=True) ) else: bookmarks=set() # TODO(dcramer): this is obsolete and needs to pull from the tsdb backend historical_data={} for g in group_list: yield g,{ 'is_bookmarked':g.pk in bookmarks, 'historical_data':','.join(six.text_type(x[1]) for x in historical_data.get(g.id,[])), } @register.simple_tag def percent(value,total,format=None): if not (value and total): result=0 else: result=int(value)/float(total)*100 if format is None: return int(result) else: return ('%%%s'%format)%result @register.filter def titlize(value): return value.replace('_',' ').title() @register.filter def split(value,delim=''): return value.split(delim) @register.inclusion_tag('sentry/partial/github_button.html') def github_button(user,repo): return { 'user':user, 'repo':repo, } @register.filter def urlquote(value,safe=''): return quote(value.encode('utf8'),safe) @register.filter def basename(value): return os.path.basename(value) @register.filter def user_display_name(user): return user.name or user.username @register.simple_tag(takes_context=True) def localized_datetime(context,dt,format='DATETIME_FORMAT'): request=context['request'] timezone=getattr(request,'timezone',None) if not timezone: timezone=pytz.timezone(settings.SENTRY_DEFAULT_TIME_ZONE) dt=dt.astimezone(timezone) return date(dt,format) @register.filter def format_userinfo(user): parts=user.username.split('@') if len(parts)==1: username=user.username else: username=parts[0].lower() return mark_safe('<span title="%s">%s</span>'%(escape(user.username),escape(username),)) @register.filter def soft_break(value,length): return _soft_break( value, length, functools.partial(soft_hyphenate,length=max(length//10,10)), )

mit

vigneshkarthi/satireguru

satire-bot.py

1

3178

import twitter import yaml import time import pickle import re global match, api, msg, oldID import random msg = '' #RegEx for parsing twitter handle from retrived keyword = ''; #UTF_CHARS = ur'a-z0-9_\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u00ff' #TAG_EXP = ur'(^|[^0-9A-Z&/]+)(#|\uff03)([0-9A-Z_]*[A-Z_]+[%s]*)' % UTF_CHARS #TAG_REGEX = re.compile(TAG_EXP, re.UNICODE | re.IGNORECASE) #Performs OAuth authentication, place all the neccessary keys in access.yaml def authenticate(): global api data = yaml.load(open("access.yaml")) api = twitter.Api(consumer_key=data['consumer-key'],consumer_secret=data['consumer-secret'],access_token_key=data['access-key'],access_token_secret=data['access-secret']) #Parses response.yaml to search and reply with relevant messages according to twitterhandles, fill your responses in response.yaml def choose_reply(): global match, msg comments = yaml.load(open("response.yaml")) for name in comments['name']: if(name['keyword']==match): msg = random.choice(name['response']) #Module which checks for mentions and replies to the mentioner and the person mentioned #current version supports only one mentioned person def get_and_post_replies(old): cache_msg_to_post = ' ' global match, api while(1): try: i = 0 repl = api.GetMentions() total = len(repl) newID = int(repl[i].id) while(newID != old): print repl[i].text+", by @"+repl[i].user.screen_name if "pm" in repl[i].text.lower(): match = 'PM' print "Match is", match choose_reply() msg_to_post = "@"+repl[i].user.screen_name+" "+msg if(msg_to_post == cache_msg_to_post): msg_to_post = msg_to_post + random.randint(0,1000) cache_msg_to_post = msg_to_post try: api.PostUpdate(msg_to_post, in_reply_to_status_id=repl[i].id) print "Msg posted is", msg_to_post i = i+1 if (total == i): break newID = int(repl[i].id) except twitter.TwitterError: print "Something happend.. Saving ID's to file.. Not to Worry" fileObj = open("idstore",'r+') old = repl[0].id fileObj.seek(0) fileObj.write(str(old)) fileObj.close() return else: i = i + 1 if (total == i): break newId = int(repl[i].id) old = int(repl[0].id) print "No New Tweets !!" print "Gonna sleep for a minute :)" time.sleep(60) except KeyboardInterrupt: fileObj = open("idstore", 'r+') fileObj.seek(0) fileObj.write(str(old)) print "Saving ID's to file.. Exiting!!" return authenticate() fileObj = open("idstore",'r+') old = fileObj.read() old = int(old) get_and_post_replies(old)

gpl-2.0

shadowk29/cusumtools

legacy/minimal_psd.py

1

12009

## COPYRIGHT ## Copyright (C) 2015 Kyle Briggs (kbrig035<at>uottawa.ca) ## ## This file is part of cusumtools. ## ## This program is free software: you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation, either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program. If not, see <http://www.gnu.org/licenses/>. import matplotlib matplotlib.use('TkAgg') import numpy as np import tkinter.filedialog import tkinter as tk from matplotlib.figure import Figure from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg import scipy.io as sio from scipy.signal import bessel, filtfilt, welch from scikits.samplerate import resample import pylab as pl import glob import os import time import pandas as pd from pandasql import sqldf import re def make_format(current, other): # current and other are axes def format_coord(x, y): # x, y are data coordinates # convert to display coords display_coord = current.transData.transform((x,y)) inv = other.transData.inverted() # convert back to data coords with respect to ax ax_coord = inv.transform(display_coord) coords = [ax_coord, (x, y)] return ('Left: {:<40} Right: {:<}' .format(*['({:.3f}, {:.3f})'.format(x, y) for x,y in coords])) return format_coord class App(tk.Frame): def __init__(self, parent,file_path): tk.Frame.__init__(self, parent) parent.deiconify() self.events_flag = False self.baseline_flag = False self.file_path = file_path ##### Trace plotting widgets ##### self.trace_frame = tk.LabelFrame(parent,text='Current Trace') self.trace_fig = Figure(figsize=(7,5), dpi=100) self.trace_canvas = FigureCanvasTkAgg(self.trace_fig, master=self.trace_frame) self.trace_toolbar_frame = tk.Frame(self.trace_frame) self.trace_toolbar = NavigationToolbar2TkAgg(self.trace_canvas, self.trace_toolbar_frame) self.trace_toolbar.update() self.trace_frame.grid(row=0,column=0,columnspan=6,sticky=tk.N+tk.S) self.trace_toolbar_frame.grid(row=1,column=0,columnspan=6) self.trace_canvas.get_tk_widget().grid(row=0,column=0,columnspan=6) ##### PSD plotting widgets ##### self.psd_frame = tk.LabelFrame(parent,text='Power Spectrum') self.psd_fig = Figure(figsize=(7,5), dpi=100) self.psd_canvas = FigureCanvasTkAgg(self.psd_fig, master=self.psd_frame) self.psd_toolbar_frame = tk.Frame(self.psd_frame) self.psd_toolbar = NavigationToolbar2TkAgg(self.psd_canvas, self.psd_toolbar_frame) self.psd_toolbar.update() self.psd_frame.grid(row=0,column=6,columnspan=6,sticky=tk.N+tk.S) self.psd_toolbar_frame.grid(row=1,column=6,columnspan=6) self.psd_canvas.get_tk_widget().grid(row=0,column=6,columnspan=6) ##### Control widgets ##### self.control_frame = tk.LabelFrame(parent, text='Controls') self.control_frame.grid(row=2,column=0,columnspan=6,sticky=tk.N+tk.S+tk.E+tk.W) self.start_entry = tk.Entry(self.control_frame) self.start_entry.insert(0,'0') self.start_label = tk.Label(self.control_frame, text='Start Time (s)') self.start_label.grid(row=0,column=0,sticky=tk.E+tk.W) self.start_entry.grid(row=0,column=1,sticky=tk.E+tk.W) self.end_entry = tk.Entry(self.control_frame) self.end_entry.insert(0,'10') self.end_label = tk.Label(self.control_frame, text='End Time (s)') self.end_label.grid(row=0,column=2,sticky=tk.E+tk.W) self.end_entry.grid(row=0,column=3,sticky=tk.E+tk.W) self.cutoff_entry = tk.Entry(self.control_frame) self.cutoff_entry.insert(0,'') self.cutoff_label = tk.Label(self.control_frame, text='Cutoff (Hz)') self.cutoff_label.grid(row=1,column=0,sticky=tk.E+tk.W) self.cutoff_entry.grid(row=1,column=1,sticky=tk.E+tk.W) self.order_entry = tk.Entry(self.control_frame) self.order_entry.insert(0,'') self.order_label = tk.Label(self.control_frame, text='Filter Order') self.order_label.grid(row=1,column=2,sticky=tk.E+tk.W) self.order_entry.grid(row=1,column=3,sticky=tk.E+tk.W) self.samplerate_entry = tk.Entry(self.control_frame) self.samplerate_entry.insert(0,'250000') self.samplerate_label = tk.Label(self.control_frame, text='Sampling Frequency (Hz)') self.samplerate_label.grid(row=1,column=4,sticky=tk.E+tk.W) self.samplerate_entry.grid(row=1,column=5,sticky=tk.E+tk.W) self.savegain_entry = tk.Entry(self.control_frame) self.savegain_entry.insert(0,'1') self.savegain_label = tk.Label(self.control_frame, text='Sampling Frequency (Hz)') self.savegain_label.grid(row=0,column=4,sticky=tk.E+tk.W) self.savegain_entry.grid(row=0,column=5,sticky=tk.E+tk.W) self.plot_trace = tk.Button(self.control_frame, text='Update Trace', command=self.update_trace) self.plot_trace.grid(row=2,column=0,columnspan=2,sticky=tk.E+tk.W) self.normalize = tk.IntVar() self.normalize.set(0) self.normalize_check = tk.Checkbutton(self.control_frame, text='Normalize', variable = self.normalize) self.normalize_check.grid(row=2,column=2,sticky=tk.E+tk.W) self.plot_psd = tk.Button(self.control_frame, text='Update PSD', command=self.update_psd) self.plot_psd.grid(row=2,column=3,sticky=tk.E+tk.W) ##### Feedback Widgets ##### self.feedback_frame = tk.LabelFrame(parent, text='Status') self.feedback_frame.grid(row=2,column=6,columnspan=6,sticky=tk.N+tk.S+tk.E+tk.W) self.export_psd = tk.Button(self.feedback_frame, text='Export PSD',command=self.export_psd) self.export_psd.grid(row=1,column=0,columnspan=6,sticky=tk.E+tk.W) self.export_trace = tk.Button(self.feedback_frame, text='Export Trace',command=self.export_trace) self.export_trace.grid(row=2,column=0,columnspan=6,sticky=tk.E+tk.W) self.load_memmap() self.initialize_samplerate() def export_psd(self): try: data_path = tkinter.filedialog.asksaveasfilename(defaultextension='.csv',initialdir='G:\PSDs for Sam') np.savetxt(data_path,np.c_[self.f, self.Pxx, self.rms],delimiter=',') except AttributeError: self.wildcard.set('Plot the PSD first') def export_trace(self): try: data_path = tkinter.filedialog.asksaveasfilename(defaultextension='.csv',initialdir='G:\Analysis\Pores\NPN\PSDs') np.savetxt(data_path,self.plot_data,delimiter=',') except AttributeError: self.wildcard.set('Plot the trace first') def load_mapped_data(self): self.total_samples = len(self.map) self.samplerate = int(self.samplerate_entry.get()) if self.start_entry.get()!='': self.start_time = float(self.start_entry.get()) start_index = int((float(self.start_entry.get())*self.samplerate)) else: self.start_time = 0 start_index = 0 if self.end_entry.get()!='': self.end_time = float(self.end_entry.get()) end_index = int((float(self.end_entry.get())*self.samplerate)) if end_index > self.total_samples: end_index = self.total_samples self.data = self.map[start_index:end_index] self.data = float(self.savegain_entry.get()) * self.data def load_memmap(self): columntypes = np.dtype([('current', '>i2'), ('voltage', '>i2')]) self.map = np.memmap(self.file_path, dtype=columntypes, mode='r')['current'] def integrate_noise(self, f, Pxx): df = f[1]-f[0] return np.sqrt(np.cumsum(Pxx * df)) def filter_data(self): cutoff = float(self.cutoff_entry.get()) order = int(self.order_entry.get()) Wn = 2.0 * cutoff/float(self.samplerate) b, a = bessel(order,Wn,'low') padding = 1000 padded = np.pad(self.data, pad_width=padding, mode='median') self.filtered_data = filtfilt(b, a, padded, padtype=None)[padding:-padding] def initialize_samplerate(self): self.samplerate = float(self.samplerate_entry.get()) ##### Plot Updating functions ##### def update_trace(self): self.initialize_samplerate() self.load_mapped_data() self.filtered_data = self.data self.plot_data = self.filtered_data plot_samplerate = self.samplerate if self.cutoff_entry.get()!='' and self.order_entry!='': self.filter_data() self.plot_data = self.filtered_data self.trace_fig.clf() a = self.trace_fig.add_subplot(111) time = np.linspace(1.0/self.samplerate,len(self.plot_data)/float(self.samplerate),len(self.plot_data))+self.start_time a.set_xlabel(r'Time ($\mu s$)') a.set_ylabel('Current (pA)') self.trace_fig.subplots_adjust(bottom=0.14,left=0.21) a.plot(time*1e6,self.plot_data,'.',markersize=1) self.trace_canvas.show() def update_psd(self): self.initialize_samplerate() self.load_mapped_data() self.filtered_data = self.data self.plot_data = self.filtered_data plot_samplerate = self.samplerate if self.cutoff_entry.get()!='' and self.order_entry!='': self.filter_data() self.plot_data = self.filtered_data maxf = 2*float(self.cutoff_entry.get()) else: maxf = 2*float(self.samplerate_entry.get()) length = np.minimum(2**18,len(self.filtered_data)) end_index = int(np.floor(len(self.filtered_data)/length)*length) current = np.average(self.filtered_data[:end_index]) f, Pxx = welch(self.filtered_data, plot_samplerate,nperseg=length) self.rms = self.integrate_noise(f, Pxx) if self.normalize.get(): Pxx /= current**2 Pxx *= maxf/2.0 self.rms /= np.absolute(current) self.f = f self.Pxx = Pxx minf = 1 BW_index = np.searchsorted(f, maxf/2) logPxx = np.log10(Pxx[1:BW_index]) minP = 10**np.floor(np.amin(logPxx)) maxP = 10**np.ceil(np.amax(logPxx)) self.psd_fig.clf() a = self.psd_fig.add_subplot(111) a.set_xlabel('Frequency (Hz)') a.set_ylabel(r'Spectral Power ($\mathrm{pA}^2/\mathrm{Hz}$)') a.set_xlim(minf, maxf) a.set_ylim(minP, maxP) self.psd_fig.subplots_adjust(bottom=0.14,left=0.21) a.loglog(f[1:],Pxx[1:],'b-') for tick in a.get_yticklabels(): tick.set_color('b') a2 = a.twinx() a2.semilogx(f, self.rms, 'r-') a2.set_ylabel('RMS Noise (pA)') a2.set_xlim(minf, maxf) for tick in a2.get_yticklabels(): tick.set_color('r') a2.format_coord = make_format(a2, a) self.psd_canvas.show() def main(): root=tk.Tk() root.withdraw() file_path = tkinter.filedialog.askopenfilename(initialdir='C:/Data/') App(root,file_path).grid(row=0,column=0) root.mainloop() if __name__=="__main__": main()

gpl-3.0

syhpoon/xyzcmd

libxyz/vfs/vfsobj.py

1

8497

#-*- coding: utf8 -* # # Max E. Kuznecov ~syhpoon <syhpoon@syhpoon.name> 2008 # # This file is part of XYZCommander. # XYZCommander is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # XYZCommander is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser Public License for more details. # You should have received a copy of the GNU Lesser Public License # along with XYZCommander. If not, see <http://www.gnu.org/licenses/>. import os from libxyz.core.utils import bstring, ustring from libxyz.vfs import types, util class VFSObject(object): """ Abstract interface for VFS objects """ def __init__(self, xyz, path, full_path, ext_path, driver, parent, enc=None, **kwargs): self.xyz = xyz self.enc = enc or xyzenc # Internal VFS path self.path = bstring(path, self.enc) # Full VFS path self.full_path = bstring(full_path, self.enc) # External VFS path self.ext_path = bstring(ext_path, self.enc) self.parent = parent self.driver = driver self.kwargs = kwargs self.fileobj = None # File name self.name = os.path.basename(self.path) # File type self.ftype = None # Access time self.atime = None # Modified time self.mtime = None # Changed time self.ctime = None # Size in bytes self.size = None # Owner UID self.uid = None # Group self.gid = None # Mode self.mode = None # Inode self.inode = None # Visual file type self.vtype = None # Visual file representation self.visual = None # File info self.info = None # Any type-specific data self.data = None # List of significant attributes self.attributes = () self.__ni_msg = _(u"Feature not implemented") #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def is_file(self): """ Return True if instance is representing regular file """ return isinstance(self.ftype, types.VFSTypeFile) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def is_dir(self): """ Return True if instance is representing directory """ return isinstance(self.ftype, types.VFSTypeDir) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def is_dir_empty(self): """ Return True if instance is representing directory and it is empty """ if not self.is_dir(): return False _, _, objs = self.walk() return len(objs) == 0 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def is_link(self): """ Return True if instance is representing soft link """ return isinstance(self.ftype, types.VFSTypeLink) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def is_char(self): """ Return True if instance is representing soft char device """ return isinstance(self.ftype, types.VFSTypeChar) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def is_block(self): """ Return True if instance is representing block device """ return isinstance(self.ftype, types.VFSTypeBlock) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def is_fifo(self): """ Return True if instance is representing FIFO """ return isinstance(self.ftype, types.VFSTypeFifo) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def is_socket(self): """ Return True if instance is representing socket """ return isinstance(self.ftype, types.VFSTypeSocket) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def copy(self, path, existcb=None, errorcb=None, save_attrs=True, follow_links=False, cancel=None): """ Copy file to specified location @param path: Local path to copy file to @param existcb: Callback function to be called if there exists an object in target directory with the same name. Callback function receives VFSObject instance as an argument and must return one of: 'override' - to override this very object 'override all' - to override any future collisions 'skip' - to skip the object 'skip all' - to skip all future collisions 'abort' - to abort the process. If no existscb provided 'abort' is used as default @param errorcb: Callback function to be called in case an error occured during copying. Function receives VFSObject instance and error string as arguments and must return one of: 'skip' - to continue the process 'skip all' - to skip all future errors 'abort' - to abort the process. If no errorcb provided 'abort' is used as default @param save_attrs: Whether to save object attributes @param follow_links: Whether to follow symlinks @param cancel: a threading.Event instance, if it is found set - abort """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def move(self, path, existcb=None, errorcb=None, save_attrs=True, follow_links=False, cancel=None): """ Move object Arguments are the same as for copy() """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def mkdir(self, newdir): """ Create new dir inside object (only valid for directory object types) """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def remove(self, recursive=True): """ [Recursively] remove object """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def walk(self): """ Directory tree walker """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def open(self, mode='r'): """ Open self object in provided mode """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def close(self): """ Close self object """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def read(self, bytes=None): """ Read bytes from self object """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def tell(self): """ Tell file position """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def seek(self, offset, whence=None): """ Perform seek() on object """ raise NotImplementedError(self.__ni_msg) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def in_dir(self, d, e): """ Filter only those archive entries which exist in the same directory level """ if e.startswith(d.lstrip(os.sep)) and \ len(util.split_path(e)) == (len(util.split_path(d)) + 1): return True else: return False #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def __repr__(self): return self.__str__() #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def __unicode__(self): return ustring(self.__str__()) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ def __del__(self): if self.fileobj: try: self.close() except Exception: pass

gpl-3.0

317070/kaggle-heart

ira/configurations/gauss_roi10_maxout.py

1

9185

from collections import namedtuple import lasagne as nn from lasagne.layers.dnn import Conv2DDNNLayer, MaxPool2DDNNLayer import data_iterators import numpy as np import theano.tensor as T from functools import partial import utils_heart import nn_heart from pathfinder import PKL_TRAIN_DATA_PATH, TRAIN_LABELS_PATH, PKL_VALIDATE_DATA_PATH import utils import data caching = None restart_from_save = None rng = np.random.RandomState(42) patch_size = (64, 64) train_transformation_params = { 'patch_size': patch_size, 'mm_patch_size': (128, 128), 'mask_roi': True, 'rotation_range': (-180, 180), 'translation_range_x': (-5, 10), 'translation_range_y': (-10, 10), 'shear_range': (0, 0), 'roi_scale_range': (0.95, 1.3), 'zoom_range': (1 / 1.5, 1.5), 'do_flip': True, 'sequence_shift': False } valid_transformation_params = { 'patch_size': patch_size, 'mm_patch_size': (128, 128), 'mask_roi': True, } test_transformation_params = { 'patch_size': patch_size, 'mm_patch_size': (128, 128), 'mask_roi': True, 'rotation_range': (-180, 180), 'translation_range_x': (-5, 10), 'translation_range_y': (-10, 10), 'shear_range': (0, 0), 'roi_scale_range': (0.95, 1.3), 'zoom_range': (1., 1.), 'do_flip': True, 'sequence_shift': False } data_prep_fun = data.transform_norm_rescale_after batch_size = 32 nbatches_chunk = 16 chunk_size = batch_size * nbatches_chunk train_valid_ids = utils.get_train_valid_split(PKL_TRAIN_DATA_PATH) train_data_iterator = data_iterators.SliceNormRescaleDataGenerator(data_path=PKL_TRAIN_DATA_PATH, batch_size=chunk_size, transform_params=train_transformation_params, patient_ids=train_valid_ids['train'], labels_path=TRAIN_LABELS_PATH, slice2roi_path='pkl_train_slice2roi_10.pkl', full_batch=True, random=True, infinite=True, data_prep_fun=data_prep_fun) valid_data_iterator = data_iterators.SliceNormRescaleDataGenerator(data_path=PKL_TRAIN_DATA_PATH, batch_size=chunk_size, transform_params=valid_transformation_params, patient_ids=train_valid_ids['valid'], labels_path=TRAIN_LABELS_PATH, slice2roi_path='pkl_train_slice2roi_10.pkl', full_batch=False, random=False, infinite=False, data_prep_fun=data_prep_fun) test_data_iterator = data_iterators.SliceNormRescaleDataGenerator(data_path=PKL_VALIDATE_DATA_PATH, batch_size=chunk_size, transform_params=test_transformation_params, slice2roi_path='pkl_validate_slice2roi_10.pkl', full_batch=False, random=False, infinite=False, data_prep_fun=data_prep_fun) nchunks_per_epoch = train_data_iterator.nsamples / chunk_size max_nchunks = nchunks_per_epoch * 150 learning_rate_schedule = { 0: 0.0002, int(max_nchunks * 0.1): 0.0001, int(max_nchunks * 0.3): 0.000075, int(max_nchunks * 0.6): 0.00005, int(max_nchunks * 0.9): 0.00001 } validate_every = 2 * nchunks_per_epoch save_every = 2 * nchunks_per_epoch conv3 = partial(Conv2DDNNLayer, stride=(1, 1), pad="same", filter_size=(3, 3), nonlinearity=nn.nonlinearities.very_leaky_rectify, b=nn.init.Constant(0.1), W=nn.init.Orthogonal("relu")) max_pool = partial(MaxPool2DDNNLayer, pool_size=(2, 2), stride=(2, 2)) def build_model(l_in=None): l_in = nn.layers.InputLayer((None, 30) + patch_size) if not l_in else l_in l = conv3(l_in, num_filters=128) l = conv3(l, num_filters=128) l = max_pool(l) l = conv3(l, num_filters=128) l = conv3(l, num_filters=128) l = max_pool(l) l = conv3(l, num_filters=256) l = conv3(l, num_filters=256) l = conv3(l, num_filters=256) l = max_pool(l) l = conv3(l, num_filters=512) l = conv3(l, num_filters=512) l = conv3(l, num_filters=512) l = max_pool(l) l = conv3(l, num_filters=512) l = conv3(l, num_filters=512) l = conv3(l, num_filters=512) l = max_pool(l) l_d01 = nn.layers.DenseLayer(l, num_units=1024, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=None) l_d01 = nn.layers.FeaturePoolLayer(l_d01, pool_size=2) l_d02 = nn.layers.DenseLayer(nn.layers.dropout(l_d01), num_units=1024, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=None) l_d02 = nn.layers.FeaturePoolLayer(l_d02, pool_size=2) mu0 = nn.layers.DenseLayer(nn.layers.dropout(l_d02), num_units=1, W=nn.init.Orthogonal(), b=nn.init.Constant(50), nonlinearity=nn_heart.lb_softplus()) sigma0 = nn.layers.DenseLayer(nn.layers.dropout(l_d02), num_units=1, W=nn.init.Orthogonal(), b=nn.init.Constant(10), nonlinearity=nn_heart.lb_softplus()) l_cdf0 = nn_heart.NormalCDFLayer(mu0, sigma0, sigma_logscale=False, mu_logscale=False) # --------------------------------------------------------------- l_d11 = nn.layers.DenseLayer(l, num_units=1024, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=None) l_d11 = nn.layers.FeaturePoolLayer(l_d11, pool_size=2) l_d12 = nn.layers.DenseLayer(nn.layers.dropout(l_d11), num_units=1024, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=None) l_d12 = nn.layers.FeaturePoolLayer(l_d12, pool_size=2) mu1 = nn.layers.DenseLayer(nn.layers.dropout(l_d12), num_units=1, W=nn.init.Orthogonal(), b=nn.init.Constant(100), nonlinearity=nn_heart.lb_softplus()) sigma1 = nn.layers.DenseLayer(nn.layers.dropout(l_d12), num_units=1, W=nn.init.Orthogonal(), b=nn.init.Constant(10), nonlinearity=nn_heart.lb_softplus()) l_cdf1 = nn_heart.NormalCDFLayer(mu1, sigma1, sigma_logscale=False, mu_logscale=False) l_outs = [l_cdf0, l_cdf1] l_top = nn.layers.MergeLayer(l_outs) l_target_mu0 = nn.layers.InputLayer((None, 1)) l_target_mu1 = nn.layers.InputLayer((None, 1)) l_targets = [l_target_mu0, l_target_mu1] dense_layers = [l_d01, l_d02, l_d11, l_d12, mu0, sigma0, mu0, mu1] mu_layers = [mu0, mu1] sigma_layers = [sigma0, sigma1] return namedtuple('Model', ['l_ins', 'l_outs', 'l_targets', 'l_top', 'dense_layers', 'mu_layers', 'sigma_layers'])( [l_in], l_outs, l_targets, l_top, dense_layers, mu_layers, sigma_layers) def build_objective(model, deterministic=False): p0 = nn.layers.get_output(model.l_outs[0], deterministic=deterministic) t0 = nn.layers.get_output(model.l_targets[0]) t0_heaviside = nn_heart.heaviside(t0) crps0 = T.mean((p0 - t0_heaviside) ** 2) p1 = nn.layers.get_output(model.l_outs[1], deterministic=deterministic) t1 = nn.layers.get_output(model.l_targets[1]) t1_heaviside = nn_heart.heaviside(t1) crps1 = T.mean((p1 - t1_heaviside) ** 2) return 0.5 * (crps0 + crps1) def build_updates(train_loss, model, learning_rate): updates = nn.updates.adam(train_loss, nn.layers.get_all_params(model.l_top), learning_rate) return updates def get_mean_validation_loss(batch_predictions, batch_targets): return [0, 0] def get_mean_crps_loss(batch_predictions, batch_targets, batch_ids): nbatches = len(batch_predictions) npredictions = len(batch_predictions[0]) crpss = [] for i in xrange(npredictions): p, t = [], [] for j in xrange(nbatches): p.append(batch_predictions[j][i]) t.append(batch_targets[j][i]) p, t = np.vstack(p), np.vstack(t) target_cdf = utils_heart.heaviside_function(t) crpss.append(np.mean((p - target_cdf) ** 2)) return crpss def get_avg_patient_predictions(batch_predictions, batch_patient_ids, mean): return utils_heart.get_patient_average_cdf_predictions(batch_predictions, batch_patient_ids, mean)

mit

SafeW3rd/Ciphers

primeSieve.py

1

1139

# Prime Number Sieve # http://inventwithpython.com/hacking (BSD Licensed) import math def isPrime(num): # Returns True if num is a prime number, otherwise False. # Note: Generally, isPrime() is slower than primeSieve(). # all numbers less than 2 are not prime if num < 2: return False # see if num is divisible by any number up to the square root of num for i in range(2, int(math.sqrt(num)) + 1): if num % i == 0: return False return True def primeSieve(sieveSize): # Returns a list of prime numbers calculated using # the Sieve of Eratosthenes algorithm. sieve = [True] * sieveSize sieve[0] = False # zero and one are not prime numbers sieve[1] = False # create the sieve for i in range(2, int(math.sqrt(sieveSize)) + 1): pointer = i * 2 while pointer < sieveSize: sieve[pointer] = False pointer += i # compile the list of primes primes = [] for i in range(sieveSize): if sieve[i] == True: primes.append(i) return primes

mit

iamaris/CMUAnalysis

Common/generateObjectTree.py

1

11728

import re import os objects = ['Photon', 'Electron', 'Muon', 'Jet', 'Vertex'] susyObjects = {'Photon': 'Photon', 'Electron': 'Electron', 'Muon': 'Muon', 'Jet': 'PFJet', 'Vertex': 'Vertex'} objectVars = file('ObjectVars.h') classPat = re.compile('^[ ]*class[ ]+([a-zA-Z0-9]+)Vars[ ]*{') cTorPat = re.compile('^[ ]*[a-zA-Z0-9]+Vars\([^,]+(,[ ]+Event.*|)\);') varPat = re.compile('^[ ]*((?:unsigned[ ]|)(?:bool|char|short|int|unsigned|long|float|double))[ ]+([a-zA-Z_][a-zA-Z0-9_]*);') useEvent = dict() varList = dict() obj = '' for line in objectVars: if '};' in line: obj = '' if obj: cTorMatch = cTorPat.match(line) if cTorMatch: useEvent[obj] = len(cTorMatch.group(1)) != 0 varMatch = varPat.match(line) if varMatch: varList[obj].append((varMatch.group(1), varMatch.group(2))) lineMatch = classPat.match(line) if lineMatch and lineMatch.group(1) in objects: obj = lineMatch.group(1) varList[obj] = [] objectVars.close() # GENERATE HEADER headerContent = '''/* Auto-generated header file */ #ifndef ObjectTree_h #define ObjectTree_h #include "ObjectVars.h" #include "TTree.h" #include "TString.h" namespace susy { unsigned const NMAX(512); ''' for obj in objects: headerContent += ''' class ''' + obj + '''VarsArray { public: ''' + obj + '''VarsArray() {} ~''' + obj + '''VarsArray() {} void setBranches(TTree&); void setAddress(TTree&); void push_back(''' + obj + '''Vars const&); void clear() { size = 0; } ''' + obj + '''Vars at(unsigned) const; unsigned size; ''' for (type, name) in varList[obj]: headerContent += ''' ''' + type + ' ' + name + '[NMAX];' headerContent += ''' }; ''' headerContent += ''' class ObjectTree { public: ObjectTree(); ~ObjectTree(); void setOutput(TString const&,''' for i in range(len(objects)): headerContent += ' bool = true' if i != len(objects) - 1: headerContent += ',' else: headerContent += ');' headerContent += ''' void setOutput(TTree&,''' for i in range(len(objects)): headerContent += ' bool = true' if i != len(objects) - 1: headerContent += ',' else: headerContent += ');' headerContent += ''' static void setBranchStatus(TTree&,''' for i in range(len(objects)): headerContent += ' bool = true' if i != len(objects) - 1: headerContent += ',' else: headerContent += ');' headerContent += ''' void initEvent(Event const&); void fill() { output_->Fill(); }''' for obj in objects: lowerName = obj.lower() headerContent += ''' void save(''' + obj + 'Vars const& _vars) { ' + lowerName + 'Array_.push_back(_vars); }' for obj in objects: lowerName = obj.lower() headerContent += ''' unsigned get''' + obj + 'Size() const { return ' + lowerName + 'Array_.size; }' for obj in objects: lowerName = obj.lower() headerContent += ''' ''' + obj + 'VarsArray const& get' + obj + 'Array() const { return ' + lowerName + 'Array_; }' headerContent += ''' private: void setBranches_(''' for i in range(len(objects)): headerContent += 'bool' if i != len(objects) - 1: headerContent += ', ' else: headerContent += ');' for obj in objects: lowerName = obj.lower() headerContent += ''' ''' + obj + '''VarsArray ''' + lowerName + '''Array_;''' headerContent += ''' unsigned runNumber_; unsigned lumiNumber_; unsigned eventNumber_; TTree* output_; bool ownOutput_; }; } #endif ''' headerFile = file('ObjectTree.h', 'w') headerFile.write(headerContent) headerFile.close() # GENERATE SRC cTors = dict() setBranches = dict() setAddress = dict() pushBack = dict() at = dict() for obj in objects: lowerName = obj.lower() cTorText = ''' ''' + obj + 'Vars::' + obj + '''Vars() :''' initList = '' for (type, name) in varList[obj]: initList += ''' ''' + name + '(' if type == 'float' or type == 'double': initList += '0.' elif type == 'bool': initList += 'false' else: initList += '0' initList += '),' initList = initList.rstrip(',') cTorText += initList cTorText += ''' { } ''' cTors[obj] = cTorText setBranchText = ''' void ''' + obj + '''VarsArray::setBranches(TTree& _tree) { _tree.Branch("''' + lowerName + '.size", &size, "' + lowerName + '.size/i");' for (type, name) in varList[obj]: branch = ''' _tree.Branch("''' + lowerName + '.' + name + '", ' + name + ', "' + name + '[' + lowerName + '.size]/' if type == 'char': branch += 'B' elif type == 'unsigned char': branch += 'b' elif type == 'short': branch += 'S' elif type == 'unsigned short': branch += 's' elif type == 'int': branch += 'I' elif type == 'unsigned' or type == 'unsigned int': branch += 'i' elif type == 'long': branch += 'L' elif type == 'unsigned long': branch += 'l' elif type == 'float': branch += 'F' elif type == 'double': branch += 'D' elif type == 'bool': branch += 'O' branch += '");' setBranchText += branch setBranchText += ''' } ''' setBranches[obj] = setBranchText setAddressText = ''' void ''' + obj + '''VarsArray::setAddress(TTree& _tree) { std::vector<TString> notFound; _tree.SetBranchAddress("''' + lowerName + '.size", &size);' for (type, name) in varList[obj]: bName = lowerName + '.' + name setAddressText += ''' if(_tree.GetBranch("''' + bName + '")) _tree.SetBranchAddress("' + bName + '", ' + name + '''); else notFound.push_back("''' + bName + '");' setAddressText += ''' for(unsigned iN(0); iN != notFound.size(); ++iN) std::cerr << "Branch " << notFound[iN] << " not found in input" << std::endl; } ''' setAddress[obj] = setAddressText pushBackText = ''' void ''' + obj + 'VarsArray::push_back(' + obj + '''Vars const& _vars) { if(size == NMAX - 1) throw std::runtime_error("Too many ''' + obj + '''s"); ''' for (type, name) in varList[obj]: pushBackText += ''' ''' + name + '[size] = _vars.' + name + ';' pushBackText += ''' ++size; } ''' pushBack[obj] = pushBackText atText = ''' ''' + obj + '''Vars ''' + obj + '''VarsArray::at(unsigned _pos) const { if(_pos >= size) throw std::runtime_error("''' + obj + '''Vars out-of-bounds"); ''' + obj + '''Vars vars; ''' for (type, name) in varList[obj]: atText += ''' vars.''' + name + ' = ' + name + '[_pos];' atText += ''' return vars; } ''' at[obj] = atText preamble = '#include "ObjectVars.h"\n' try: originalSrc = file('ObjectVars.cc', 'r') userDef = '' copy = False namespace = False for line in originalSrc: if 'namespace susy' in line: namespace = True if not namespace and 'ObjectVars.h' not in line and not re.match('^[ ]*/\*.*\*/[ ]*$', line): preamble += line if '/* START USER-DEFINED IMPLEMENTATION (DO NOT MODIFY THIS LINE) */' in line: copy = True if copy: userDef += line if '/* END USER-DEFINED IMPLEMENTATION (DO NOT MODIFY THIS LINE) */' in line: copy = False originalSrc.close() except: userDef = '\n/* START USER-DEFINED IMPLEMENTATION (DO NOT MODIFY THIS LINE) */\n' for obj in objects: userDef += ''' void ''' + obj + '''Vars::set(''' + susyObjects[obj] + ' const&' if useEvent[obj]: userDef += ', Event const&' userDef += ''') { } /*static*/ ''' + obj + '''Vars::setBranchStatus(TTree&) { } ''' userDef += '/* END USER-DEFINED IMPLEMENTATION (DO NOT MODIFY THIS LINE) */\n' # ObjectTree.cc objTreeContent = '''/* Auto-generated source file */ #include "ObjectTree.h" #include "TFile.h" #include <stdexcept> #include <iostream> namespace susy { ''' for obj in objects: objTreeContent += setBranches[obj] objTreeContent += setAddress[obj] objTreeContent += pushBack[obj] objTreeContent += at[obj] objTreeContent += ''' ObjectTree::ObjectTree() :''' for obj in objects: lowerName = obj.lower() objTreeContent += ''' ''' + lowerName + '''Array_(),''' objTreeContent += ''' runNumber_(0), lumiNumber_(0), eventNumber_(0), output_(0), ownOutput_(false) { } ObjectTree::~ObjectTree() { if(ownOutput_ && output_){ TFile* outFile(output_->GetCurrentFile()); outFile->cd(); output_->Write(); delete outFile; } } void ObjectTree::setOutput(TString const& _fileName''' for obj in objects: objTreeContent += ', bool _set' + obj + '/* = true*/' objTreeContent += ''') { ownOutput_ = true; TFile::Open(_fileName, "recreate"); output_ = new TTree("objectVars", "Object ID variables"); setBranches_(''' for obj in objects: objTreeContent += '_set' + obj + ', ' objTreeContent = objTreeContent.rstrip(', ') objTreeContent += '''); } void ObjectTree::setOutput(TTree& _tree''' for obj in objects: objTreeContent += ', bool _set' + obj + '/* = true*/' objTreeContent += ''') { output_ = &_tree; setBranches_(''' for obj in objects: objTreeContent += '_set' + obj + ', ' objTreeContent = objTreeContent.rstrip(', ') objTreeContent += '''); } /*static*/ void ObjectTree::setBranchStatus(TTree& _input''' for obj in objects: objTreeContent += ', bool _set' + obj + '/* = true*/' objTreeContent += ''') { _input.SetBranchStatus("runNumber", 1); _input.SetBranchStatus("luminosityBlockNumber", 1); _input.SetBranchStatus("eventNumber", 1); ''' for obj in objects: objTreeContent += ''' if(_set''' + obj + ') ' + obj + 'Vars::setBranchStatus(_input);' objTreeContent += ''' } #ifdef STANDALONE void ObjectTree::initEvent(Event const&) { runNumber_ = 0; lumiNumber_ = 0; eventNumber_ = 0; #else void ObjectTree::initEvent(Event const& _event) { runNumber_ = _event.runNumber; lumiNumber_ = _event.luminosityBlockNumber; eventNumber_ = _event.eventNumber; #endif''' for obj in objects: objTreeContent += ''' ''' + obj.lower() + 'Array_.clear();' objTreeContent += ''' } void ObjectTree::setBranches_(''' for obj in objects: objTreeContent += 'bool _set' + obj + ', ' objTreeContent = objTreeContent.rstrip(', ') + ')' objTreeContent += ''' { output_->Branch("runNumber", &runNumber_, "runNumber/i"); output_->Branch("lumiNumber", &lumiNumber_, "lumiNumber/i"); output_->Branch("eventNumber", &eventNumber_, "eventNumber/i"); ''' for obj in objects: objTreeContent += ''' if(_set''' + obj + ') ' + obj.lower() + 'Array_.setBranches(*output_);' objTreeContent += ''' } ''' objTreeContent += '}\n' objTreeFile = file('ObjectTree.cc', 'w') objTreeFile.write(objTreeContent) objTreeFile.close() # ObjectVars.cc objVarsContent = '''/* Partially auto-generated source file - edit where indicated */ /* Add necessary inclusions below */ ''' + preamble + ''' namespace susy { ''' for obj in objects: objVarsContent += cTors[obj] objVarsContent += '\n' objVarsContent += userDef objVarsContent += ''' } ''' objVarsFile = file('ObjectVars.cc', 'w') objVarsFile.write(objVarsContent) objVarsFile.close()

apache-2.0

dsimic/taxsims

ss.py

1

1112

import pandas as pd import numpy as np def ss_calc( contrib_yearly, inv_gwth_rt, num_years, safe_withdrw_rate, start_age=28 ): """ inv_gwth_rt is infaltion adjusted. contrib_yearly is in first years dollars """ tot_years = max(0, 62 - start_age - num_years) + num_years df = pd.DataFrame({ 'contrib_yearly': [contrib_yearly] * num_years + [0.] * max(0, (62 - num_years - start_age)), 'inv_value': [0] * tot_years, }, index=range(tot_years)) for year in range(0, tot_years): print year multiplier = np.array([ (1. + inv_gwth_rt) ** (year - y_) for y_ in range(year + 1)]) print multiplier df['inv_value'][year] = np.sum( np.array(df['contrib_yearly'][0: year + 1]) * multiplier) df['monthly_inv_income'] = safe_withdrw_rate * df['inv_value'] / 12. df['monthly_inv_income_w_spouse'] = df['monthly_inv_income'] * 1.5 return df if __name__ == "__main__": df = ss_calc(15e3, .03, 10, .03) ss_benefit_monthly = 939.00 ss_benefit_w_spouse_monthly = 1.5 * ss_benefit_monthly

gpl-2.0

pacoqueen/bbinn

PyChart-1.39/demos/linestyles.py

1

1258

#!/usr/bin/env python # -*- coding: utf-8 -*- import sys sys.path.append("..") # # Copyright (C) 2000-2005 by Yasushi Saito (yasushi.saito@gmail.com) # # Pychart is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by the # Free Software Foundation; either version 2, or (at your option) any # later version. # # Pychart is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License # for more details. # from pychart import * import pychart.doc_support import chartdemo import re can = canvas.default_canvas() x = 100 y = 500 def drawLine(style): global x, y name = pychart.doc_support.stringify_value(style) name = re.sub("line_style\\.", "", name) name = pychart.doc_support.break_string(name) can.line(style, x, y, x+40, y) #print "name=", name height = font.text_height(name)[0] + 5 tb = text_box.T(text=name, loc=(x, y-height), line_style=None) x = x + 60 tb.draw() for style in line_style.standards.list(): drawLine(style) if x >= chartdemo.MaxWidth: x=100 y=y-40

gpl-2.0

Psycojoker/wanawana

wanawana/settings.py

1

2687

""" Django settings for wanawana project. For more information on this file, see https://docs.djangoproject.com/en/1.7/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/1.7/ref/settings/ """ # Build paths inside the project like this: os.path.join(BASE_DIR, ...) import os BASE_DIR = os.path.dirname(os.path.dirname(__file__)) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.7/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = 'w2=4yi@cyc@vsio@$tvz$%&_po6si@533=cwh5kr2dk#pd69)v' # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True TEMPLATE_DEBUG = True ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'bootstrap3', 'django_extensions', 'debug_toolbar', 'django_pdb', 'wanawana', 'users', 'events', ) MIDDLEWARE_CLASSES = ( 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.auth.middleware.SessionAuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', 'django_pdb.middleware.PdbMiddleware', ) ROOT_URLCONF = 'wanawana.urls' TEMPLATE_LOADERS = ( 'hamlpy.template.loaders.HamlPyFilesystemLoader', 'hamlpy.template.loaders.HamlPyAppDirectoriesLoader', 'django.template.loaders.filesystem.Loader', 'django.template.loaders.app_directories.Loader', ) WSGI_APPLICATION = 'wanawana.wsgi.application' # Email configuration EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' if DEBUG: EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' # Database # https://docs.djangoproject.com/en/1.7/ref/settings/#databases DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), } } # Internationalization # https://docs.djangoproject.com/en/1.7/topics/i18n/ LANGUAGE_CODE = 'en-us' TIME_ZONE = 'UTC' USE_I18N = True USE_L10N = True USE_TZ = True # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/1.7/howto/static-files/ STATIC_URL = '/static/' try: from settings_local import * except ImportError: pass

gpl-3.0

jasper-meyer/Platformer

platformer.py

1

3751

""" platformer.py Author: Jasper Meyer Credit: You, the internet, Brendan Assignment: Write and submit a program that implements the sandbox platformer game: https://github.com/HHS-IntroProgramming/Platformer """ from ggame import App, RectangleAsset, ImageAsset, Sprite, LineStyle, Color, Frame SCREEN_WIDTH = 1080 SCREEN_HEIGHT = 720 myapp = App(SCREEN_WIDTH, SCREEN_HEIGHT) black = Color(0, 1) backcol = Color(0xd9ffcc, 1.0) purp = Color(0x9900cc, 1.0) blue = Color(0x3399ff,1.0) noline = LineStyle(0, black) bg_asset = RectangleAsset(SCREEN_WIDTH, SCREEN_HEIGHT, noline, backcol) bg = Sprite(bg_asset, (0,0)) thinline = LineStyle(1, black) sq = RectangleAsset (75,75, noline, black) wub=0 pup=0 mousex=0 mousey=0 mousexround=0 mouseyround=0 play = RectangleAsset (25,50, noline, purp) spr = RectangleAsset (20,10, noline, blue) vy=0 player=0 acc = 0 ti = 0 rupx=0 lupx=0 vx=0 up=0 upup=0 stop = 0 shutup=0 spring = 0 sub = 0 springlist = [] def wup(event): global wub global mousexround global mouseyround wub = 1 if wub == 1: mousexround=mousex-((mousex)%75) mouseyround=mousey-((mousey)%75) block = Sprite (sq, (mousexround, mouseyround)) def mousemo(event): global mousex global mousey mousex=event.x mousey=event.y def spri(event): global spring global mousex global mousey global mouseyround global sub global springlist sub =1 if sub == 1: mouseyround=mousey-((mousey)%75)+65 springlist.append (Sprite (spr, (mousex, mouseyround))) def pup(event): global pub global mousex global mouseyround global player pub = 1 if pub == 1: mouseyround=mousey-((mousey)%75)+25 if player == 0: player = Sprite (play, (mousex, mouseyround)) def rup(event): global rupx rupx=1 def lup(event): global lupx lupx=1 def uup(event): global up up=1 def step(): if player != 0: global vy global acc global ti global rupx global vx global lupx global up global upup global stop global shutup global springlist global player acc = 0.02 for s in springlist: if player.collidingWith(s): vy=-50+vy vx=-vx if stop == 0: ti=ti+.5 if upup==4.5: vy = (0.2*ti)-upup else: vy = (0.2*ti) player.y=player.y+vy player.x=player.x+vx if rupx == 1: vx=vx+1.5 lupx=0 rupx=0 if lupx == 1: vx=vx-1.5 rupx=0 lupx=0 if vx > 3: vx = 3 if vx < -3: vx =-3 if up == 1: upup = 4.5 up=0 if up == 0: upup =4.5 col = player.collidingWithSprites(Sprite) if len(col) > 1 and col[1].y<player.y+500: stop=1 player.y=player.y-0.2 else: stop=0 if stop == 1: vy=0 ti=0 if len(col) > 1: if col[1].y<player.y+50: vx=-0.5*vx if player.y > 2000: player = 0 ti=0 myapp.listenKeyEvent('keyup', 's', spri) myapp.listenKeyEvent('keydown', 'up arrow', uup) myapp.listenKeyEvent('keydown', 'left arrow', lup) myapp.listenKeyEvent('keydown', 'right arrow', rup) myapp.listenKeyEvent('keyup', 'p', pup) myapp.listenKeyEvent('keyup', 'w', wup) myapp.listenMouseEvent('mousemove', mousemo) myapp.run(step)

mit

polaris-gslb/polaris-core

tests/test-polaris-pdns.py

2

1937

#!/usr/bin/env python3 import subprocess import sys import time import json POLARIS_PDNS_FILE = '/opt/polaris/bin/polaris-pdns' def pretty_json(s): d = json.loads(s) return json.dumps(d, indent=4, separators=(',', ': ')) class TestPolarisPDNS: def __init__(self, polaris_pdns_file): self.proc = subprocess.Popen([ polaris_pdns_file ], stdin=subprocess.PIPE, stdout=subprocess.PIPE) def execute_query(self, query): query += '\n' self.proc.stdin.write(query.encode()) self.proc.stdin.flush() output = self.proc.stdout.readline().decode() return pretty_json(output) def prepare_query(self, method, params): q = { 'method': method, 'parameters': { 'qtype': params['qtype'], 'qname': params['qname'], 'remote': params['remote'], 'local': params['local'], 'real-remote': params['real-remote'], 'zone-id': params['zone-id'] } } return json.dumps(q) if __name__ == '__main__': t = TestPolarisPDNS(POLARIS_PDNS_FILE) method = 'lookup' params = { 'qtype': 'A', 'qname': 'www.example.com', 'remote': '10.1.1.21', 'local': '0.0.0.0', 'real-remote': '10.1.1.21/32', 'zone-id': -1 } q = t.prepare_query(method, params) print("query: ", pretty_json(q), "\n") print("response: ", t.execute_query(q)) method = 'lookup' params = { 'qtype': 'SOA', 'qname': 'www.example.com', 'remote': '10.1.1.21', 'local': '0.0.0.0', 'real-remote': '10.1.1.21/32', 'zone-id': -1 } q = t.prepare_query(method, params) print("query: ", pretty_json(q), "\n") print("response: ", t.execute_query(q))

bsd-3-clause

daniel20162016/my-first

read_xml_all/calcul_matrix_compare_je_good_192matrix.py

1

6357

# -*- coding: utf-8 -*- """ Created on Mon Oct 31 15:45:22 2016 @author: wang """ #from matplotlib import pylab as plt #from numpy import fft, fromstring, int16, linspace #import wave from read_wav_xml_good_1 import* from matrix_24_2 import* from max_matrix_norm import* import numpy as np # open a wave file filename = 'francois_filon_pure_3.wav' filename_1 ='francois_filon_pure_3.xml' word ='je' wave_signal_float,framerate, word_start_point, word_length_point, word_end_point= read_wav_xml_good_1(filename,filename_1,word) #print 'word_start_point=',word_start_point #print 'word_length_point=',word_length_point #print 'word_end_point=',word_end_point XJ_1 =wave_signal_float t_step=1920; t_entre_step=1440; t_du_1_1 = int(word_start_point[0]); t_du_1_2 = int(word_end_point[0]); t_du_2_1 = int(word_start_point[1]); t_du_2_2 = int(word_end_point[1]); t_du_3_1 = int(word_start_point[2]); t_du_3_2 = int(word_end_point[2]); t_du_4_1 = int(word_start_point[3]); t_du_4_2 = int(word_end_point[3]); t_du_5_1 = int(word_start_point[4]); t_du_5_2 = int(word_end_point[4]); fs=framerate #XJ_du_1 = wave_signal_float[(t_du_1_1-1):t_du_1_2]; #length_XJ_du_1 = int(word_length_point[0]+1); #x1,y1,z1=matrix_24_2(XJ_du_1,fs) #x1=max_matrix_norm(x1) #============================================================================== # this part is to calcul the first matrix #============================================================================== XJ_du_1_2 = XJ_1[(t_du_1_1-1):(t_du_1_1+t_step)]; x1_1,y1_1,z1_1=matrix_24_2(XJ_du_1_2 ,fs) x1_1=max_matrix_norm(x1_1) matrix_all_step_new_1 = np.zeros([192]) for i in range(0,24): matrix_all_step_new_1[i]=x1_1[i] #============================================================================== # the other colonne is the all fft #============================================================================== for i in range(1,8): XJ_du_1_total = XJ_1[(t_du_1_1+t_entre_step*(i)-1):(t_du_1_1+t_step+t_entre_step*(i) )]; x1_all,y1_all,z1_all=matrix_24_2(XJ_du_1_total,fs) x1_all=max_matrix_norm(x1_all) for j in range(0,24): matrix_all_step_new_1[24*i+j]=x1_all[j] #============================================================================== # this part is to calcul the second matrix #============================================================================== for k in range (1,2): t_start=t_du_2_1 XJ_du_1_2 = XJ_1[(t_start-1):(t_start+t_step)]; x1_1,y1_1,z1_1=matrix_24_2(XJ_du_1_2 ,fs) x1_1=max_matrix_norm(x1_1) matrix_all_step_new_2 = np.zeros([192]) for i in range(0,24): matrix_all_step_new_2[i]=x1_1[i] #============================================================================== # the other colonne is the all fft #============================================================================== for i in range(1,8): XJ_du_1_total = XJ_1[(t_start+t_entre_step*(i)-1):(t_start+t_step+t_entre_step*(i) )]; x1_all,y1_all,z1_all=matrix_24_2(XJ_du_1_total,fs) x1_all=max_matrix_norm(x1_all) for j in range(0,24): matrix_all_step_new_2[24*i+j]=x1_all[j] #============================================================================== # this part is to calcul the 3 matrix #============================================================================== for k in range (1,2): t_start=t_du_3_1 XJ_du_1_2 = XJ_1[(t_start-1):(t_start+t_step)]; x1_1,y1_1,z1_1=matrix_24_2(XJ_du_1_2 ,fs) x1_1=max_matrix_norm(x1_1) matrix_all_step_new_3 = np.zeros([192]) for i in range(0,24): matrix_all_step_new_3[i]=x1_1[i] #============================================================================== # the other colonne is the all fft #============================================================================== for i in range(1,8): XJ_du_1_total = XJ_1[(t_start+t_entre_step*(i)-1):(t_start+t_step+t_entre_step*(i) )]; x1_all,y1_all,z1_all=matrix_24_2(XJ_du_1_total,fs) x1_all=max_matrix_norm(x1_all) for j in range(0,24): matrix_all_step_new_3[24*i+j]=x1_all[j] #============================================================================== # this part is to calcul the 4 matrix #============================================================================== for k in range (1,2): t_start=t_du_4_1 XJ_du_1_2 = XJ_1[(t_start-1):(t_start+t_step)]; x1_1,y1_1,z1_1=matrix_24_2(XJ_du_1_2 ,fs) x1_1=max_matrix_norm(x1_1) matrix_all_step_new_4 = np.zeros([192]) for i in range(0,24): matrix_all_step_new_4[i]=x1_1[i] #============================================================================== # the other colonne is the all fft #============================================================================== for i in range(1,8): # print i XJ_du_1_total = XJ_1[(t_start+t_entre_step*(i)-1):(t_start+t_step+t_entre_step*(i) )]; x1_all,y1_all,z1_all=matrix_24_2(XJ_du_1_total,fs) x1_all=max_matrix_norm(x1_all) for j in range(0,24): matrix_all_step_new_4[24*i+j]=x1_all[j] #print 'matrix_all_step_4=',matrix_all_step_4 #============================================================================== # this part is to calcul the 5 matrix #============================================================================== for k in range (1,2): t_start=t_du_5_1 XJ_du_1_2 = XJ_1[(t_start-1):(t_start+t_step)]; x1_1,y1_1,z1_1=matrix_24_2(XJ_du_1_2 ,fs) x1_1=max_matrix_norm(x1_1) matrix_all_step_new_5 = np.zeros([192]) for i in range(0,24): matrix_all_step_new_5[i]=x1_1[i] #============================================================================== # the other colonne is the all fft #============================================================================== for i in range(1,8): # print i XJ_du_1_total = XJ_1[(t_start+t_entre_step*(i)-1):(t_start+t_step+t_entre_step*(i) )]; x1_all,y1_all,z1_all=matrix_24_2(XJ_du_1_total,fs) x1_all=max_matrix_norm(x1_all) for j in range(0,24): matrix_all_step_new_5[24*i+j]=x1_all[j] #print 'matrix_all_step_5=',matrix_all_step_5 np.savez('je_compare_192_matrix.npz',matrix_all_step_new_1,matrix_all_step_new_2,matrix_all_step_new_3,matrix_all_step_new_4,matrix_all_step_new_5)

mit

wholland/env

env.py

1

6119

#!/usr/bin/python import argparse import json import shutil import os def copy_file(src, dest, backup): success = True if not backup is None: (backup_folder, backup_file) = os.path.split(backup) print("Creating backup file for " + dest + " at " + backup) try: if not os.path.exists(backup_folder): os.makedirs(backup_folder) shutil.copyfile(dest, backup) except Exception as e: print("Backup failed: " + str(e)) success = False if success: (dest_folder, dest_file) = os.path.split(dest) print("Copy file " + src + " to " + dest) try: if not os.path.exists(dest_folder): os.makedirs(dest_folder) shutil.copyfile(src, dest) except IOError as e: print("Copy failed: " + str(e)) def copy_dir(src, dest, backup): success = True if not backup is None: try: print("Creating backup file for " + dest + " at " + backup) rmtree(backup, ignore_errors=True) shutil.copytree(dest, backup) except IOError as e: print("Backup failed: " + str(e)) success = False if success: try: print("Copy directory " + src + " to " + dest) shutil.copytree(src, dest) except IOError as e: print("Copy failed: " + str(e)) def push(args): defs = json.load(open(os.path.expanduser(args.file))) for definition in defs: if definition["group"] in args.categories: print("Pushing " + definition["name"]); src = os.path.expanduser(os.path.join(args.source, definition["source"])) dest = os.path.expanduser(os.path.join(args.target, definition["target"])) backup = os.path.expanduser(os.path.join(args.backup, definition["target"])) if definition["type"].lower() == "f": # Copy a file if args.unsafe: if not args.wimp: copy_file(src, dest, None) else: print("Would copy file. Src:" + src + " Dest:" + dest); else: if not args.wimp: copy_file(src, dest, backup) else: print("Would copy file. Src:" + src + " Dest:" + dest + " Backup:" + backup); elif definition["type"].lower() == "d": # Copy a directory if args.verbose: print(definition["name"] + ": Pushing directory from " + src + " to " + dest) if args.unsafe: if not args.wimp: copy_dir(src, dest, None) else: print("Would copy file. Src:" + src + " Dest:" + dest); else: if not args.wimp: copy_dir(src, dest, backup) else: print("Would copy dir. Src:" + src + " Dest:" + dest + " Backup:" + backup); else: print(definition["name"] + ": Unknown type \""+definition["type"]+"\"") def pull(args): defs = json.load(open(os.path.expanduser(args.file))) for definition in defs: if definition["group"] in args.categories: print("Pulling " + definition["name"]); src = os.path.expanduser(os.path.join(args.target, definition["target"])) dest = os.path.expanduser(os.path.join(args.source, definition["source"])) if definition["type"].lower() == "f": # Copy a file if not args.wimp: copy_file(src, dest, None) else: print("Would copy file. Src:" + src + " Dest:" + dest); elif definition["type"].lower() == "d": # Copy a directory if not args.wimp: copy_dir(src, dest, None) else: print("Would copy directory. Src:" + src + " Dest:" + dest); else: print(definition["name"] + ": Unknown type \""+definition["type"]+"\"") def revert(args): defs = json.load(open(os.path.expanduser(args.file))) for definition in defs: if definition["group"] in args.categories: src = os.path.expanduser(os.path.join(args.backup, definition["target"])) dest = os.path.expanduser(os.path.join(args.target, definition["target"])) if definition["type"].lower() == "f": # Copy a file if not args.wimp: copy_file(src, dest, None) else: print("Would copy file. Src:" + src + " Dest:" + dest); elif definition["type"].lower() == "d": # Copy a directory if not args.wimp: copy_dir(src, dest, None) else: print("Would copy directory. Src:" + src + " Dest:" + dest); else: print(definition["name"] + ": Unknown type \""+definition["type"]+"\"") def main(): default_defs = "~/env/env.def" default_source = "~/env/" default_target = "~/" default_backup = "~/.backup/env/" parser = argparse.ArgumentParser() parser.add_argument("-v", "--verbose", action="store_true", help="Increase Verbosity") parser.add_argument("-f", "--file", default=default_defs, help="Definition File to use") parser.add_argument("-s", "--source", default=default_source, help="Override source root") parser.add_argument("-t", "--target", default=default_target, help="Override target root") parser.add_argument("-w", "--wimp", action="store_true", help="Don't actually make any changes (implies -v)") subparsers = parser.add_subparsers() parser_push = subparsers.add_parser("push", help="Push configs into environment") parser_push.add_argument("-u", "--unsafe", action="store_true", help="No backups Created") parser_push.add_argument("-a", "--All", action="store_true", help="Cleanup Backups") parser_push.add_argument("-b", "--backup", default=default_backup, help="Override backup root") parser_push.add_argument("categories", nargs=argparse.REMAINDER) parser_push.set_defaults(func=push) parser_pull = subparsers.add_parser("pull", help="Pull configs from environment") parser_pull.add_argument("-a", "--All", action="store_true", help="Cleanup Backups") parser_pull.add_argument("categories", nargs=argparse.REMAINDER) parser_pull.set_defaults(func=pull) parser_revert = subparsers.add_parser("revert", help="Revert configs from backups") parser_revert.add_argument("-c", "--cleanup", action="store_true", help="Cleanup Backups") parser_revert.add_argument("-a", "--All", action="store_true", help="Cleanup Backups") parser_revert.add_argument("-b", "--backup", default=default_backup, help="Override backup root") parser_revert.add_argument("categories", nargs=argparse.REMAINDER) parser_revert.set_defaults(func=revert) args = parser.parse_args() if args.wimp: args.verbose = True args.func(args) if __name__ == "__main__": main();

mit

jailuthra/misc

python/quicksort.py

1

1066

import sys import random comparisons = 0 def main(): global comparisons with open(sys.argv[1], 'r') as f: arr = [int(x) for x in f.read().split()] quicksort(arr, 0, len(arr)-1) # print(arr) print(comparisons) def getPivot(arr, l, r): first = arr[l] mid = arr[(l+r)//2] last = arr[r] if first <= mid <= last or last <= mid <= first: return (l+r)//2 elif mid <= first <= last or last <= first <= mid: return l else: return r def partition(arr, l, r): k = getPivot(arr, l, r) k = random.randint(l, r) pivot = arr[k] arr[k], arr[l] = arr[l], arr[k] i = l+1 for j in range(l+1, r+1): if arr[j] < pivot: arr[j], arr[i] = arr[i], arr[j] i += 1 arr[l], arr[i-1] = arr[i-1], arr[l] return i-1 def quicksort(arr, l, r): if r - l < 0: return global comparisons comparisons += r - l p = partition(arr, l, r) quicksort(arr, l, p-1) quicksort(arr, p+1, r) if __name__ == '__main__': main()

mit

mistercrunch/panoramix

superset/views/base_api.py

2

21953

# Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. import functools import logging from typing import Any, Callable, cast, Dict, List, Optional, Set, Tuple, Type, Union from apispec import APISpec from apispec.exceptions import DuplicateComponentNameError from flask import Blueprint, g, Response from flask_appbuilder import AppBuilder, Model, ModelRestApi from flask_appbuilder.api import expose, protect, rison, safe from flask_appbuilder.models.filters import BaseFilter, Filters from flask_appbuilder.models.sqla.filters import FilterStartsWith from flask_appbuilder.models.sqla.interface import SQLAInterface from flask_babel import lazy_gettext as _ from marshmallow import fields, Schema from sqlalchemy import and_, distinct, func from sqlalchemy.orm.query import Query from superset.extensions import db, event_logger, security_manager from superset.models.core import FavStar from superset.models.dashboard import Dashboard from superset.models.slice import Slice from superset.schemas import error_payload_content from superset.sql_lab import Query as SqllabQuery from superset.stats_logger import BaseStatsLogger from superset.typing import FlaskResponse from superset.utils.core import time_function logger = logging.getLogger(__name__) get_related_schema = { "type": "object", "properties": { "page_size": {"type": "integer"}, "page": {"type": "integer"}, "include_ids": {"type": "array", "items": {"type": "integer"}}, "filter": {"type": "string"}, }, } class RelatedResultResponseSchema(Schema): value = fields.Integer(description="The related item identifier") text = fields.String(description="The related item string representation") class RelatedResponseSchema(Schema): count = fields.Integer(description="The total number of related values") result = fields.List(fields.Nested(RelatedResultResponseSchema)) class DistinctResultResponseSchema(Schema): text = fields.String(description="The distinct item") class DistincResponseSchema(Schema): count = fields.Integer(description="The total number of distinct values") result = fields.List(fields.Nested(DistinctResultResponseSchema)) def statsd_metrics(f: Callable[..., Any]) -> Callable[..., Any]: """ Handle sending all statsd metrics from the REST API """ def wraps(self: "BaseSupersetModelRestApi", *args: Any, **kwargs: Any) -> Response: try: duration, response = time_function(f, self, *args, **kwargs) except Exception as ex: self.incr_stats("error", f.__name__) raise ex self.send_stats_metrics(response, f.__name__, duration) return response return functools.update_wrapper(wraps, f) class RelatedFieldFilter: # data class to specify what filter to use on a /related endpoint # pylint: disable=too-few-public-methods def __init__(self, field_name: str, filter_class: Type[BaseFilter]): self.field_name = field_name self.filter_class = filter_class class BaseFavoriteFilter(BaseFilter): # pylint: disable=too-few-public-methods """ Base Custom filter for the GET list that filters all dashboards, slices that a user has favored or not """ name = _("Is favorite") arg_name = "" class_name = "" """ The FavStar class_name to user """ model: Type[Union[Dashboard, Slice, SqllabQuery]] = Dashboard """ The SQLAlchemy model """ def apply(self, query: Query, value: Any) -> Query: # If anonymous user filter nothing if security_manager.current_user is None: return query users_favorite_query = db.session.query(FavStar.obj_id).filter( and_( FavStar.user_id == g.user.get_id(), FavStar.class_name == self.class_name, ) ) if value: return query.filter(and_(self.model.id.in_(users_favorite_query))) return query.filter(and_(~self.model.id.in_(users_favorite_query))) class BaseSupersetModelRestApi(ModelRestApi): """ Extends FAB's ModelResApi to implement specific superset generic functionality """ csrf_exempt = False method_permission_name = { "bulk_delete": "delete", "data": "list", "data_from_cache": "list", "delete": "delete", "distinct": "list", "export": "mulexport", "import_": "add", "get": "show", "get_list": "list", "info": "list", "post": "add", "put": "edit", "refresh": "edit", "related": "list", "related_objects": "list", "schemas": "list", "select_star": "list", "table_metadata": "list", "test_connection": "post", "thumbnail": "list", "viz_types": "list", } order_rel_fields: Dict[str, Tuple[str, str]] = {} """ Impose ordering on related fields query:: order_rel_fields = { "<RELATED_FIELD>": ("<RELATED_FIELD_FIELD>", "<asc|desc>"), ... } """ # pylint: disable=pointless-string-statement related_field_filters: Dict[str, Union[RelatedFieldFilter, str]] = {} """ Declare the filters for related fields:: related_fields = { "<RELATED_FIELD>": <RelatedFieldFilter>) } """ # pylint: disable=pointless-string-statement filter_rel_fields: Dict[str, BaseFilter] = {} """ Declare the related field base filter:: filter_rel_fields_field = { "<RELATED_FIELD>": "<FILTER>") } """ # pylint: disable=pointless-string-statement allowed_rel_fields: Set[str] = set() """ Declare a set of allowed related fields that the `related` endpoint supports """ # pylint: disable=pointless-string-statement text_field_rel_fields: Dict[str, str] = {} """ Declare an alternative for the human readable representation of the Model object:: text_field_rel_fields = { "<RELATED_FIELD>": "<RELATED_OBJECT_FIELD>" } """ # pylint: disable=pointless-string-statement allowed_distinct_fields: Set[str] = set() openapi_spec_component_schemas: Tuple[Type[Schema], ...] = tuple() """ Add extra schemas to the OpenAPI component schemas section """ # pylint: disable=pointless-string-statement add_columns: List[str] edit_columns: List[str] list_columns: List[str] show_columns: List[str] responses = { "400": {"description": "Bad request", "content": error_payload_content}, "401": {"description": "Unauthorized", "content": error_payload_content}, "403": {"description": "Forbidden", "content": error_payload_content}, "404": {"description": "Not found", "content": error_payload_content}, "422": { "description": "Could not process entity", "content": error_payload_content, }, "500": {"description": "Fatal error", "content": error_payload_content}, } def __init__(self) -> None: # Setup statsd self.stats_logger = BaseStatsLogger() # Add base API spec base query parameter schemas if self.apispec_parameter_schemas is None: # type: ignore self.apispec_parameter_schemas = {} self.apispec_parameter_schemas["get_related_schema"] = get_related_schema if self.openapi_spec_component_schemas is None: self.openapi_spec_component_schemas = () self.openapi_spec_component_schemas = self.openapi_spec_component_schemas + ( RelatedResponseSchema, DistincResponseSchema, ) super().__init__() def add_apispec_components(self, api_spec: APISpec) -> None: """ Adds extra OpenApi schema spec components, these are declared on the `openapi_spec_component_schemas` class property """ for schema in self.openapi_spec_component_schemas: try: api_spec.components.schema( schema.__name__, schema=schema, ) except DuplicateComponentNameError: pass super().add_apispec_components(api_spec) def create_blueprint( self, appbuilder: AppBuilder, *args: Any, **kwargs: Any ) -> Blueprint: self.stats_logger = self.appbuilder.get_app.config["STATS_LOGGER"] return super().create_blueprint(appbuilder, *args, **kwargs) def _init_properties(self) -> None: model_id = self.datamodel.get_pk_name() if self.list_columns is None and not self.list_model_schema: self.list_columns = [model_id] if self.show_columns is None and not self.show_model_schema: self.show_columns = [model_id] if self.edit_columns is None and not self.edit_model_schema: self.edit_columns = [model_id] if self.add_columns is None and not self.add_model_schema: self.add_columns = [model_id] super()._init_properties() def _get_related_filter( self, datamodel: SQLAInterface, column_name: str, value: str ) -> Filters: filter_field = self.related_field_filters.get(column_name) if isinstance(filter_field, str): filter_field = RelatedFieldFilter(cast(str, filter_field), FilterStartsWith) filter_field = cast(RelatedFieldFilter, filter_field) search_columns = [filter_field.field_name] if filter_field else None filters = datamodel.get_filters(search_columns) base_filters = self.filter_rel_fields.get(column_name) if base_filters: filters.add_filter_list(base_filters) if value and filter_field: filters.add_filter( filter_field.field_name, filter_field.filter_class, value ) return filters def _get_distinct_filter(self, column_name: str, value: str) -> Filters: filter_field = RelatedFieldFilter(column_name, FilterStartsWith) filter_field = cast(RelatedFieldFilter, filter_field) search_columns = [filter_field.field_name] if filter_field else None filters = self.datamodel.get_filters(search_columns) filters.add_filter_list(self.base_filters) if value and filter_field: filters.add_filter( filter_field.field_name, filter_field.filter_class, value ) return filters def _get_text_for_model(self, model: Model, column_name: str) -> str: if column_name in self.text_field_rel_fields: model_column_name = self.text_field_rel_fields.get(column_name) if model_column_name: return getattr(model, model_column_name) return str(model) def _get_result_from_rows( self, datamodel: SQLAInterface, rows: List[Model], column_name: str ) -> List[Dict[str, Any]]: return [ { "value": datamodel.get_pk_value(row), "text": self._get_text_for_model(row, column_name), } for row in rows ] def _add_extra_ids_to_result( self, datamodel: SQLAInterface, column_name: str, ids: List[int], result: List[Dict[str, Any]], ) -> None: if ids: # Filter out already present values on the result values = [row["value"] for row in result] ids = [id_ for id_ in ids if id_ not in values] pk_col = datamodel.get_pk() # Fetch requested values from ids extra_rows = db.session.query(datamodel.obj).filter(pk_col.in_(ids)).all() result += self._get_result_from_rows(datamodel, extra_rows, column_name) def incr_stats(self, action: str, func_name: str) -> None: """ Proxy function for statsd.incr to impose a key structure for REST API's :param action: String with an action name eg: error, success :param func_name: The function name """ self.stats_logger.incr(f"{self.__class__.__name__}.{func_name}.{action}") def timing_stats(self, action: str, func_name: str, value: float) -> None: """ Proxy function for statsd.incr to impose a key structure for REST API's :param action: String with an action name eg: error, success :param func_name: The function name :param value: A float with the time it took for the endpoint to execute """ self.stats_logger.timing( f"{self.__class__.__name__}.{func_name}.{action}", value ) def send_stats_metrics( self, response: Response, key: str, time_delta: Optional[float] = None ) -> None: """ Helper function to handle sending statsd metrics :param response: flask response object, will evaluate if it was an error :param key: The function name :param time_delta: Optional time it took for the endpoint to execute """ if 200 <= response.status_code < 400: self.incr_stats("success", key) else: self.incr_stats("error", key) if time_delta: self.timing_stats("time", key, time_delta) @event_logger.log_this_with_context( action=lambda self, *args, **kwargs: f"{self.__class__.__name__}.info", object_ref=False, log_to_statsd=False, ) def info_headless(self, **kwargs: Any) -> Response: """ Add statsd metrics to builtin FAB _info endpoint """ duration, response = time_function(super().info_headless, **kwargs) self.send_stats_metrics(response, self.info.__name__, duration) return response @event_logger.log_this_with_context( action=lambda self, *args, **kwargs: f"{self.__class__.__name__}.get", object_ref=False, log_to_statsd=False, ) def get_headless(self, pk: int, **kwargs: Any) -> Response: """ Add statsd metrics to builtin FAB GET endpoint """ duration, response = time_function(super().get_headless, pk, **kwargs) self.send_stats_metrics(response, self.get.__name__, duration) return response @event_logger.log_this_with_context( action=lambda self, *args, **kwargs: f"{self.__class__.__name__}.get_list", object_ref=False, log_to_statsd=False, ) def get_list_headless(self, **kwargs: Any) -> Response: """ Add statsd metrics to builtin FAB GET list endpoint """ duration, response = time_function(super().get_list_headless, **kwargs) self.send_stats_metrics(response, self.get_list.__name__, duration) return response @event_logger.log_this_with_context( action=lambda self, *args, **kwargs: f"{self.__class__.__name__}.post", object_ref=False, log_to_statsd=False, ) def post_headless(self) -> Response: """ Add statsd metrics to builtin FAB POST endpoint """ duration, response = time_function(super().post_headless) self.send_stats_metrics(response, self.post.__name__, duration) return response @event_logger.log_this_with_context( action=lambda self, *args, **kwargs: f"{self.__class__.__name__}.put", object_ref=False, log_to_statsd=False, ) def put_headless(self, pk: int) -> Response: """ Add statsd metrics to builtin FAB PUT endpoint """ duration, response = time_function(super().put_headless, pk) self.send_stats_metrics(response, self.put.__name__, duration) return response @event_logger.log_this_with_context( action=lambda self, *args, **kwargs: f"{self.__class__.__name__}.delete", object_ref=False, log_to_statsd=False, ) def delete_headless(self, pk: int) -> Response: """ Add statsd metrics to builtin FAB DELETE endpoint """ duration, response = time_function(super().delete_headless, pk) self.send_stats_metrics(response, self.delete.__name__, duration) return response @expose("/related/<column_name>", methods=["GET"]) @protect() @safe @statsd_metrics @rison(get_related_schema) def related(self, column_name: str, **kwargs: Any) -> FlaskResponse: """Get related fields data --- get: parameters: - in: path schema: type: string name: column_name - in: query name: q content: application/json: schema: $ref: '#/components/schemas/get_related_schema' responses: 200: description: Related column data content: application/json: schema: schema: $ref: "#/components/schemas/RelatedResponseSchema" 400: $ref: '#/components/responses/400' 401: $ref: '#/components/responses/401' 404: $ref: '#/components/responses/404' 500: $ref: '#/components/responses/500' """ if column_name not in self.allowed_rel_fields: self.incr_stats("error", self.related.__name__) return self.response_404() args = kwargs.get("rison", {}) # handle pagination page, page_size = self._handle_page_args(args) try: datamodel = self.datamodel.get_related_interface(column_name) except KeyError: return self.response_404() page, page_size = self._sanitize_page_args(page, page_size) # handle ordering order_field = self.order_rel_fields.get(column_name) if order_field: order_column, order_direction = order_field else: order_column, order_direction = "", "" # handle filters filters = self._get_related_filter(datamodel, column_name, args.get("filter")) # Make the query _, rows = datamodel.query( filters, order_column, order_direction, page=page, page_size=page_size ) # produce response result = self._get_result_from_rows(datamodel, rows, column_name) # If ids are specified make sure we fetch and include them on the response ids = args.get("include_ids") self._add_extra_ids_to_result(datamodel, column_name, ids, result) return self.response(200, count=len(result), result=result) @expose("/distinct/<column_name>", methods=["GET"]) @protect() @safe @statsd_metrics @rison(get_related_schema) def distinct(self, column_name: str, **kwargs: Any) -> FlaskResponse: """Get distinct values from field data --- get: parameters: - in: path schema: type: string name: column_name - in: query name: q content: application/json: schema: $ref: '#/components/schemas/get_related_schema' responses: 200: description: Distinct field data content: application/json: schema: schema: $ref: "#/components/schemas/DistincResponseSchema" 400: $ref: '#/components/responses/400' 401: $ref: '#/components/responses/401' 404: $ref: '#/components/responses/404' 500: $ref: '#/components/responses/500' """ if column_name not in self.allowed_distinct_fields: self.incr_stats("error", self.related.__name__) return self.response_404() args = kwargs.get("rison", {}) # handle pagination page, page_size = self._sanitize_page_args(*self._handle_page_args(args)) # Create generic base filters with added request filter filters = self._get_distinct_filter(column_name, args.get("filter")) # Make the query query_count = self.appbuilder.get_session.query( func.count(distinct(getattr(self.datamodel.obj, column_name))) ) count = self.datamodel.apply_filters(query_count, filters).scalar() if count == 0: return self.response(200, count=count, result=[]) query = self.appbuilder.get_session.query( distinct(getattr(self.datamodel.obj, column_name)) ) # Apply generic base filters with added request filter query = self.datamodel.apply_filters(query, filters) # Apply sort query = self.datamodel.apply_order_by(query, column_name, "asc") # Apply pagination result = self.datamodel.apply_pagination(query, page, page_size).all() # produce response result = [ {"text": item[0], "value": item[0]} for item in result if item[0] is not None ] return self.response(200, count=count, result=result)

apache-2.0

sippy/voiptests

test_cases/reinv_brkn2.py

1

2000

# Copyright (c) 2016 Sippy Software, Inc. All rights reserved. # # All rights reserved. # # Redistribution and use in source and binary forms, with or without modification, # are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, this # list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation and/or # other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR # ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON # ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. from test_cases.reinv_fail import a_test_reinv_fail from test_cases.reinvite import b_test_reinvite class a_test_reinv_brkn2(a_test_reinv_fail): cld = 'bob_reinv_brkn2' cli = 'alice_reinv_brkn2' def reinvite(self, ua): if not self.connect_done or self.disconnect_done: return sdp_body_bak = ua.lSDP ua.lSDP = sdp_body_bak.getCopy() for sect in ua.lSDP.content.sections: sect.c_header = None rval = a_test_reinv_fail.reinvite(self, ua) ua.lSDP = sdp_body_bak return rval class b_test_reinv_brkn2(b_test_reinvite): cli = 'bob_reinv_brkn2'

bsd-2-clause

csmart/jockey-yum

setup.py

1

1204

#!/usr/bin/env python # (c) 2007 Canonical Ltd. # Author: Martin Pitt <martin.pitt@ubuntu.com> # This script needs python-distutils-extra, an extension to the standard # distutils which provides i18n, icon support, etc. # https://launchpad.net/python-distutils-extra from glob import glob from distutils.version import StrictVersion try: import DistUtilsExtra.auto except ImportError: import sys print >> sys.stderr, 'To build Jockey you need https://launchpad.net/python-distutils-extra' sys.exit(1) assert StrictVersion(DistUtilsExtra.auto.__version__) >= '2.4', 'needs DistUtilsExtra.auto >= 2.4' DistUtilsExtra.auto.setup( name='jockey', version='0.9.3', description='UI for managing third-party and non-free drivers', url='https://launchpad.net/jockey', license='GPL v2 or later', author='Martin Pitt', author_email='martin.pitt@ubuntu.com', data_files = [ ('share/jockey', ['backend/jockey-backend']), ('share/jockey', ['gtk/jockey-gtk.ui']), # bug in DistUtilsExtra.auto 2.2 ('share/jockey', glob('kde/*.ui')), # don't use pykdeuic4 ], scripts = ['gtk/jockey-gtk', 'kde/jockey-kde', 'text/jockey-text'], )

gpl-2.0

gersolar/stations

stations_configuration/settings.py

1

5198

# Only Celery settings for stations project. #import djcelery #djcelery.setup_loader() #BROKER_TRANSPORT = 'amqplib' #BROKER_URL = 'django://' ##CELERY_RESULT_BACKEND = 'database' #CELERY_DEFAULT_QUEUE = "default" #CELERY_QUEUES = { # "default": { # "binding_key": "task.#", # }, # "mailer": { # "binding_key": "task.#", # }, #} #CELERY_ROUTES = {'downloader.tasks.check_email_schedule': {'queue': 'mailer'}} #CELERY_TIMEZONE = 'UTC' #CELERY_CONCURRENCY = 7 # Django settings for stations project. DEBUG = True TEMPLATE_DEBUG = DEBUG ADMINS = ( # ('Your Name', 'your_email@example.com'), ) MANAGERS = ADMINS DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'stations.sqlite3', } } # Local time zone for this installation. Choices can be found here: # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name # although not all choices may be available on all operating systems. # In a Windows environment this must be set to your system time zone. TIME_ZONE = 'UTC' # 'America/Buenos_Aires' # Language code for this installation. All choices can be found here: # http://www.i18nguy.com/unicode/language-identifiers.html LANGUAGE_CODE = 'en-us' SITE_ID = 1 # If you set this to False, Django will make some optimizations so as not # to load the internationalization machinery. USE_I18N = True # If you set this to False, Django will not format dates, numbers and # calendars according to the current locale. USE_L10N = True # If you set this to False, Django will not use timezone-aware datetimes. USE_TZ = True # Absolute filesystem path to the directory that will hold user-uploaded files. # Example: "/home/media/media.lawrence.com/media/" MEDIA_ROOT = '' # URL that handles the media served from MEDIA_ROOT. Make sure to use a # trailing slash. # Examples: "http://media.lawrence.com/media/", "http://example.com/media/" MEDIA_URL = '' # Absolute path to the directory static files should be collected to. # Don't put anything in this directory yourself; store your static files # in apps' "static/" subdirectories and in STATICFILES_DIRS. # Example: "/home/media/media.lawrence.com/static/" STATIC_ROOT = '' # URL prefix for static files. # Example: "http://media.lawrence.com/static/" STATIC_URL = '/static/' # Additional locations of static files STATICFILES_DIRS = ( # Put strings here, like "/home/html/static" or "C:/www/django/static". # Always use forward slashes, even on Windows. # Don't forget to use absolute paths, not relative paths. ) # List of finder classes that know how to find static files in # various locations. STATICFILES_FINDERS = ( 'django.contrib.staticfiles.finders.FileSystemFinder', 'django.contrib.staticfiles.finders.AppDirectoriesFinder', # 'django.contrib.staticfiles.finders.DefaultStorageFinder', ) # Make this unique, and don't share it with anybody. SECRET_KEY = 'fax%_3d9oshwed$!3s)jdn876jpj#5u&amp;50m$6naau#&amp;=zpyn%0' # List of callables that know how to import templates from various sources. TEMPLATE_LOADERS = ( 'django.template.loaders.filesystem.Loader', 'django.template.loaders.app_directories.Loader', # 'django.template.loaders.eggs.Loader', ) MIDDLEWARE_CLASSES = ( 'sslify.middleware.SSLifyMiddleware', 'django.middleware.common.CommonMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', # Uncomment the next line for simple clickjacking protection: # 'django.middleware.clickjacking.XFrameOptionsMiddleware', ) ROOT_URLCONF = 'stations_configuration.urls' # Python dotted path to the WSGI application used by Django's runserver. WSGI_APPLICATION = 'stations_configuration.wsgi.application' TEMPLATE_DIRS = ( # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates". # Always use forward slashes, even on Windows. # Don't forget to use absolute paths, not relative paths. ) INSTALLED_APPS = ( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.messages', 'django.contrib.staticfiles', 'polymorphic', 'django.contrib.contenttypes', # Uncomment the next line to enable the admin: 'django.contrib.admin', # Uncomment the next line to enable admin documentation: 'django.contrib.admindocs', 'stations', ) # A sample logging configuration. The only tangible logging # performed by this configuration is to send an email to # the site admins on every HTTP 500 error when DEBUG=False. # See http://docs.djangoproject.com/en/dev/topics/logging for # more details on how to customize your logging configuration. LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'filters': { 'require_debug_false': { '()': 'django.utils.log.RequireDebugFalse' } }, 'handlers': { 'mail_admins': { 'level': 'ERROR', 'filters': ['require_debug_false'], 'class': 'django.utils.log.AdminEmailHandler' } }, 'loggers': { 'django.request': { 'handlers': ['mail_admins'], 'level': 'ERROR', 'propagate': True, }, } } TEMPLATE_DIRS='templates'

mit

lizardsystem/lizard-measure

lizard_measure/migrations/0010_auto__del_score__del_measuringrod__del_field_measurestatusmoment_is_pl.py

1

23606

# encoding: utf-8 import datetime from south.db import db from south.v2 import SchemaMigration from django.db import models class Migration(SchemaMigration): def forwards(self, orm): # Deleting model 'Score' db.delete_table('lizard_measure_score') # Deleting model 'MeasuringRod' db.delete_table('lizard_measure_measuringrod') # Deleting field 'MeasureStatusMoment.is_planning' db.delete_column('lizard_measure_measurestatusmoment', 'is_planning') # Deleting field 'MeasureStatusMoment.date' db.delete_column('lizard_measure_measurestatusmoment', 'date') # Adding field 'MeasureStatusMoment.planning_date' db.add_column('lizard_measure_measurestatusmoment', 'planning_date', self.gf('django.db.models.fields.DateField')(null=True, blank=True), keep_default=False) # Adding field 'MeasureStatusMoment.realisation_date' db.add_column('lizard_measure_measurestatusmoment', 'realisation_date', self.gf('django.db.models.fields.DateField')(null=True, blank=True), keep_default=False) # Deleting field 'Measure.total_costs' db.delete_column('lizard_measure_measure', 'total_costs') # Adding field 'Measure.valid' db.add_column('lizard_measure_measure', 'valid', self.gf('django.db.models.fields.NullBooleanField')(default=False, null=True, blank=True), keep_default=False) # Adding field 'Measure.geom' db.add_column('lizard_measure_measure', 'geom', self.gf('django.contrib.gis.db.models.fields.GeometryField')(null=True, blank=True), keep_default=False) def backwards(self, orm): # Adding model 'Score' db.create_table('lizard_measure_score', ( ('gep', self.gf('django.db.models.fields.FloatField')(null=True, blank=True)), ('area_ident', self.gf('django.db.models.fields.CharField')(max_length=32, null=True, blank=True)), ('ascending', self.gf('django.db.models.fields.NullBooleanField')(null=True, blank=True)), ('mep', self.gf('django.db.models.fields.FloatField')(null=True, blank=True)), ('measuring_rod', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['lizard_measure.MeasuringRod'])), ('limit_bad_insufficient', self.gf('django.db.models.fields.FloatField')(null=True, blank=True)), ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('area', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['lizard_area.Area'], null=True, blank=True)), ('target_2027', self.gf('django.db.models.fields.FloatField')(null=True, blank=True)), ('limit_insufficient_moderate', self.gf('django.db.models.fields.FloatField')(null=True, blank=True)), ('target_2015', self.gf('django.db.models.fields.FloatField')(null=True, blank=True)), )) db.send_create_signal('lizard_measure', ['Score']) # Adding model 'MeasuringRod' db.create_table('lizard_measure_measuringrod', ( ('group', self.gf('django.db.models.fields.CharField')(max_length=128, null=True, blank=True)), ('sign', self.gf('django.db.models.fields.CharField')(max_length=128, null=True, blank=True)), ('sub_measuring_rod', self.gf('django.db.models.fields.CharField')(max_length=128, null=True, blank=True)), ('measuring_rod', self.gf('django.db.models.fields.CharField')(max_length=128, null=True, blank=True)), ('id', self.gf('django.db.models.fields.IntegerField')(primary_key=True)), ('unit', self.gf('django.db.models.fields.CharField')(max_length=128, null=True, blank=True)), )) db.send_create_signal('lizard_measure', ['MeasuringRod']) # Adding field 'MeasureStatusMoment.is_planning' db.add_column('lizard_measure_measurestatusmoment', 'is_planning', self.gf('django.db.models.fields.BooleanField')(default=False), keep_default=False) # Adding field 'MeasureStatusMoment.date' db.add_column('lizard_measure_measurestatusmoment', 'date', self.gf('django.db.models.fields.DateField')(null=True, blank=True), keep_default=False) # Deleting field 'MeasureStatusMoment.planning_date' db.delete_column('lizard_measure_measurestatusmoment', 'planning_date') # Deleting field 'MeasureStatusMoment.realisation_date' db.delete_column('lizard_measure_measurestatusmoment', 'realisation_date') # Adding field 'Measure.total_costs' db.add_column('lizard_measure_measure', 'total_costs', self.gf('django.db.models.fields.IntegerField')(null=True, blank=True), keep_default=False) # Deleting field 'Measure.valid' db.delete_column('lizard_measure_measure', 'valid') # Deleting field 'Measure.geom' db.delete_column('lizard_measure_measure', 'geom') models = { 'auth.group': { 'Meta': {'object_name': 'Group'}, 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}), 'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}) }, 'auth.permission': { 'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'}, 'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}) }, 'auth.user': { 'Meta': {'object_name': 'User'}, 'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}), 'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}), 'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}), 'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}), 'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}), 'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}), 'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}), 'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}), 'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}), 'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}), 'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'}) }, 'contenttypes.contenttype': { 'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"}, 'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}) }, 'lizard_area.area': { 'Meta': {'ordering': "('name',)", 'object_name': 'Area', '_ormbases': ['lizard_area.Communique']}, 'area_class': ('django.db.models.fields.IntegerField', [], {'default': '1'}), 'communique_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['lizard_area.Communique']", 'unique': 'True', 'primary_key': 'True'}), 'data_administrator': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_area.DataAdministrator']"}), 'parent': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_area.Area']", 'null': 'True', 'blank': 'True'}) }, 'lizard_area.communique': { 'Meta': {'object_name': 'Communique', '_ormbases': ['lizard_geo.GeoObject']}, 'code': ('django.db.models.fields.CharField', [], {'max_length': '128', 'null': 'True', 'blank': 'True'}), 'description': ('django.db.models.fields.TextField', [], {'default': "''"}), 'geoobject_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['lizard_geo.GeoObject']", 'unique': 'True', 'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '128'}) }, 'lizard_area.dataadministrator': { 'Meta': {'object_name': 'DataAdministrator'}, 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '128'}) }, 'lizard_geo.geoobject': { 'Meta': {'object_name': 'GeoObject'}, 'geo_object_group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_geo.GeoObjectGroup']"}), 'geometry': ('django.contrib.gis.db.models.fields.GeometryField', [], {}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'ident': ('django.db.models.fields.CharField', [], {'max_length': '80'}) }, 'lizard_geo.geoobjectgroup': { 'Meta': {'object_name': 'GeoObjectGroup'}, 'created_by': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'last_modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '128'}), 'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '50', 'db_index': 'True'}), 'source_log': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}) }, 'lizard_measure.fundingorganization': { 'Meta': {'object_name': 'FundingOrganization'}, 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'measure': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.Measure']"}), 'organization': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.Organization']"}), 'percentage': ('django.db.models.fields.FloatField', [], {}) }, 'lizard_measure.krwstatus': { 'Meta': {'object_name': 'KRWStatus'}, 'code': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '32'}), 'description': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'valid': ('django.db.models.fields.NullBooleanField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}) }, 'lizard_measure.krwwatertype': { 'Meta': {'object_name': 'KRWWatertype'}, 'code': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '32'}), 'description': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}), 'group': ('django.db.models.fields.CharField', [], {'max_length': '64', 'null': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'valid': ('django.db.models.fields.NullBooleanField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}) }, 'lizard_measure.measure': { 'Meta': {'ordering': "('id',)", 'object_name': 'Measure'}, 'aggregation_type': ('django.db.models.fields.IntegerField', [], {'default': '1'}), 'areas': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'area_measure_set'", 'blank': 'True', 'to': "orm['lizard_area.Area']"}), 'categories': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['lizard_measure.MeasureCategory']", 'symmetrical': 'False', 'blank': 'True'}), 'datetime_in_source': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}), 'description': ('django.db.models.fields.CharField', [], {'max_length': '512', 'null': 'True', 'blank': 'True'}), 'executive': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'executive_measure_set'", 'null': 'True', 'to': "orm['lizard_measure.Organization']"}), 'exploitation_costs': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}), 'funding_organizations': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['lizard_measure.Organization']", 'through': "orm['lizard_measure.FundingOrganization']", 'symmetrical': 'False'}), 'geom': ('django.contrib.gis.db.models.fields.GeometryField', [], {'null': 'True', 'blank': 'True'}), 'geometry': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_geo.GeoObject']", 'null': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'ident': ('django.db.models.fields.CharField', [], {'max_length': '64', 'unique': 'True', 'null': 'True', 'blank': 'True'}), 'import_raw': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}), 'import_source': ('django.db.models.fields.IntegerField', [], {'default': '3'}), 'initiator': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'initiator_measure_set'", 'null': 'True', 'to': "orm['lizard_measure.Organization']"}), 'investment_costs': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}), 'is_KRW_measure': ('django.db.models.fields.NullBooleanField', [], {'null': 'True', 'blank': 'True'}), 'is_indicator': ('django.db.models.fields.BooleanField', [], {'default': 'False'}), 'measure_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.MeasureType']"}), 'parent': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.Measure']", 'null': 'True', 'blank': 'True'}), 'period': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.MeasurePeriod']", 'null': 'True', 'blank': 'True'}), 'read_only': ('django.db.models.fields.BooleanField', [], {'default': 'False'}), 'responsible_department': ('django.db.models.fields.CharField', [], {'max_length': '256'}), 'status_moments': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['lizard_measure.MeasureStatus']", 'through': "orm['lizard_measure.MeasureStatusMoment']", 'symmetrical': 'False'}), 'title': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}), 'unit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.Unit']"}), 'valid': ('django.db.models.fields.NullBooleanField', [], {'default': 'False', 'null': 'True', 'blank': 'True'}), 'value': ('django.db.models.fields.FloatField', [], {}), 'waterbodies': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['lizard_measure.WaterBody']", 'symmetrical': 'False', 'blank': 'True'}) }, 'lizard_measure.measurecategory': { 'Meta': {'object_name': 'MeasureCategory'}, 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '200'}), 'valid': ('django.db.models.fields.NullBooleanField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}) }, 'lizard_measure.measureperiod': { 'Meta': {'ordering': "('start_date', 'end_date')", 'object_name': 'MeasurePeriod'}, 'description': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}), 'end_date': ('django.db.models.fields.DateField', [], {}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'start_date': ('django.db.models.fields.DateField', [], {}), 'valid': ('django.db.models.fields.NullBooleanField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}) }, 'lizard_measure.measurestatus': { 'Meta': {'ordering': "('-value',)", 'object_name': 'MeasureStatus'}, 'color': ('lizard_map.models.ColorField', [], {'max_length': '8'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '200'}), 'valid': ('django.db.models.fields.NullBooleanField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}), 'value': ('django.db.models.fields.FloatField', [], {'default': '0.0'}) }, 'lizard_measure.measurestatusmoment': { 'Meta': {'ordering': "('measure__id', 'status__value')", 'object_name': 'MeasureStatusMoment'}, 'description': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}), 'exploitation_expenditure': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'investment_expenditure': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}), 'measure': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.Measure']"}), 'planning_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}), 'realisation_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}), 'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.MeasureStatus']"}) }, 'lizard_measure.measuretype': { 'Meta': {'ordering': "('code',)", 'object_name': 'MeasureType'}, 'code': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}), 'combined_name': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}), 'description': ('django.db.models.fields.TextField', [], {}), 'group': ('django.db.models.fields.CharField', [], {'max_length': '128', 'null': 'True', 'blank': 'True'}), 'harmonisation': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'klass': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}), 'subcategory': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}), 'units': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['lizard_measure.Unit']", 'symmetrical': 'False', 'blank': 'True'}), 'valid': ('django.db.models.fields.NullBooleanField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}) }, 'lizard_measure.organization': { 'Meta': {'ordering': "('description',)", 'unique_together': "(('source', 'code'),)", 'object_name': 'Organization'}, 'code': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}), 'description': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}), 'group': ('django.db.models.fields.CharField', [], {'max_length': '128', 'null': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'source': ('django.db.models.fields.IntegerField', [], {'default': '5'}), 'valid': ('django.db.models.fields.NullBooleanField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}) }, 'lizard_measure.steeringparameter': { 'Meta': {'object_name': 'SteeringParameter'}, 'area': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_area.Area']"}), 'fews_parameter': ('django.db.models.fields.CharField', [], {'max_length': '256'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'target_maximum': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'}), 'target_minimum': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'}) }, 'lizard_measure.unit': { 'Meta': {'object_name': 'Unit'}, 'code': ('django.db.models.fields.CharField', [], {'max_length': '20', 'unique': 'True', 'null': 'True', 'blank': 'True'}), 'conversion_factor': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'}), 'description': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}), 'dimension': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}), 'group': ('django.db.models.fields.CharField', [], {'max_length': '128', 'null': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'valid': ('django.db.models.fields.NullBooleanField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}) }, 'lizard_measure.waterbody': { 'Meta': {'object_name': 'WaterBody'}, 'area': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_area.Area']", 'null': 'True', 'blank': 'True'}), 'area_ident': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'krw_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.KRWStatus']", 'null': 'True', 'blank': 'True'}), 'krw_watertype': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['lizard_measure.KRWWatertype']", 'null': 'True', 'blank': 'True'}) } } complete_apps = ['lizard_measure']

gpl-3.0

konrad/kufpybio

kufpybiotools/generate_igr_gff.py

1

1881

#!/usr/bin/env python __description__ = "" __author__ = "Konrad Foerstner <konrad@foerstner.org>" __copyright__ = "2013 by Konrad Foerstner <konrad@foerstner.org>" __license__ = "ISC license" __email__ = "konrad@foerstner.org" __version__ = "" import argparse import csv import sys sys.path.append(".") from kufpybio.gff3 import Gff3Parser, Gff3Entry from kufpybio.gene import Gene from kufpybio.igrfinder import IGRFinder parser = argparse.ArgumentParser(description=__description__) parser.add_argument("gff_file", type=argparse.FileType("r")) parser.add_argument("output_file", type=argparse.FileType("w")) parser.add_argument("--margin", type=int, default=0) parser.add_argument("--plus_only", default=False, action="store_true") args = parser.parse_args() # Build gene list gene_list = [] gff_parser = Gff3Parser() region_entry = None for entry in gff_parser.entries(args.gff_file): if entry.feature == "region": region_entry = entry continue gene_list.append(Gene( entry.seq_id, "", "", entry.start, entry.end, entry.strand)) # Find IGRs and generate GFF file igr_finder = IGRFinder() args.output_file.write("##gff-version 3\n") strands = ["+", "-"] if args.plus_only is True: strands = ["+"] for start, end in igr_finder.find_igrs(gene_list, region_entry.end): start = start + args.margin end = end - args.margin if end <= start: continue for strand in strands: gff3_entry = Gff3Entry({ "seq_id" : region_entry.seq_id, "source" : "IGR", "feature" : "IGR", "start" : start, "end" : end, "score" : ".", "strand" : strand, "phase" : ".", "attributes" : "ID=IGR_%s_%s_to_%s" % ( region_entry.seq_id, start, end)}) args.output_file.write(str(gff3_entry) + "\n")

isc

jakobmoss/tsa

utils/makeweights.py

1

2350

# -*- coding: utf-8 -*- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Time Series Analysis -- Generate statistical weigts from scatter # # Author: Jakob Rørsted Mosumgaard # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ############################################################################### # Modules ############################################################################### from __future__ import print_function, with_statement, division import numpy as np import bottleneck as bn ############################################################################### # Functions ############################################################################### def genweight(datname, dpath, wpath): """ Combine time series with statistical weights calculated from scatter Arguments: - `datname`: Identifier of data file - `dpath` : Path to data file (time series). - `wpath` : Path to scatter file (with same time points!) """ # Pretty print print('Generating weights for {0} !'.format(dpath)) # Load data and weights t, d = np.loadtxt(dpath, unpack=True) tt, sig = np.loadtxt(wpath, unpack=True) # Check that times are indeed the same tdif = t - tt if tdif.any() != 0: print('Error! Not the same time points! Quitting!') exit() # Moving variance (Hans: M = 50 - 100) M = 70 movstd = bn.move_std(sig, M, min_count=1) movvar = np.square(movstd) # Remove first point x = 1 t = t[x:] d = d[x:] movvar = movvar[x:] # Calculate weights from scatter (1 / variance) w = np.divide(1.0, movvar) # Save outfile = star + '_with-weights.txt' np.savetxt(outfile, np.transpose([t, d, w]), fmt='%.15e', delimiter='\t') # Done! print('Done!\n') ############################################################################### # Script ############################################################################### if __name__ == "__main__": # Definitions datdir = '../../data/' ext = '.txt' append = '-high' # Run for star 1 star = 'star01' genweight(star, datdir + star + ext, star + append + ext) # Run for star 2 star = 'star02' genweight(star, datdir + star + ext, star + append + ext)

mit

erstis-go-botting/sexy-bot

misc.py

1

1888

import os #checks if settings.ini should be generated. if not given universe, username and password it will generate a settings.ini with the default account #This settings_generator will only work for universe 82 if the flag argument is given als True(to make sure that universe 82 is intended) def settings_generator(universe = 82, username = 'defaultName', password = 'defaultPassword', flag=False): path = os.path.normcase('settings/settings.ini') if (os.path.isfile('settings/settings.ini')): print("settings file found, stopping now.") return if (universe == 82 and not(flag)) or (username == 'defaultName') or (password == 'defaultPassword'): print("Not all fields specified, fallback on default configuration") universe = 82 username = 'defaultName' password = 'defaultPassword' if not (os.path.isdir('settings')): os.makedir('settings') with open(path,'w') as foo: foo.write('[credentials]\nuniverse = '+ str(universe) +'\npassword = '+password+'\nusername = '+username) print("Settings.ini generated") def force_settings_generator(universe = 82, username = 'defaultName', password = 'defaultPassword', flag=False): path = os.path.normcase('settings/settings.ini') if not (os.path.isfile('settings/settings.ini')): settings_generator(universe, username, password, flag) return if (universe == 82 and not(flag)) or (username == 'defaultName') or (password == 'defaultPassword'): print("Not all fields specified, fallback on default configuration") universe = 82 username = 'defaultName' password = 'defaultPassword' with open(path,'w') as foo: foo.write('[credentials]\nuniverse = '+ str(universe) +'\npassword = '+password+'\nusername = '+username) print("Settings.ini generated") #settings_generator()

mit

ActiveState/code

recipes/Python/275366_Email_address_leech/recipe-275366.py

1

1624

import re def test(): text = \ ''' You can contact us at myname@server.site.com or at yourname AT server DOT site DOT com. Also at o u r n a m e @ s e r v e r dot s i t e dot c o m and t.h.e.i.r.n.a.m.e at server dot s/i/t/e DOT COM. ''' for email in emailLeech(text): print email DOMAINS = ["com","edu","net","org","gov","us"] #.. and so on FLAGS = re.IGNORECASE | re.VERBOSE AT = r'(?: @ | \b A \s* T \b)' ADDRESSPART = r'\b (?: \w+ | \w (?:(?:\s+|\W) \w)*) \b' DOMAIN = r'(?:%s)' % '|'.join(["(?:\s*|\W)".join(domain) for domain in DOMAINS]) NONWORD = re.compile(r'\W+') DOT_REGEX = re.compile(r'(?: \. | \b D \s* O \s* T \b)', FLAGS) EMAIL_REGEX = re.compile( (r'(?P<name>%s) \W* %s \W*' % (ADDRESSPART,AT)) + r'(?P<site>(?: %s \W* %s \W*)+)' % (ADDRESSPART, DOT_REGEX.pattern) + r'(?P<domain>%s)' % DOMAIN, FLAGS) def emailLeech(text): ''' An iterator over recognized email addresses within text''' while (True): match = EMAIL_REGEX.search(text) if not match: break parts = [match.group("name")] + \ DOT_REGEX.split(match.group("site")) + \ [match.group("domain")] # discard non word chars parts = [NONWORD.sub('',part) for part in parts] # discard all empty parts and make lowercase parts = [part.lower() for part in parts if len(part)>0] # join the parts yield "%s@%s.%s" % (parts[0], '.'.join(parts[1:-1]), parts[-1]) text = text[match.end():] if __name__ == '__main__': test()

mit

mosdef-hub/foyer

foyer/tests/test_forcefield_parameters.py

1

10029

import numpy as np import pytest from foyer import Forcefield, forcefields from foyer.exceptions import MissingForceError, MissingParametersError from foyer.forcefield import get_available_forcefield_loaders from foyer.tests.base_test import BaseTest from foyer.tests.utils import get_fn @pytest.mark.skipif( condition="load_GAFF" not in map(lambda func: func.__name__, get_available_forcefield_loaders()), reason="GAFF Plugin is not installed", ) class TestForcefieldParameters(BaseTest): @pytest.fixture(scope="session") def gaff(self): return forcefields.load_GAFF() def test_gaff_missing_group(self, gaff): with pytest.raises(ValueError): gaff.get_parameters("missing", key=[]) def test_gaff_non_string_keys(self, gaff): with pytest.raises(TypeError): gaff.get_parameters("atoms", key=1) def test_gaff_bond_parameters_gaff(self, gaff): bond_params = gaff.get_parameters("harmonic_bonds", ["br", "ca"]) assert np.isclose(bond_params["length"], 0.19079) assert np.isclose(bond_params["k"], 219827.36) def test_gaff_bond_params_reversed(self, gaff): assert gaff.get_parameters( "harmonic_bonds", ["ca", "br"] ) == gaff.get_parameters("harmonic_bonds", ["ca", "br"]) def test_gaff_missing_bond_parameters(self, gaff): with pytest.raises(MissingParametersError): gaff.get_parameters("harmonic_bonds", ["str1", "str2"]) def test_gaff_angle_parameters(self, gaff): angle_params = gaff.get_parameters("harmonic_angles", ["f", "c1", "f"]) assert np.allclose( [angle_params["theta"], angle_params["k"]], [3.141592653589793, 487.0176], ) def test_gaff_angle_parameters_reversed(self, gaff): assert np.allclose( list( gaff.get_parameters( "harmonic_angles", ["f", "c2", "ha"] ).values() ), list( gaff.get_parameters( "harmonic_angles", ["ha", "c2", "f"] ).values() ), ) def test_gaff_missing_angle_parameters(self, gaff): with pytest.raises(MissingParametersError): gaff.get_parameters("harmonic_angles", ["1", "2", "3"]) def test_gaff_periodic_proper_parameters(self, gaff): periodic_proper_params = gaff.get_parameters( "periodic_propers", ["c3", "c", "sh", "hs"] ) assert np.allclose(periodic_proper_params["periodicity"], [2.0, 1.0]) assert np.allclose( periodic_proper_params["k"], [9.414, 5.4392000000000005] ) assert np.allclose( periodic_proper_params["phase"], [3.141592653589793, 3.141592653589793], ) def test_gaff_periodic_proper_parameters_reversed(self, gaff): assert np.allclose( list( gaff.get_parameters( "periodic_propers", ["c3", "c", "sh", "hs"] ).values() ), list( gaff.get_parameters( "periodic_propers", ["hs", "sh", "c", "c3"] ).values() ), ) def test_gaff_periodic_improper_parameters(self, gaff): periodic_improper_params = gaff.get_parameters( "periodic_impropers", ["c", "", "o", "o"] ) assert np.allclose(periodic_improper_params["periodicity"], [2.0]) assert np.allclose(periodic_improper_params["k"], [4.6024]) assert np.allclose( periodic_improper_params["phase"], [3.141592653589793] ) def test_gaff_periodic_improper_parameters_reversed(self, gaff): assert np.allclose( list( gaff.get_parameters( "periodic_impropers", ["c", "", "o", "o"] ).values() ), list( gaff.get_parameters( "periodic_impropers", ["c", "o", "", "o"] ).values() ), ) def test_gaff_proper_params_missing(self, gaff): with pytest.raises(MissingParametersError): gaff.get_parameters("periodic_impropers", ["a", "b", "c", "d"]) def test_gaff_scaling_factors(self, gaff): assert gaff.lj14scale == 0.5 assert np.isclose(gaff.coulomb14scale, 0.833333333) def test_opls_get_parameters_atoms(self, oplsaa): atom_params = oplsaa.get_parameters("atoms", "opls_145") assert atom_params["sigma"] == 0.355 assert atom_params["epsilon"] == 0.29288 def test_opls_get_parameters_atoms_list(self, oplsaa): atom_params = oplsaa.get_parameters("atoms", ["opls_145"]) assert atom_params["sigma"] == 0.355 assert atom_params["epsilon"] == 0.29288 def test_opls_get_parameters_atom_class(self, oplsaa): atom_params = oplsaa.get_parameters( "atoms", "CA", keys_are_atom_classes=True ) assert atom_params["sigma"] == 0.355 assert atom_params["epsilon"] == 0.29288 def test_opls_get_parameters_bonds(self, oplsaa): bond_params = oplsaa.get_parameters( "harmonic_bonds", ["opls_760", "opls_145"] ) assert bond_params["length"] == 0.146 assert bond_params["k"] == 334720.0 def test_opls_get_parameters_bonds_reversed(self, oplsaa): assert np.allclose( list( oplsaa.get_parameters( "harmonic_bonds", ["opls_760", "opls_145"] ).values() ), list( oplsaa.get_parameters( "harmonic_bonds", ["opls_145", "opls_760"] ).values() ), ) def test_opls_get_parameters_bonds_atom_classes_reversed(self, oplsaa): assert np.allclose( list( oplsaa.get_parameters( "harmonic_bonds", ["C_2", "O_2"], True ).values() ), list( oplsaa.get_parameters( "harmonic_bonds", ["O_2", "C_2"], True ).values() ), ) def test_opls_get_parameters_angle(self, oplsaa): angle_params = oplsaa.get_parameters( "harmonic_angles", ["opls_166", "opls_772", "opls_167"] ) assert np.allclose( [angle_params["theta"], angle_params["k"]], [2.0943950239, 585.76] ) def test_opls_get_parameters_angle_reversed(self, oplsaa): assert np.allclose( list( oplsaa.get_parameters( "harmonic_angles", ["opls_166", "opls_772", "opls_167"] ).values() ), list( oplsaa.get_parameters( "harmonic_angles", ["opls_167", "opls_772", "opls_166"] ).values() ), ) def test_opls_get_parameters_angle_atom_classes(self, oplsaa): angle_params = oplsaa.get_parameters( "harmonic_angles", ["CA", "C_2", "CA"], keys_are_atom_classes=True ) assert np.allclose( [angle_params["theta"], angle_params["k"]], [2.09439510239, 711.28] ) def test_opls_get_parameters_angle_atom_classes_reversed(self, oplsaa): assert np.allclose( list( oplsaa.get_parameters( "harmonic_angles", ["CA", "C", "O"], keys_are_atom_classes=True, ).values() ), list( oplsaa.get_parameters( "harmonic_angles", ["O", "C", "CA"], keys_are_atom_classes=True, ).values() ), ) def test_opls_get_parameters_rb_proper(self, oplsaa): proper_params = oplsaa.get_parameters( "rb_propers", ["opls_215", "opls_215", "opls_235", "opls_269"] ) assert np.allclose( [ proper_params["c0"], proper_params["c1"], proper_params["c2"], proper_params["c3"], proper_params["c4"], proper_params["c5"], ], [2.28446, 0.0, -2.28446, 0.0, 0.0, 0.0], ) def test_get_parameters_rb_proper_reversed(self, oplsaa): assert np.allclose( list( oplsaa.get_parameters( "rb_propers", ["opls_215", "opls_215", "opls_235", "opls_269"], ).values() ), list( oplsaa.get_parameters( "rb_propers", ["opls_269", "opls_235", "opls_215", "opls_215"], ).values() ), ) def test_opls_get_parameters_wildcard(self, oplsaa): proper_params = oplsaa.get_parameters( "rb_propers", ["", "opls_235", "opls_544", ""] ) assert np.allclose( [ proper_params["c0"], proper_params["c1"], proper_params["c2"], proper_params["c3"], proper_params["c4"], proper_params["c5"], ], [30.334, 0.0, -30.334, 0.0, 0.0, 0.0], ) def test_opls_missing_force(self, oplsaa): with pytest.raises(MissingForceError): oplsaa.get_parameters("periodic_propers", key=["a", "b", "c", "d"]) def test_opls_scaling_factors(self, oplsaa): assert oplsaa.lj14scale == 0.5 assert oplsaa.coulomb14scale == 0.5 def test_missing_scaling_factors(self): ff = Forcefield(forcefield_files=(get_fn("validate_customtypes.xml"))) with pytest.raises(AttributeError): assert ff.lj14scale with pytest.raises(AttributeError): assert ff.coulomb14scale

mit

ecell/ecell3

ecell/pyecell/ecell/analysis/PathwayProxy.py

1

13263

#!/usr/bin/env python #:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: # # This file is part of the E-Cell System # # Copyright (C) 1996-2016 Keio University # Copyright (C) 2008-2016 RIKEN # Copyright (C) 2005-2009 The Molecular Sciences Institute # #:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: # # # E-Cell System is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # E-Cell System is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public # License along with E-Cell System -- see the file COPYING. # If not, write to the Free Software Foundation, Inc., # 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # #END_HEADER """ A program for handling and defining a pathway. This program is the extension package for E-Cell System Version 3. """ __program__ = 'PathwayProxy' __version__ = '1.0' __author__ = 'Kazunari Kaizu <kaizu@sfc.keio.ac.jp>' __coyright__ = '' __license__ = '' import ecell.eml from ecell.ecssupport import * from ecell.analysis.util import createVariableReferenceFullID import copy import numpy class PathwayProxy: def __init__( self, anEmlSupport, processList=None ): ''' anEmlSupport: Eml support object processList: (list) a list of process full path ''' self.theEmlSupport = anEmlSupport if processList: self.setProcessList( processList ) else: self.setProcessList( [] ) # end of __init__ def setProcessList( self, processList ): ''' set and detect a pathway processList: (list) a list of process full ID ''' # check the existence of processes, # and create relatedVariableList self.__processList = [] self.__variableList = [] for processFullID in processList: # if not self.theEmlSupport.isEntityExist( processFullID ): # continue self.__processList.append( processFullID ) try: aVariableReferenceList = self.theEmlSupport.getEntityProperty( processFullID + ':VariableReferenceList' ) except AttributeError, e: continue for aVariableReference in aVariableReferenceList: fullID = createVariableReferenceFullID( aVariableReference[ 1 ], processFullID ) fullIDString = ecell.ecssupport.createFullIDString( fullID ) if self.__variableList.count( fullIDString ) == 0: self.__variableList.append( fullIDString ) self.__processList.sort() self.__variableList.sort() # end of setProcessList def getProcessList( self ): ''' return processList ''' return copy.copy( self.__processList ) # end of getProcessList def addProcess( self, processFullID ): ''' add a process to the pathway processFullID: (str) a process full ID ''' if not self.__processList.count( processFullID ) == 0: return # elif not ecell.eml.Eml.isEntityExist( processFullID ): # return # add process self.__processList.append( processFullID ) self.__processList.sort() # update the related variable list try: aVariableReferenceList = self.theEmlSupport.getEntityProperty( processFullID + ':VariableReferenceList' ) except AttributeError, e: return for aVariableReference in aVariableReferenceList: fullID = createVariableReferenceFullID( aVariableReference[ 1 ], processFullID ) fullIDString = ecell.ecssupport.createFullIDString( fullID ) if self.__variableList.count( fullIDString ) == 0: self.__variableList.append( fullIDString ) self.__variableList.sort() # end of addProcess def removeProcess( self, processIndexList ): ''' remove processes from the pathway processIndexList: (list) a list of indices of processes ''' indexList = copy.copy( processIndexList ) indexList.sort() indexList.reverse() removedProcessList = [] for i in indexList: if len( self.__processList ) > i: removedProcessList.append( self.__processList.pop( i ) ) removedVariableList = [] for processFullID in removedProcessList: # if not ecell.eml.Eml.isEntityExist( self.theEmlSupport, processFullID ): # continue try: aVariableReferenceList = self.theEmlSupport.getEntityProperty( processFullID + ':VariableReferenceList' ) except AttributeError, e: continue for aVariableReference in aVariableReferenceList: fullID = createVariableReferenceFullID( aVariableReference[ 1 ], processFullID ) fullIDString = ecell.ecssupport.createFullIDString( fullID ) if removedVariableList.count( fullIDString ) == 0: removedVariableList.append( fullIDString ) for processFullID in self.__processList: # if not self.theEmlSupport.isEntityExist( processFullID ): # continue try: aVariableReferenceList = self.theEmlSupport.getEntityProperty( processFullID + ':VariableReferenceList' ) except AttributeError, e: continue for aVariableReference in aVariableReferenceList: fullID = createVariableReferenceFullID( aVariableReference[ 1 ], processFullID ) fullIDString = ecell.ecssupport.createFullIDString( fullID ) if not removedVariableList.count( fullIDString ) == 0: removedVariableList.remove( fullIDString ) for variableFullID in removedVariableList: self.__variableList.remove( variableFullID ) # end of removeProcess def take( self, processIndexList ): ''' create and return a sub-pathway processIndexList: (list) a list of indices of processes return PathwayProxy ''' processList = [] for i in processIndexList: if len( self.__processList ) > i: processList.append( self.__processList[ i ] ) subPathway = PathwayProxy( self.theEmlSupport, processList ) return subPathway # end of removeProcess def getVariableList( self ): ''' return relatedVariableList ''' return copy.copy( self.__variableList ) # end of getVariableList def removeVariable( self, variableIndexList ): ''' remove variables from the pathway variableIndexList: (list) a list of indices of variables ''' indexList = copy.copy( variableIndexList ) indexList.sort() indexList.reverse() for i in indexList: if len( self.__variableList ) > i: self.__variableList.pop( i ) # end of removeVariable def addVariable( self, variableFullID ): ''' recover a removed variable to the pathway variableFullID: (str) a variable full ID ''' if not self.__variableList.count( variableFullID ) == 0: return 1 # elif not ecell.eml.Eml.isEntityExist( variableFullID ): # return 0 for processFullID in self.__processList: try: aVariableReferenceList = self.theEmlSupport.getEntityProperty( processFullID + ':VariableReferenceList' ) except AttributeError, e: continue for aVariableReference in aVariableReferenceList: fullID = createVariableReferenceFullID( aVariableReference[ 1 ], processFullID ) fullIDString = fullID[ 1 ] + ':' + fullID[ 2 ] if fullIDString == variableFullID: self.__variableList.append( variableFullID ) self.__variableList.sort() return 1 return 0 # end of addProcess def getIncidentMatrix( self, mode=0 ): ''' create the incident matrix (array) mode: (0 or 1) 0 means that only the \'write\' variables are checked. 0 is set as default. return incidentMatrix ''' incidentMatrix = numpy.zeros( ( len( self.__variableList ), len( self.__processList ) ) ) for j in range( len( self.__processList ) ): processFullID = self.__processList[ j ] try: aVariableReferenceList = self.theEmlSupport.getEntityProperty( processFullID + ':VariableReferenceList' ) except AttributeError, e: continue for aVariableReference in aVariableReferenceList: fullID = createVariableReferenceFullID( aVariableReference[ 1 ], processFullID ) fullIDString = ecell.ecssupport.createFullIDString( fullID ) try: i = self.__variableList.index( fullIDString ) except ValueError: # should some warning message be showed? continue if mode: if len( aVariableReference ) > 2: coeff = int( aVariableReference[ 2 ] ) if coeff != 0: incidentMatrix[ i ][ j ] = 1 else: incidentMatrix[ i ][ j ] = 1 return incidentMatrix # end of getIncidentMatrix def getStoichiometryMatrix( self ): ''' create the stoichiometry matrix (array) return stoichiometryMatrix ''' stoichiometryMatrix = numpy.zeros( ( len( self.__variableList ), len( self.__processList ) ), float ) for j in range( len( self.__processList ) ): processFullID = self.__processList[ j ] try: aVariableReferenceList = self.theEmlSupport.getEntityProperty( processFullID + ':VariableReferenceList' ) except AttributeError, e: continue for aVariableReference in aVariableReferenceList: fullID = createVariableReferenceFullID( aVariableReference[ 1 ], processFullID ) fullIDString = ecell.ecssupport.createFullIDString( fullID ) try: i = self.__variableList.index( fullIDString ) except ValueError: # should some warning message be showed? continue if len( aVariableReference ) > 2: coeff = int( aVariableReference[ 2 ] ) if coeff != 0: stoichiometryMatrix[ i ][ j ] += coeff return stoichiometryMatrix # end of getStoichiometryMatrix def getReversibilityList( self ): ''' check and return the reversibilities (isReversible) for processes default value is 0, irreversible return reversibilityList ''' reversibilityList = [] for processFullID in self.__processList: propertyList = self.theEmlSupport.getEntityPropertyList( processFullID ) if propertyList.count( 'isReversible' ) != 0: # isReversible is handled as float isReversible = float( self.theEmlSupport.getEntityProperty( processFullID + ':isReversible' )[ 0 ] ) reversibilityList.append( int( isReversible ) ) else: # default value, irreversible reversibilityList.append( 0 ) return reversibilityList # end of getReversibilityList # end of PathwayProxy if __name__ == '__main__': from emlsupport import EmlSupport import sys import os def main( filename ): anEmlSupport = EmlSupport( filename ) pathwayProxy = anEmlSupport.createPathwayProxy() print 'process list =' print pathwayProxy.getProcessList() print 'related variable list =' print pathwayProxy.getVariableList() print 'incident matrix =' print pathwayProxy.getIncidentMatrix() print 'stoichiometry matrix =' print pathwayProxy.getStoichiometryMatrix() print 'reversibility list =' print pathwayProxy.getReversibilityList() # end of main if len( sys.argv ) > 1: main( sys.argv[ 1 ] ) else: filename = '../../../../doc/samples/Heinrich/Heinrich.eml' main( os.path.abspath( filename ) )

lgpl-3.0

Syralist/pixels_clock

clock.py

1

3227

# -*- coding: utf-8 -*- import pygame, led, sys, os, random, csv import smbus from pygame.locals import * from led.PixelEventHandler import * from time import gmtime, strftime """ A very simple arcade shooter demo :) """ random.seed() BLACK = pygame.Color(0,0,0) WHITE = pygame.Color(255, 255, 255) RED = pygame.Color(255, 0, 0) GREEN = pygame.Color(0, 255, 0) adress = 0x48 LM75 = smbus.SMBus(1) # detect if a serial/USB port is given as argument hasSerialPortParameter = ( sys.argv.__len__() > 1 ) # use 90 x 20 matrix when no usb port for real display provided fallbackSize = ( 90, 20 ) if hasSerialPortParameter: serialPort = sys.argv[1] print "INITIALIZING WITH USB-PORT: " + serialPort ledDisplay = led.teensy.TeensyDisplay(serialPort, fallbackSize) else: print "INITIALIZING WITH SERVER DISPLAY AND SIMULATOR." ledDisplay = led.dsclient.DisplayServerClientDisplay('localhost', 8123, fallbackSize) # use same size for sim and real LED panel size = ledDisplay.size() simDisplay = led.sim.SimDisplay(size) screen = pygame.Surface(size) gamestate = 0 #1=alive; 0=dead def main(): pygame.init() pygame.font.init() clock = pygame.time.Clock() pygame.joystick.init() gameover = False # Initialize first joystick if pygame.joystick.get_count() > 0: stick = pygame.joystick.Joystick(0) stick.init() global gamestate scored = False # Clear event list before starting the game pygame.event.clear() while not gameover: # Process event queue for pgevent in pygame.event.get(): if pgevent.type == QUIT: pygame.quit() sys.exit() event = process_event(pgevent) # End the game if event.button == EXIT: gameover = True # Keypresses on keyboard and joystick axis motions / button presses elif event.type == PUSH: # Movements if event.button == UP: pass elif event.button == DOWN: pass elif event.button == RIGHT: pass elif event.button == LEFT: pass # Tower selection elif event.button == B2: pass # Tower placement elif event.button == P1: gameover = True # Only on Keyboard elif pgevent.type == KEYDOWN and pgevent.key == K_ESCAPE: gameover = True screen.fill(BLACK) font = pygame.font.SysFont("Arial", 12) text1 = font.render(strftime("%H:%M:%S"), 0, RED) text1pos = text1.get_rect() text1pos.midtop = (screen.get_rect().centerx, -1) screen.blit(text1,text1pos) try: temp = LM75.read_byte(adress) except: temp = -1 text2 = font.render("T: "+str(temp)+"'C", 0, GREEN) text2pos = text2.get_rect() text2pos.midbottom = (screen.get_rect().centerx, 23) screen.blit(text2,text2pos) simDisplay.update(screen) ledDisplay.update(screen) clock.tick(10) main()

gpl-3.0

tylerclair/py3canvas

py3canvas/apis/modules.py

1

54047

"""Modules API Version 1.0. This API client was generated using a template. Make sure this code is valid before using it. """ import logging from datetime import date, datetime from .base import BaseCanvasAPI from .base import BaseModel class ModulesAPI(BaseCanvasAPI): """Modules API Version 1.0.""" def __init__(self, *args, **kwargs): """Init method for ModulesAPI.""" super(ModulesAPI, self).__init__(*args, **kwargs) self.logger = logging.getLogger("py3canvas.ModulesAPI") def list_modules(self, course_id, include=None, search_term=None, student_id=None): """ List modules. List the modules in a course """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # OPTIONAL - include """- "items": Return module items inline if possible. This parameter suggests that Canvas return module items directly in the Module object JSON, to avoid having to make separate API requests for each module when enumerating modules and items. Canvas is free to omit 'items' for any particular module if it deems them too numerous to return inline. Callers must be prepared to use the {api:ContextModuleItemsApiController#index List Module Items API} if items are not returned. - "content_details": Requires include['items']. Returns additional details with module items specific to their associated content items. Includes standard lock information for each item.""" if include is not None: self._validate_enum(include, ["items", "content_details"]) params["include"] = include # OPTIONAL - search_term """The partial name of the modules (and module items, if include['items'] is specified) to match and return.""" if search_term is not None: params["search_term"] = search_term # OPTIONAL - student_id """Returns module completion information for the student with this id.""" if student_id is not None: params["student_id"] = student_id self.logger.debug("GET /api/v1/courses/{course_id}/modules with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("GET", "/api/v1/courses/{course_id}/modules".format(**path), data=data, params=params, all_pages=True) def show_module(self, id, course_id, include=None, student_id=None): """ Show module. Get information about a single module """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - id """ID""" path["id"] = id # OPTIONAL - include """- "items": Return module items inline if possible. This parameter suggests that Canvas return module items directly in the Module object JSON, to avoid having to make separate API requests for each module when enumerating modules and items. Canvas is free to omit 'items' for any particular module if it deems them too numerous to return inline. Callers must be prepared to use the {api:ContextModuleItemsApiController#index List Module Items API} if items are not returned. - "content_details": Requires include['items']. Returns additional details with module items specific to their associated content items. Includes standard lock information for each item.""" if include is not None: self._validate_enum(include, ["items", "content_details"]) params["include"] = include # OPTIONAL - student_id """Returns module completion information for the student with this id.""" if student_id is not None: params["student_id"] = student_id self.logger.debug("GET /api/v1/courses/{course_id}/modules/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("GET", "/api/v1/courses/{course_id}/modules/{id}".format(**path), data=data, params=params, single_item=True) def create_module(self, course_id, module_name, module_position=None, module_prerequisite_module_ids=None, module_publish_final_grade=None, module_require_sequential_progress=None, module_unlock_at=None): """ Create a module. Create and return a new module """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - module[name] """The name of the module""" data["module[name]"] = module_name # OPTIONAL - module[unlock_at] """The date the module will unlock""" if module_unlock_at is not None: if issubclass(module_unlock_at.__class__, str): module_unlock_at = self._validate_iso8601_string(module_unlock_at) elif issubclass(module_unlock_at.__class__, date) or issubclass(module_unlock_at.__class__, datetime): module_unlock_at = module_unlock_at.strftime('%Y-%m-%dT%H:%M:%S+00:00') data["module[unlock_at]"] = module_unlock_at # OPTIONAL - module[position] """The position of this module in the course (1-based)""" if module_position is not None: data["module[position]"] = module_position # OPTIONAL - module[require_sequential_progress] """Whether module items must be unlocked in order""" if module_require_sequential_progress is not None: data["module[require_sequential_progress]"] = module_require_sequential_progress # OPTIONAL - module[prerequisite_module_ids] """IDs of Modules that must be completed before this one is unlocked. Prerequisite modules must precede this module (i.e. have a lower position value), otherwise they will be ignored""" if module_prerequisite_module_ids is not None: data["module[prerequisite_module_ids]"] = module_prerequisite_module_ids # OPTIONAL - module[publish_final_grade] """Whether to publish the student's final grade for the course upon completion of this module.""" if module_publish_final_grade is not None: data["module[publish_final_grade]"] = module_publish_final_grade self.logger.debug("POST /api/v1/courses/{course_id}/modules with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("POST", "/api/v1/courses/{course_id}/modules".format(**path), data=data, params=params, single_item=True) def update_module(self, id, course_id, module_name=None, module_position=None, module_prerequisite_module_ids=None, module_publish_final_grade=None, module_published=None, module_require_sequential_progress=None, module_unlock_at=None): """ Update a module. Update and return an existing module """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - id """ID""" path["id"] = id # OPTIONAL - module[name] """The name of the module""" if module_name is not None: data["module[name]"] = module_name # OPTIONAL - module[unlock_at] """The date the module will unlock""" if module_unlock_at is not None: if issubclass(module_unlock_at.__class__, str): module_unlock_at = self._validate_iso8601_string(module_unlock_at) elif issubclass(module_unlock_at.__class__, date) or issubclass(module_unlock_at.__class__, datetime): module_unlock_at = module_unlock_at.strftime('%Y-%m-%dT%H:%M:%S+00:00') data["module[unlock_at]"] = module_unlock_at # OPTIONAL - module[position] """The position of the module in the course (1-based)""" if module_position is not None: data["module[position]"] = module_position # OPTIONAL - module[require_sequential_progress] """Whether module items must be unlocked in order""" if module_require_sequential_progress is not None: data["module[require_sequential_progress]"] = module_require_sequential_progress # OPTIONAL - module[prerequisite_module_ids] """IDs of Modules that must be completed before this one is unlocked Prerequisite modules must precede this module (i.e. have a lower position value), otherwise they will be ignored""" if module_prerequisite_module_ids is not None: data["module[prerequisite_module_ids]"] = module_prerequisite_module_ids # OPTIONAL - module[publish_final_grade] """Whether to publish the student's final grade for the course upon completion of this module.""" if module_publish_final_grade is not None: data["module[publish_final_grade]"] = module_publish_final_grade # OPTIONAL - module[published] """Whether the module is published and visible to students""" if module_published is not None: data["module[published]"] = module_published self.logger.debug("PUT /api/v1/courses/{course_id}/modules/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("PUT", "/api/v1/courses/{course_id}/modules/{id}".format(**path), data=data, params=params, single_item=True) def delete_module(self, id, course_id): """ Delete module. Delete a module """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - id """ID""" path["id"] = id self.logger.debug("DELETE /api/v1/courses/{course_id}/modules/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("DELETE", "/api/v1/courses/{course_id}/modules/{id}".format(**path), data=data, params=params, single_item=True) def re_lock_module_progressions(self, id, course_id): """ Re-lock module progressions. Resets module progressions to their default locked state and recalculates them based on the current requirements. Adding progression requirements to an active course will not lock students out of modules they have already unlocked unless this action is called. """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - id """ID""" path["id"] = id self.logger.debug("PUT /api/v1/courses/{course_id}/modules/{id}/relock with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("PUT", "/api/v1/courses/{course_id}/modules/{id}/relock".format(**path), data=data, params=params, single_item=True) def list_module_items(self, course_id, module_id, include=None, search_term=None, student_id=None): """ List module items. List the items in a module """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - module_id """ID""" path["module_id"] = module_id # OPTIONAL - include """If included, will return additional details specific to the content associated with each item. Refer to the {api:Modules:Module%20Item Module Item specification} for more details. Includes standard lock information for each item.""" if include is not None: self._validate_enum(include, ["content_details"]) params["include"] = include # OPTIONAL - search_term """The partial title of the items to match and return.""" if search_term is not None: params["search_term"] = search_term # OPTIONAL - student_id """Returns module completion information for the student with this id.""" if student_id is not None: params["student_id"] = student_id self.logger.debug("GET /api/v1/courses/{course_id}/modules/{module_id}/items with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("GET", "/api/v1/courses/{course_id}/modules/{module_id}/items".format(**path), data=data, params=params, all_pages=True) def show_module_item(self, id, course_id, module_id, include=None, student_id=None): """ Show module item. Get information about a single module item """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - module_id """ID""" path["module_id"] = module_id # REQUIRED - PATH - id """ID""" path["id"] = id # OPTIONAL - include """If included, will return additional details specific to the content associated with this item. Refer to the {api:Modules:Module%20Item Module Item specification} for more details. Includes standard lock information for each item.""" if include is not None: self._validate_enum(include, ["content_details"]) params["include"] = include # OPTIONAL - student_id """Returns module completion information for the student with this id.""" if student_id is not None: params["student_id"] = student_id self.logger.debug("GET /api/v1/courses/{course_id}/modules/{module_id}/items/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("GET", "/api/v1/courses/{course_id}/modules/{module_id}/items/{id}".format(**path), data=data, params=params, single_item=True) def create_module_item(self, course_id, module_id, module_item_type, module_item_content_id, module_item_completion_requirement_min_score=None, module_item_completion_requirement_type=None, module_item_external_url=None, module_item_indent=None, module_item_new_tab=None, module_item_page_url=None, module_item_position=None, module_item_title=None): """ Create a module item. Create and return a new module item """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - module_id """ID""" path["module_id"] = module_id # OPTIONAL - module_item[title] """The name of the module item and associated content""" if module_item_title is not None: data["module_item[title]"] = module_item_title # REQUIRED - module_item[type] """The type of content linked to the item""" self._validate_enum(module_item_type, ["File", "Page", "Discussion", "Assignment", "Quiz", "SubHeader", "ExternalUrl", "ExternalTool"]) data["module_item[type]"] = module_item_type # REQUIRED - module_item[content_id] """The id of the content to link to the module item. Required, except for 'ExternalUrl', 'Page', and 'SubHeader' types.""" data["module_item[content_id]"] = module_item_content_id # OPTIONAL - module_item[position] """The position of this item in the module (1-based).""" if module_item_position is not None: data["module_item[position]"] = module_item_position # OPTIONAL - module_item[indent] """0-based indent level; module items may be indented to show a hierarchy""" if module_item_indent is not None: data["module_item[indent]"] = module_item_indent # OPTIONAL - module_item[page_url] """Suffix for the linked wiki page (e.g. 'front-page'). Required for 'Page' type.""" if module_item_page_url is not None: data["module_item[page_url]"] = module_item_page_url # OPTIONAL - module_item[external_url] """External url that the item points to. [Required for 'ExternalUrl' and 'ExternalTool' types.""" if module_item_external_url is not None: data["module_item[external_url]"] = module_item_external_url # OPTIONAL - module_item[new_tab] """Whether the external tool opens in a new tab. Only applies to 'ExternalTool' type.""" if module_item_new_tab is not None: data["module_item[new_tab]"] = module_item_new_tab # OPTIONAL - module_item[completion_requirement][type] """Completion requirement for this module item. "must_view": Applies to all item types "must_contribute": Only applies to "Assignment", "Discussion", and "Page" types "must_submit", "min_score": Only apply to "Assignment" and "Quiz" types Inapplicable types will be ignored""" if module_item_completion_requirement_type is not None: self._validate_enum(module_item_completion_requirement_type, ["must_view", "must_contribute", "must_submit"]) data["module_item[completion_requirement][type]"] = module_item_completion_requirement_type # OPTIONAL - module_item[completion_requirement][min_score] """Minimum score required to complete. Required for completion_requirement type 'min_score'.""" if module_item_completion_requirement_min_score is not None: data["module_item[completion_requirement][min_score]"] = module_item_completion_requirement_min_score self.logger.debug("POST /api/v1/courses/{course_id}/modules/{module_id}/items with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("POST", "/api/v1/courses/{course_id}/modules/{module_id}/items".format(**path), data=data, params=params, single_item=True) def update_module_item(self, id, course_id, module_id, module_item_completion_requirement_min_score=None, module_item_completion_requirement_type=None, module_item_external_url=None, module_item_indent=None, module_item_module_id=None, module_item_new_tab=None, module_item_position=None, module_item_published=None, module_item_title=None): """ Update a module item. Update and return an existing module item """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - module_id """ID""" path["module_id"] = module_id # REQUIRED - PATH - id """ID""" path["id"] = id # OPTIONAL - module_item[title] """The name of the module item""" if module_item_title is not None: data["module_item[title]"] = module_item_title # OPTIONAL - module_item[position] """The position of this item in the module (1-based)""" if module_item_position is not None: data["module_item[position]"] = module_item_position # OPTIONAL - module_item[indent] """0-based indent level; module items may be indented to show a hierarchy""" if module_item_indent is not None: data["module_item[indent]"] = module_item_indent # OPTIONAL - module_item[external_url] """External url that the item points to. Only applies to 'ExternalUrl' type.""" if module_item_external_url is not None: data["module_item[external_url]"] = module_item_external_url # OPTIONAL - module_item[new_tab] """Whether the external tool opens in a new tab. Only applies to 'ExternalTool' type.""" if module_item_new_tab is not None: data["module_item[new_tab]"] = module_item_new_tab # OPTIONAL - module_item[completion_requirement][type] """Completion requirement for this module item. "must_view": Applies to all item types "must_contribute": Only applies to "Assignment", "Discussion", and "Page" types "must_submit", "min_score": Only apply to "Assignment" and "Quiz" types Inapplicable types will be ignored""" if module_item_completion_requirement_type is not None: self._validate_enum(module_item_completion_requirement_type, ["must_view", "must_contribute", "must_submit"]) data["module_item[completion_requirement][type]"] = module_item_completion_requirement_type # OPTIONAL - module_item[completion_requirement][min_score] """Minimum score required to complete, Required for completion_requirement type 'min_score'.""" if module_item_completion_requirement_min_score is not None: data["module_item[completion_requirement][min_score]"] = module_item_completion_requirement_min_score # OPTIONAL - module_item[published] """Whether the module item is published and visible to students.""" if module_item_published is not None: data["module_item[published]"] = module_item_published # OPTIONAL - module_item[module_id] """Move this item to another module by specifying the target module id here. The target module must be in the same course.""" if module_item_module_id is not None: data["module_item[module_id]"] = module_item_module_id self.logger.debug("PUT /api/v1/courses/{course_id}/modules/{module_id}/items/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("PUT", "/api/v1/courses/{course_id}/modules/{module_id}/items/{id}".format(**path), data=data, params=params, single_item=True) def select_mastery_path(self, id, course_id, module_id, assignment_set_id=None, student_id=None): """ Select a mastery path. Select a mastery path when module item includes several possible paths. Requires Mastery Paths feature to be enabled. Returns a compound document with the assignments included in the given path and any module items related to those assignments """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - module_id """ID""" path["module_id"] = module_id # REQUIRED - PATH - id """ID""" path["id"] = id # OPTIONAL - assignment_set_id """Assignment set chosen, as specified in the mastery_paths portion of the context module item response""" if assignment_set_id is not None: data["assignment_set_id"] = assignment_set_id # OPTIONAL - student_id """Which student the selection applies to. If not specified, current user is implied.""" if student_id is not None: data["student_id"] = student_id self.logger.debug("POST /api/v1/courses/{course_id}/modules/{module_id}/items/{id}/select_mastery_path with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("POST", "/api/v1/courses/{course_id}/modules/{module_id}/items/{id}/select_mastery_path".format(**path), data=data, params=params, no_data=True) def delete_module_item(self, id, course_id, module_id): """ Delete module item. Delete a module item """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - module_id """ID""" path["module_id"] = module_id # REQUIRED - PATH - id """ID""" path["id"] = id self.logger.debug("DELETE /api/v1/courses/{course_id}/modules/{module_id}/items/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("DELETE", "/api/v1/courses/{course_id}/modules/{module_id}/items/{id}".format(**path), data=data, params=params, single_item=True) def mark_module_item_as_done_not_done(self, id, course_id, module_id): """ Mark module item as done/not done. Mark a module item as done/not done. Use HTTP method PUT to mark as done, and DELETE to mark as not done. """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - module_id """ID""" path["module_id"] = module_id # REQUIRED - PATH - id """ID""" path["id"] = id self.logger.debug("PUT /api/v1/courses/{course_id}/modules/{module_id}/items/{id}/done with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("PUT", "/api/v1/courses/{course_id}/modules/{module_id}/items/{id}/done".format(**path), data=data, params=params, no_data=True) def get_module_item_sequence(self, course_id, asset_id=None, asset_type=None): """ Get module item sequence. Given an asset in a course, find the ModuleItem it belongs to, and also the previous and next Module Items in the course sequence. """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # OPTIONAL - asset_type """The type of asset to find module sequence information for. Use the ModuleItem if it is known (e.g., the user navigated from a module item), since this will avoid ambiguity if the asset appears more than once in the module sequence.""" if asset_type is not None: self._validate_enum(asset_type, ["ModuleItem", "File", "Page", "Discussion", "Assignment", "Quiz", "ExternalTool"]) params["asset_type"] = asset_type # OPTIONAL - asset_id """The id of the asset (or the url in the case of a Page)""" if asset_id is not None: params["asset_id"] = asset_id self.logger.debug("GET /api/v1/courses/{course_id}/module_item_sequence with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("GET", "/api/v1/courses/{course_id}/module_item_sequence".format(**path), data=data, params=params, single_item=True) def mark_module_item_read(self, id, course_id, module_id): """ Mark module item read. Fulfills "must view" requirement for a module item. It is generally not necessary to do this explicitly, but it is provided for applications that need to access external content directly (bypassing the html_url redirect that normally allows Canvas to fulfill "must view" requirements). This endpoint cannot be used to complete requirements on locked or unpublished module items. """ path = {} data = {} params = {} # REQUIRED - PATH - course_id """ID""" path["course_id"] = course_id # REQUIRED - PATH - module_id """ID""" path["module_id"] = module_id # REQUIRED - PATH - id """ID""" path["id"] = id self.logger.debug("POST /api/v1/courses/{course_id}/modules/{module_id}/items/{id}/mark_read with query params: {params} and form data: {data}".format(params=params, data=data, **path)) return self.generic_request("POST", "/api/v1/courses/{course_id}/modules/{module_id}/items/{id}/mark_read".format(**path), data=data, params=params, no_data=True) class Contentdetails(BaseModel): """Contentdetails Model.""" def __init__(self, unlock_at=None, due_at=None, points_possible=None, lock_info=None, lock_at=None, lock_explanation=None, locked_for_user=None): """Init method for Contentdetails class.""" self._unlock_at = unlock_at self._due_at = due_at self._points_possible = points_possible self._lock_info = lock_info self._lock_at = lock_at self._lock_explanation = lock_explanation self._locked_for_user = locked_for_user self.logger = logging.getLogger('py3canvas.Contentdetails') @property def unlock_at(self): """unlock_at.""" return self._unlock_at @unlock_at.setter def unlock_at(self, value): """Setter for unlock_at property.""" self.logger.warn("Setting values on unlock_at will NOT update the remote Canvas instance.") self._unlock_at = value @property def due_at(self): """due_at.""" return self._due_at @due_at.setter def due_at(self, value): """Setter for due_at property.""" self.logger.warn("Setting values on due_at will NOT update the remote Canvas instance.") self._due_at = value @property def points_possible(self): """points_possible.""" return self._points_possible @points_possible.setter def points_possible(self, value): """Setter for points_possible property.""" self.logger.warn("Setting values on points_possible will NOT update the remote Canvas instance.") self._points_possible = value @property def lock_info(self): """lock_info.""" return self._lock_info @lock_info.setter def lock_info(self, value): """Setter for lock_info property.""" self.logger.warn("Setting values on lock_info will NOT update the remote Canvas instance.") self._lock_info = value @property def lock_at(self): """lock_at.""" return self._lock_at @lock_at.setter def lock_at(self, value): """Setter for lock_at property.""" self.logger.warn("Setting values on lock_at will NOT update the remote Canvas instance.") self._lock_at = value @property def lock_explanation(self): """lock_explanation.""" return self._lock_explanation @lock_explanation.setter def lock_explanation(self, value): """Setter for lock_explanation property.""" self.logger.warn("Setting values on lock_explanation will NOT update the remote Canvas instance.") self._lock_explanation = value @property def locked_for_user(self): """locked_for_user.""" return self._locked_for_user @locked_for_user.setter def locked_for_user(self, value): """Setter for locked_for_user property.""" self.logger.warn("Setting values on locked_for_user will NOT update the remote Canvas instance.") self._locked_for_user = value class Moduleitemsequenceasset(BaseModel): """Moduleitemsequenceasset Model.""" def __init__(self, module_id=None, type=None, id=None, title=None): """Init method for Moduleitemsequenceasset class.""" self._module_id = module_id self._type = type self._id = id self._title = title self.logger = logging.getLogger('py3canvas.Moduleitemsequenceasset') @property def module_id(self): """module_id.""" return self._module_id @module_id.setter def module_id(self, value): """Setter for module_id property.""" self.logger.warn("Setting values on module_id will NOT update the remote Canvas instance.") self._module_id = value @property def type(self): """type.""" return self._type @type.setter def type(self, value): """Setter for type property.""" self.logger.warn("Setting values on type will NOT update the remote Canvas instance.") self._type = value @property def id(self): """id.""" return self._id @id.setter def id(self, value): """Setter for id property.""" self.logger.warn("Setting values on id will NOT update the remote Canvas instance.") self._id = value @property def title(self): """title.""" return self._title @title.setter def title(self, value): """Setter for title property.""" self.logger.warn("Setting values on title will NOT update the remote Canvas instance.") self._title = value class Moduleitemcompletionrequirement(BaseModel): """Moduleitemcompletionrequirement Model.""" def __init__(self, min_score=None, type=None, completed=None): """Init method for Moduleitemcompletionrequirement class.""" self._min_score = min_score self._type = type self._completed = completed self.logger = logging.getLogger('py3canvas.Moduleitemcompletionrequirement') @property def min_score(self): """min_score.""" return self._min_score @min_score.setter def min_score(self, value): """Setter for min_score property.""" self.logger.warn("Setting values on min_score will NOT update the remote Canvas instance.") self._min_score = value @property def type(self): """type.""" return self._type @type.setter def type(self, value): """Setter for type property.""" self.logger.warn("Setting values on type will NOT update the remote Canvas instance.") self._type = value @property def completed(self): """completed.""" return self._completed @completed.setter def completed(self, value): """Setter for completed property.""" self.logger.warn("Setting values on completed will NOT update the remote Canvas instance.") self._completed = value class Module(BaseModel): """Module Model.""" def __init__(self, completed_at=None, items_count=None, unlock_at=None, workflow_state=None, items=None, prerequisite_module_ids=None, state=None, publish_final_grade=None, position=None, items_url=None, id=None, require_sequential_progress=None, name=None): """Init method for Module class.""" self._completed_at = completed_at self._items_count = items_count self._unlock_at = unlock_at self._workflow_state = workflow_state self._items = items self._prerequisite_module_ids = prerequisite_module_ids self._state = state self._publish_final_grade = publish_final_grade self._position = position self._items_url = items_url self._id = id self._require_sequential_progress = require_sequential_progress self._name = name self.logger = logging.getLogger('py3canvas.Module') @property def completed_at(self): """the date the calling user completed the module (Optional; present only if the caller is a student or if the optional parameter 'student_id' is included).""" return self._completed_at @completed_at.setter def completed_at(self, value): """Setter for completed_at property.""" self.logger.warn("Setting values on completed_at will NOT update the remote Canvas instance.") self._completed_at = value @property def items_count(self): """The number of items in the module.""" return self._items_count @items_count.setter def items_count(self, value): """Setter for items_count property.""" self.logger.warn("Setting values on items_count will NOT update the remote Canvas instance.") self._items_count = value @property def unlock_at(self): """(Optional) the date this module will unlock.""" return self._unlock_at @unlock_at.setter def unlock_at(self, value): """Setter for unlock_at property.""" self.logger.warn("Setting values on unlock_at will NOT update the remote Canvas instance.") self._unlock_at = value @property def workflow_state(self): """the state of the module: 'active', 'deleted'.""" return self._workflow_state @workflow_state.setter def workflow_state(self, value): """Setter for workflow_state property.""" self.logger.warn("Setting values on workflow_state will NOT update the remote Canvas instance.") self._workflow_state = value @property def items(self): """The contents of this module, as an array of Module Items. (Present only if requested via include[]=items AND the module is not deemed too large by Canvas.).""" return self._items @items.setter def items(self, value): """Setter for items property.""" self.logger.warn("Setting values on items will NOT update the remote Canvas instance.") self._items = value @property def prerequisite_module_ids(self): """IDs of Modules that must be completed before this one is unlocked.""" return self._prerequisite_module_ids @prerequisite_module_ids.setter def prerequisite_module_ids(self, value): """Setter for prerequisite_module_ids property.""" self.logger.warn("Setting values on prerequisite_module_ids will NOT update the remote Canvas instance.") self._prerequisite_module_ids = value @property def state(self): """The state of this Module for the calling user one of 'locked', 'unlocked', 'started', 'completed' (Optional; present only if the caller is a student or if the optional parameter 'student_id' is included).""" return self._state @state.setter def state(self, value): """Setter for state property.""" self.logger.warn("Setting values on state will NOT update the remote Canvas instance.") self._state = value @property def publish_final_grade(self): """if the student's final grade for the course should be published to the SIS upon completion of this module.""" return self._publish_final_grade @publish_final_grade.setter def publish_final_grade(self, value): """Setter for publish_final_grade property.""" self.logger.warn("Setting values on publish_final_grade will NOT update the remote Canvas instance.") self._publish_final_grade = value @property def position(self): """the position of this module in the course (1-based).""" return self._position @position.setter def position(self, value): """Setter for position property.""" self.logger.warn("Setting values on position will NOT update the remote Canvas instance.") self._position = value @property def items_url(self): """The API URL to retrive this module's items.""" return self._items_url @items_url.setter def items_url(self, value): """Setter for items_url property.""" self.logger.warn("Setting values on items_url will NOT update the remote Canvas instance.") self._items_url = value @property def id(self): """the unique identifier for the module.""" return self._id @id.setter def id(self, value): """Setter for id property.""" self.logger.warn("Setting values on id will NOT update the remote Canvas instance.") self._id = value @property def require_sequential_progress(self): """Whether module items must be unlocked in order.""" return self._require_sequential_progress @require_sequential_progress.setter def require_sequential_progress(self, value): """Setter for require_sequential_progress property.""" self.logger.warn("Setting values on require_sequential_progress will NOT update the remote Canvas instance.") self._require_sequential_progress = value @property def name(self): """the name of this module.""" return self._name @name.setter def name(self, value): """Setter for name property.""" self.logger.warn("Setting values on name will NOT update the remote Canvas instance.") self._name = value class Moduleitemsequence(BaseModel): """Moduleitemsequence Model.""" def __init__(self, items=None, modules=None): """Init method for Moduleitemsequence class.""" self._items = items self._modules = modules self.logger = logging.getLogger('py3canvas.Moduleitemsequence') @property def items(self): """an array containing one hash for each appearence of the asset in the module sequence (up to 10 total).""" return self._items @items.setter def items(self, value): """Setter for items property.""" self.logger.warn("Setting values on items will NOT update the remote Canvas instance.") self._items = value @property def modules(self): """an array containing each Module referenced above.""" return self._modules @modules.setter def modules(self, value): """Setter for modules property.""" self.logger.warn("Setting values on modules will NOT update the remote Canvas instance.") self._modules = value class Completionrequirement(BaseModel): """Completionrequirement Model.""" def __init__(self, min_score=None, type=None, completed=None): """Init method for Completionrequirement class.""" self._min_score = min_score self._type = type self._completed = completed self.logger = logging.getLogger('py3canvas.Completionrequirement') @property def min_score(self): """minimum score required to complete (only present when type == 'min_score').""" return self._min_score @min_score.setter def min_score(self, value): """Setter for min_score property.""" self.logger.warn("Setting values on min_score will NOT update the remote Canvas instance.") self._min_score = value @property def type(self): """one of 'must_view', 'must_submit', 'must_contribute', 'min_score'.""" return self._type @type.setter def type(self, value): """Setter for type property.""" self.logger.warn("Setting values on type will NOT update the remote Canvas instance.") self._type = value @property def completed(self): """whether the calling user has met this requirement (Optional; present only if the caller is a student or if the optional parameter 'student_id' is included).""" return self._completed @completed.setter def completed(self, value): """Setter for completed property.""" self.logger.warn("Setting values on completed will NOT update the remote Canvas instance.") self._completed = value class Moduleitem(BaseModel): """Moduleitem Model.""" def __init__(self, indent=None, title=None, url=None, completion_requirement=None, html_url=None, content_details=None, new_tab=None, external_url=None, position=None, module_id=None, content_id=None, type=None, id=None, page_url=None): """Init method for Moduleitem class.""" self._indent = indent self._title = title self._url = url self._completion_requirement = completion_requirement self._html_url = html_url self._content_details = content_details self._new_tab = new_tab self._external_url = external_url self._position = position self._module_id = module_id self._content_id = content_id self._type = type self._id = id self._page_url = page_url self.logger = logging.getLogger('py3canvas.Moduleitem') @property def indent(self): """0-based indent level; module items may be indented to show a hierarchy.""" return self._indent @indent.setter def indent(self, value): """Setter for indent property.""" self.logger.warn("Setting values on indent will NOT update the remote Canvas instance.") self._indent = value @property def title(self): """the title of this item.""" return self._title @title.setter def title(self, value): """Setter for title property.""" self.logger.warn("Setting values on title will NOT update the remote Canvas instance.") self._title = value @property def url(self): """(Optional) link to the Canvas API object, if applicable.""" return self._url @url.setter def url(self, value): """Setter for url property.""" self.logger.warn("Setting values on url will NOT update the remote Canvas instance.") self._url = value @property def completion_requirement(self): """Completion requirement for this module item.""" return self._completion_requirement @completion_requirement.setter def completion_requirement(self, value): """Setter for completion_requirement property.""" self.logger.warn("Setting values on completion_requirement will NOT update the remote Canvas instance.") self._completion_requirement = value @property def html_url(self): """link to the item in Canvas.""" return self._html_url @html_url.setter def html_url(self, value): """Setter for html_url property.""" self.logger.warn("Setting values on html_url will NOT update the remote Canvas instance.") self._html_url = value @property def content_details(self): """(Present only if requested through include[]=content_details) If applicable, returns additional details specific to the associated object.""" return self._content_details @content_details.setter def content_details(self, value): """Setter for content_details property.""" self.logger.warn("Setting values on content_details will NOT update the remote Canvas instance.") self._content_details = value @property def new_tab(self): """(only for 'ExternalTool' type) whether the external tool opens in a new tab.""" return self._new_tab @new_tab.setter def new_tab(self, value): """Setter for new_tab property.""" self.logger.warn("Setting values on new_tab will NOT update the remote Canvas instance.") self._new_tab = value @property def external_url(self): """(only for 'ExternalUrl' and 'ExternalTool' types) external url that the item points to.""" return self._external_url @external_url.setter def external_url(self, value): """Setter for external_url property.""" self.logger.warn("Setting values on external_url will NOT update the remote Canvas instance.") self._external_url = value @property def position(self): """the position of this item in the module (1-based).""" return self._position @position.setter def position(self, value): """Setter for position property.""" self.logger.warn("Setting values on position will NOT update the remote Canvas instance.") self._position = value @property def module_id(self): """the id of the Module this item appears in.""" return self._module_id @module_id.setter def module_id(self, value): """Setter for module_id property.""" self.logger.warn("Setting values on module_id will NOT update the remote Canvas instance.") self._module_id = value @property def content_id(self): """the id of the object referred to applies to 'File', 'Discussion', 'Assignment', 'Quiz', 'ExternalTool' types.""" return self._content_id @content_id.setter def content_id(self, value): """Setter for content_id property.""" self.logger.warn("Setting values on content_id will NOT update the remote Canvas instance.") self._content_id = value @property def type(self): """the type of object referred to one of 'File', 'Page', 'Discussion', 'Assignment', 'Quiz', 'SubHeader', 'ExternalUrl', 'ExternalTool'.""" return self._type @type.setter def type(self, value): """Setter for type property.""" self.logger.warn("Setting values on type will NOT update the remote Canvas instance.") self._type = value @property def id(self): """the unique identifier for the module item.""" return self._id @id.setter def id(self, value): """Setter for id property.""" self.logger.warn("Setting values on id will NOT update the remote Canvas instance.") self._id = value @property def page_url(self): """(only for 'Page' type) unique locator for the linked wiki page.""" return self._page_url @page_url.setter def page_url(self, value): """Setter for page_url property.""" self.logger.warn("Setting values on page_url will NOT update the remote Canvas instance.") self._page_url = value class Moduleitemsequencenode(BaseModel): """Moduleitemsequencenode Model.""" def __init__(self, current=None, prev=None, next=None): """Init method for Moduleitemsequencenode class.""" self._current = current self._prev = prev self._next = next self.logger = logging.getLogger('py3canvas.Moduleitemsequencenode') @property def current(self): """current.""" return self._current @current.setter def current(self, value): """Setter for current property.""" self.logger.warn("Setting values on current will NOT update the remote Canvas instance.") self._current = value @property def prev(self): """prev.""" return self._prev @prev.setter def prev(self, value): """Setter for prev property.""" self.logger.warn("Setting values on prev will NOT update the remote Canvas instance.") self._prev = value @property def next(self): """next.""" return self._next @next.setter def next(self, value): """Setter for next property.""" self.logger.warn("Setting values on next will NOT update the remote Canvas instance.") self._next = value class Moduleitemcontentdetails(BaseModel): """Moduleitemcontentdetails Model.""" def __init__(self, unlock_at=None, due_at=None, points_possible=None, lock_info=None, lock_at=None, lock_explanation=None, locked_for_user=None): """Init method for Moduleitemcontentdetails class.""" self._unlock_at = unlock_at self._due_at = due_at self._points_possible = points_possible self._lock_info = lock_info self._lock_at = lock_at self._lock_explanation = lock_explanation self._locked_for_user = locked_for_user self.logger = logging.getLogger('py3canvas.Moduleitemcontentdetails') @property def unlock_at(self): """unlock_at.""" return self._unlock_at @unlock_at.setter def unlock_at(self, value): """Setter for unlock_at property.""" self.logger.warn("Setting values on unlock_at will NOT update the remote Canvas instance.") self._unlock_at = value @property def due_at(self): """due_at.""" return self._due_at @due_at.setter def due_at(self, value): """Setter for due_at property.""" self.logger.warn("Setting values on due_at will NOT update the remote Canvas instance.") self._due_at = value @property def points_possible(self): """points_possible.""" return self._points_possible @points_possible.setter def points_possible(self, value): """Setter for points_possible property.""" self.logger.warn("Setting values on points_possible will NOT update the remote Canvas instance.") self._points_possible = value @property def lock_info(self): """lock_info.""" return self._lock_info @lock_info.setter def lock_info(self, value): """Setter for lock_info property.""" self.logger.warn("Setting values on lock_info will NOT update the remote Canvas instance.") self._lock_info = value @property def lock_at(self): """lock_at.""" return self._lock_at @lock_at.setter def lock_at(self, value): """Setter for lock_at property.""" self.logger.warn("Setting values on lock_at will NOT update the remote Canvas instance.") self._lock_at = value @property def lock_explanation(self): """lock_explanation.""" return self._lock_explanation @lock_explanation.setter def lock_explanation(self, value): """Setter for lock_explanation property.""" self.logger.warn("Setting values on lock_explanation will NOT update the remote Canvas instance.") self._lock_explanation = value @property def locked_for_user(self): """locked_for_user.""" return self._locked_for_user @locked_for_user.setter def locked_for_user(self, value): """Setter for locked_for_user property.""" self.logger.warn("Setting values on locked_for_user will NOT update the remote Canvas instance.") self._locked_for_user = value

mit

kajgan/stbgui

lib/python/Components/Converter/ClientsStreaming.py

1

3432

from Converter import Converter from Poll import Poll from Components.Element import cached from Components.Sources.StreamService import StreamServiceList from enigma import eStreamServer from ServiceReference import ServiceReference import socket class ClientsStreaming(Converter, Poll, object): UNKNOWN = -1 REF = 0 IP = 1 NAME = 2 ENCODER = 3 NUMBER = 4 SHORT_ALL = 5 ALL = 6 INFO = 7 INFO_RESOLVE = 8 INFO_RESOLVE_SHORT = 9 EXTRA_INFO = 10 def __init__(self, type): Converter.__init__(self, type) Poll.__init__(self) self.poll_interval = 30000 self.poll_enabled = True if type == "REF": self.type = self.REF elif type == "IP": self.type = self.IP elif type == "NAME": self.type = self.NAME elif type == "ENCODER": self.type = self.ENCODER elif type == "NUMBER": self.type = self.NUMBER elif type == "SHORT_ALL": self.type = self.SHORT_ALL elif type == "ALL": self.type = self.ALL elif type == "INFO": self.type = self.INFO elif type == "INFO_RESOLVE": self.type = self.INFO_RESOLVE elif type == "INFO_RESOLVE_SHORT": self.type = self.INFO_RESOLVE_SHORT elif type == "EXTRA_INFO": self.type = self.EXTRA_INFO else: self.type = self.UNKNOWN self.streamServer = eStreamServer.getInstance() @cached def getText(self): if self.streamServer is None: return "" clients = [] refs = [] ips = [] names = [] encoders = [] extrainfo = _("ClientIP") + "\t" + _("Transcode") + "\t" + _("Channel") + "\n" info = "" for x in self.streamServer.getConnectedClients(): refs.append((x[1])) servicename = ServiceReference(x[1]).getServiceName() or "(unknown service)" service_name = servicename names.append((service_name)) ip = x[0] ips.append((ip)) if int(x[2]) == 0: strtype = "S" encoder = _('NO') else: strtype = "T" encoder = _('YES') encoders.append((encoder)) if self.type == self.INFO_RESOLVE or self.type == self.INFO_RESOLVE_SHORT: try: raw = socket.gethostbyaddr(ip) ip = raw[0] except: pass if self.type == self.INFO_RESOLVE_SHORT: ip, sep, tail = ip.partition('.') info += ("%s %-8s %s\n") % (strtype, ip, service_name) clients.append((ip, service_name, encoder)) extrainfo += ("%-8s\t%s\t%s") % (ip, encoder, service_name) +"\n" if self.type == self.REF: return ' '.join(refs) elif self.type == self.IP: return ' '.join(ips) elif self.type == self.NAME: return ' '.join(names) elif self.type == self.ENCODER: return _("Transcoding: ") + ' '.join(encoders) elif self.type == self.NUMBER: return str(len(clients)) elif self.type == self.EXTRA_INFO: return extrainfo elif self.type == self.SHORT_ALL: return _("Total clients streaming: %d (%s)") % (len(clients), ' '.join(names)) elif self.type == self.ALL: return '\n'.join(' '.join(elems) for elems in clients) elif self.type == self.INFO or self.type == self.INFO_RESOLVE or self.type == self.INFO_RESOLVE_SHORT: return info else: return "(unknown)" return "" text = property(getText) @cached def getBoolean(self): if self.streamServer is None: return False return (self.streamServer.getConnectedClients() or StreamServiceList) and True or False boolean = property(getBoolean) def changed(self, what): Converter.changed(self, (self.CHANGED_POLL,)) def doSuspend(self, suspended): pass

gpl-2.0

viaict/viaduct

app/forms/pimpy.py

1

1268

import datetime from flask_babel import _ from flask_login import current_user from flask_wtf import FlaskForm from wtforms import StringField, TextAreaField, DateTimeField, SelectField from wtforms.ext.sqlalchemy.fields import QuerySelectField from wtforms.validators import InputRequired, Optional from app import constants from app.service import group_service, pimpy_service class AddTaskForm(FlaskForm): name = StringField(_('Name'), validators=[InputRequired()]) content = TextAreaField(_('Content'), validators=[Optional()]) group = QuerySelectField( _('Group'), query_factory=lambda: group_service.get_groups_for_user(current_user), get_label=lambda x: x.name) users = StringField(_('Users')) status = SelectField(_('Status'), coerce=int, choices=pimpy_service.get_task_status_choices()) class AddMinuteForm(FlaskForm): content = TextAreaField(_('Minute content'), validators=[InputRequired()]) group = QuerySelectField( _('Group'), query_factory=lambda: group_service.get_groups_for_user(current_user), get_label=lambda x: x.name) date = DateTimeField(_('Date'), format=constants.DATE_FORMAT, default=datetime.date.today)

mit

Cito/DBUtils

tests/mock_db.py

1

3341

"""This module serves as a mock object for the DB-API 2 module""" threadsafety = 2 class Error(Exception): pass class DatabaseError(Error): pass class OperationalError(DatabaseError): pass class InternalError(DatabaseError): pass class ProgrammingError(DatabaseError): pass def connect(database=None, user=None): return Connection(database, user) class Connection: has_ping = False num_pings = 0 def __init__(self, database=None, user=None): self.database = database self.user = user self.valid = False if database == 'error': raise OperationalError self.open_cursors = 0 self.num_uses = 0 self.num_queries = 0 self.num_pings = 0 self.session = [] self.valid = True def close(self): if not self.valid: raise InternalError self.open_cursors = 0 self.num_uses = 0 self.num_queries = 0 self.session = [] self.valid = False def commit(self): if not self.valid: raise InternalError self.session.append('commit') def rollback(self): if not self.valid: raise InternalError self.session.append('rollback') def ping(self): cls = self.__class__ cls.num_pings += 1 if not cls.has_ping: raise AttributeError if not self.valid: raise OperationalError def cursor(self, name=None): if not self.valid: raise InternalError return Cursor(self, name) class Cursor: def __init__(self, con, name=None): self.con = con self.valid = False if name == 'error': raise OperationalError self.result = None self.inputsizes = [] self.outputsizes = {} con.open_cursors += 1 self.valid = True def close(self): if not self.valid: raise InternalError self.con.open_cursors -= 1 self.valid = False def execute(self, operation): if not self.valid or not self.con.valid: raise InternalError self.con.num_uses += 1 if operation.startswith('select '): self.con.num_queries += 1 self.result = operation[7:] elif operation.startswith('set '): self.con.session.append(operation[4:]) self.result = None elif operation == 'get sizes': self.result = (self.inputsizes, self.outputsizes) self.inputsizes = [] self.outputsizes = {} else: raise ProgrammingError def fetchone(self): if not self.valid: raise InternalError result = self.result self.result = None return result def callproc(self, procname): if not self.valid or not self.con.valid or not procname: raise InternalError self.con.num_uses += 1 def setinputsizes(self, sizes): if not self.valid: raise InternalError self.inputsizes = sizes def setoutputsize(self, size, column=None): if not self.valid: raise InternalError self.outputsizes[column] = size def __del__(self): if self.valid: self.close()

mit

bluestemscott/librarygadget

librarygadget/librarybot/migrations/0001_initial.py

1

15532

# encoding: utf-8 import datetime from south.db import db from south.v2 import SchemaMigration from django.db import models class Migration(SchemaMigration): def forwards(self, orm): # Adding model 'UserProfile' db.create_table('librarybot_userprofile', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('user', self.gf('django.db.models.fields.related.OneToOneField')(to=orm['auth.User'], unique=True)), ('api_key', self.gf('django.db.models.fields.CharField')(max_length=50, null=True)), ('account_level', self.gf('django.db.models.fields.CharField')(default='free', max_length=10)), ('paid_last_date', self.gf('django.db.models.fields.DateField')(null=True, blank=True)), ('paid_first_date', self.gf('django.db.models.fields.DateField')(null=True, blank=True)), )) db.send_create_signal('librarybot', ['UserProfile']) # Adding model 'Library' db.create_table('librarybot_library', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('name', self.gf('django.db.models.fields.CharField')(max_length=100)), ('state', self.gf('django.db.models.fields.CharField')(max_length=2)), ('catalogurl', self.gf('django.db.models.fields.URLField')(max_length=200)), ('librarysystem', self.gf('django.db.models.fields.CharField')(max_length=20)), ('renew_supported_code', self.gf('django.db.models.fields.CharField')(default='untested', max_length=10)), ('active', self.gf('django.db.models.fields.BooleanField')(default=True, blank=True)), ('lastmodified', self.gf('django.db.models.fields.DateField')(auto_now=True, blank=True)), )) db.send_create_signal('librarybot', ['Library']) # Adding model 'Patron' db.create_table('librarybot_patron', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('library', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['librarybot.Library'])), ('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'], null=True)), ('patronid', self.gf('django.db.models.fields.CharField')(max_length=40)), ('pin', self.gf('django.db.models.fields.CharField')(max_length=75)), ('name', self.gf('django.db.models.fields.CharField')(max_length=150, null=True)), ('save_history', self.gf('django.db.models.fields.BooleanField')(default=False, blank=True)), ('lastchecked', self.gf('django.db.models.fields.DateTimeField')()), ('batch_last_run', self.gf('django.db.models.fields.DateField')(null=True)), )) db.send_create_signal('librarybot', ['Patron']) # Adding model 'Item' db.create_table('librarybot_item', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('patron', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['librarybot.Patron'])), ('title', self.gf('django.db.models.fields.CharField')(max_length=1024)), ('author', self.gf('django.db.models.fields.CharField')(max_length=1024, null=True)), ('outDate', self.gf('django.db.models.fields.DateField')(null=True)), ('dueDate', self.gf('django.db.models.fields.DateField')(null=True)), ('timesRenewed', self.gf('django.db.models.fields.SmallIntegerField')(null=True)), ('isbn', self.gf('django.db.models.fields.CharField')(max_length=25, null=True)), ('asof', self.gf('django.db.models.fields.DateField')()), )) db.send_create_signal('librarybot', ['Item']) # Adding model 'AccessLog' db.create_table('librarybot_accesslog', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('patron', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['librarybot.Patron'])), ('library', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['librarybot.Library'])), ('viewfunc', self.gf('django.db.models.fields.CharField')(max_length=50)), ('error', self.gf('django.db.models.fields.CharField')(max_length=150)), ('error_stacktrace', self.gf('django.db.models.fields.CharField')(max_length=3000)), ('date', self.gf('django.db.models.fields.DateField')(auto_now=True, null=True, blank=True)), )) db.send_create_signal('librarybot', ['AccessLog']) # Adding model 'LibraryRequest' db.create_table('librarybot_libraryrequest', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('libraryname', self.gf('django.db.models.fields.CharField')(max_length=100)), ('state', self.gf('django.db.models.fields.CharField')(max_length=2)), ('catalogurl', self.gf('django.db.models.fields.URLField')(max_length=200)), ('name', self.gf('django.db.models.fields.CharField')(max_length=60)), ('email', self.gf('django.db.models.fields.EmailField')(max_length=75)), ('patronid', self.gf('django.db.models.fields.CharField')(max_length=40)), ('password', self.gf('django.db.models.fields.CharField')(max_length=20)), )) db.send_create_signal('librarybot', ['LibraryRequest']) # Adding model 'RenewalResponse' db.create_table('librarybot_renewalresponse', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('token', self.gf('django.db.models.fields.CharField')(max_length=36)), ('response', self.gf('django.db.models.fields.TextField')()), ('cachedate', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)), )) db.send_create_signal('librarybot', ['RenewalResponse']) def backwards(self, orm): # Deleting model 'UserProfile' db.delete_table('librarybot_userprofile') # Deleting model 'Library' db.delete_table('librarybot_library') # Deleting model 'Patron' db.delete_table('librarybot_patron') # Deleting model 'Item' db.delete_table('librarybot_item') # Deleting model 'AccessLog' db.delete_table('librarybot_accesslog') # Deleting model 'LibraryRequest' db.delete_table('librarybot_libraryrequest') # Deleting model 'RenewalResponse' db.delete_table('librarybot_renewalresponse') models = { 'auth.group': { 'Meta': {'object_name': 'Group'}, 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}), 'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}) }, 'auth.permission': { 'Meta': {'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'}, 'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}) }, 'auth.user': { 'Meta': {'object_name': 'User'}, 'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}), 'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}), 'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}), 'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True', 'blank': 'True'}), 'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}), 'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}), 'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}), 'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}), 'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}), 'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}), 'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'}) }, 'contenttypes.contenttype': { 'Meta': {'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"}, 'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}) }, 'librarybot.accesslog': { 'Meta': {'object_name': 'AccessLog'}, 'date': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}), 'error': ('django.db.models.fields.CharField', [], {'max_length': '150'}), 'error_stacktrace': ('django.db.models.fields.CharField', [], {'max_length': '3000'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'library': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['librarybot.Library']"}), 'patron': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['librarybot.Patron']"}), 'viewfunc': ('django.db.models.fields.CharField', [], {'max_length': '50'}) }, 'librarybot.item': { 'Meta': {'object_name': 'Item'}, 'asof': ('django.db.models.fields.DateField', [], {}), 'author': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'null': 'True'}), 'dueDate': ('django.db.models.fields.DateField', [], {'null': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'isbn': ('django.db.models.fields.CharField', [], {'max_length': '25', 'null': 'True'}), 'outDate': ('django.db.models.fields.DateField', [], {'null': 'True'}), 'patron': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['librarybot.Patron']"}), 'timesRenewed': ('django.db.models.fields.SmallIntegerField', [], {'null': 'True'}), 'title': ('django.db.models.fields.CharField', [], {'max_length': '1024'}) }, 'librarybot.library': { 'Meta': {'object_name': 'Library'}, 'active': ('django.db.models.fields.BooleanField', [], {'default': 'True', 'blank': 'True'}), 'catalogurl': ('django.db.models.fields.URLField', [], {'max_length': '200'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'lastmodified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'blank': 'True'}), 'librarysystem': ('django.db.models.fields.CharField', [], {'max_length': '20'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'renew_supported_code': ('django.db.models.fields.CharField', [], {'default': "'untested'", 'max_length': '10'}), 'state': ('django.db.models.fields.CharField', [], {'max_length': '2'}) }, 'librarybot.libraryrequest': { 'Meta': {'object_name': 'LibraryRequest'}, 'catalogurl': ('django.db.models.fields.URLField', [], {'max_length': '200'}), 'email': ('django.db.models.fields.EmailField', [], {'max_length': '75'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'libraryname': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '60'}), 'password': ('django.db.models.fields.CharField', [], {'max_length': '20'}), 'patronid': ('django.db.models.fields.CharField', [], {'max_length': '40'}), 'state': ('django.db.models.fields.CharField', [], {'max_length': '2'}) }, 'librarybot.patron': { 'Meta': {'object_name': 'Patron'}, 'batch_last_run': ('django.db.models.fields.DateField', [], {'null': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'lastchecked': ('django.db.models.fields.DateTimeField', [], {}), 'library': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['librarybot.Library']"}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '150', 'null': 'True'}), 'patronid': ('django.db.models.fields.CharField', [], {'max_length': '40'}), 'pin': ('django.db.models.fields.CharField', [], {'max_length': '75'}), 'save_history': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}), 'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True'}) }, 'librarybot.renewalresponse': { 'Meta': {'object_name': 'RenewalResponse'}, 'cachedate': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'response': ('django.db.models.fields.TextField', [], {}), 'token': ('django.db.models.fields.CharField', [], {'max_length': '36'}) }, 'librarybot.userprofile': { 'Meta': {'object_name': 'UserProfile'}, 'account_level': ('django.db.models.fields.CharField', [], {'default': "'free'", 'max_length': '10'}), 'api_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'null': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'paid_first_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}), 'paid_last_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}), 'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True'}) } } complete_apps = ['librarybot']

mit

rcmachado/pysuru

pysuru/tests/test_http.py

1

1256

# coding: utf-8 try: from unittest import mock except ImportError: import mock from pysuru.http import HttpClient def test_headers_attribute_should_always_have_authorization_header_with_token(): client = HttpClient('TARGET', 'TOKEN') assert 'Authorization' in client.headers assert client.headers['Authorization'] == 'bearer TOKEN' def test_urlopen_should_build_full_url_using_target_and_path(): client = HttpClient('example.com/api', 'TOKEN') client.conn.request = mock.MagicMock() client.urlopen('GET', '/sample') expected_url = 'http://example.com/api/sample' assert client.conn.request.call_args_list == [ mock.call('GET', expected_url, headers=mock.ANY, fields=None)] def test_urlopen_should_merge_headers_argument_with_headers_attribute(): my_headers = { 'X-Custom-Header': 'custom value' } expected_headers = { 'Authorization': 'bearer TOKEN', 'X-Custom-Header': 'custom value' } client = HttpClient('TARGET', 'TOKEN') client.conn.request = mock.MagicMock() client.urlopen('GET', '/sample', headers=my_headers) assert client.conn.request.call_args_list == [ mock.call('GET', mock.ANY, headers=expected_headers, fields=None)]

mit

JaneliaSciComp/Neuroptikon

Source/lib/CrossPlatform/networkx/generators/small.py

1

12813

""" Various small and named graphs, together with some compact generators. """ __author__ ="""Aric Hagberg (hagberg@lanl.gov)\nPieter Swart (swart@lanl.gov)""" # Copyright (C) 2004-2008 by # Aric Hagberg <hagberg@lanl.gov> # Dan Schult <dschult@colgate.edu> # Pieter Swart <swart@lanl.gov> # All rights reserved. # BSD license. __all__ = ['make_small_graph', 'LCF_graph', 'bull_graph', 'chvatal_graph', 'cubical_graph', 'desargues_graph', 'diamond_graph', 'dodecahedral_graph', 'frucht_graph', 'heawood_graph', 'house_graph', 'house_x_graph', 'icosahedral_graph', 'krackhardt_kite_graph', 'moebius_kantor_graph', 'octahedral_graph', 'pappus_graph', 'petersen_graph', 'sedgewick_maze_graph', 'tetrahedral_graph', 'truncated_cube_graph', 'truncated_tetrahedron_graph', 'tutte_graph'] from networkx.generators.classic import empty_graph, cycle_graph, path_graph, complete_graph from networkx.exception import NetworkXError #------------------------------------------------------------------------------ # Tools for creating small graphs #------------------------------------------------------------------------------ def make_small_undirected_graph(graph_description, create_using=None): """ Return a small undirected graph described by graph_description. See make_small_graph. """ if create_using is not None and create_using.is_directed(): raise NetworkXError("Directed Graph not supported") return make_small_graph(graph_description, create_using) def make_small_graph(graph_description, create_using=None): """ Return the small graph described by graph_description. graph_description is a list of the form [ltype,name,n,xlist] Here ltype is one of "adjacencylist" or "edgelist", name is the name of the graph and n the number of nodes. This constructs a graph of n nodes with integer labels 0,..,n-1. If ltype="adjacencylist" then xlist is an adjacency list with exactly n entries, in with the j'th entry (which can be empty) specifies the nodes connected to vertex j. e.g. the "square" graph C_4 can be obtained by >>> G=nx.make_small_graph(["adjacencylist","C_4",4,[[2,4],[1,3],[2,4],[1,3]]]) or, since we do not need to add edges twice, >>> G=nx.make_small_graph(["adjacencylist","C_4",4,[[2,4],[3],[4],[]]]) If ltype="edgelist" then xlist is an edge list written as [[v1,w2],[v2,w2],...,[vk,wk]], where vj and wj integers in the range 1,..,n e.g. the "square" graph C_4 can be obtained by >>> G=nx.make_small_graph(["edgelist","C_4",4,[[1,2],[3,4],[2,3],[4,1]]]) Use the create_using argument to choose the graph class/type. """ ltype=graph_description[0] name=graph_description[1] n=graph_description[2] G=empty_graph(n, create_using) nodes=G.nodes() if ltype=="adjacencylist": adjlist=graph_description[3] if len(adjlist) != n: raise NetworkXError,"invalid graph_description" G.add_edges_from([(u-1,v) for v in nodes for u in adjlist[v]]) elif ltype=="edgelist": edgelist=graph_description[3] for e in edgelist: v1=e[0]-1 v2=e[1]-1 if v1<0 or v1>n-1 or v2<0 or v2>n-1: raise NetworkXError,"invalid graph_description" else: G.add_edge(v1,v2) G.name=name return G def LCF_graph(n,shift_list,repeats,create_using=None): """ Return the cubic graph specified in LCF notation. LCF notation (LCF=Lederberg-Coxeter-Fruchte) is a compressed notation used in the generation of various cubic Hamiltonian graphs of high symmetry. See, for example, dodecahedral_graph, desargues_graph, heawood_graph and pappus_graph below. n (number of nodes) The starting graph is the n-cycle with nodes 0,...,n-1. (The null graph is returned if n < 0.) shift_list = [s1,s2,..,sk], a list of integer shifts mod n, repeats integer specifying the number of times that shifts in shift_list are successively applied to each v_current in the n-cycle to generate an edge between v_current and v_current+shift mod n. For v1 cycling through the n-cycle a total of k*repeats with shift cycling through shiftlist repeats times connect v1 with v1+shift mod n The utility graph K_{3,3} >>> G=nx.LCF_graph(6,[3,-3],3) The Heawood graph >>> G=nx.LCF_graph(14,[5,-5],7) See http://mathworld.wolfram.com/LCFNotation.html for a description and references. """ if create_using is not None and create_using.is_directed(): raise NetworkXError("Directed Graph not supported") if n <= 0: return empty_graph(0, create_using) # start with the n-cycle G=cycle_graph(n, create_using) G.name="LCF_graph" nodes=G.nodes() n_extra_edges=repeats*len(shift_list) # edges are added n_extra_edges times # (not all of these need be new) if n_extra_edges < 1: return G for i in range(n_extra_edges): shift=shift_list[i%len(shift_list)] #cycle through shift_list v1=nodes[i%n] # cycle repeatedly through nodes v2=nodes[(i + shift)%n] G.add_edge(v1, v2) return G #------------------------------------------------------------------------------- # Various small and named graphs #------------------------------------------------------------------------------- def bull_graph(create_using=None): """Return the Bull graph. """ description=[ "adjacencylist", "Bull Graph", 5, [[2,3],[1,3,4],[1,2,5],[2],[3]] ] G=make_small_undirected_graph(description, create_using) return G def chvatal_graph(create_using=None): """Return the Chvatal graph.""" description=[ "adjacencylist", "Chvatal Graph", 12, [[2,5,7,10],[3,6,8],[4,7,9],[5,8,10], [6,9],[11,12],[11,12],[9,12], [11],[11,12],[],[]] ] G=make_small_undirected_graph(description, create_using) return G def cubical_graph(create_using=None): """Return the 3-regular Platonic Cubical graph.""" description=[ "adjacencylist", "Platonic Cubical Graph", 8, [[2,4,5],[1,3,8],[2,4,7],[1,3,6], [1,6,8],[4,5,7],[3,6,8],[2,5,7]] ] G=make_small_undirected_graph(description, create_using) return G def desargues_graph(create_using=None): """ Return the Desargues graph.""" G=LCF_graph(20, [5,-5,9,-9], 5, create_using) G.name="Desargues Graph" return G def diamond_graph(create_using=None): """Return the Diamond graph. """ description=[ "adjacencylist", "Diamond Graph", 4, [[2,3],[1,3,4],[1,2,4],[2,3]] ] G=make_small_undirected_graph(description, create_using) return G def dodecahedral_graph(create_using=None): """ Return the Platonic Dodecahedral graph. """ G=LCF_graph(20, [10,7,4,-4,-7,10,-4,7,-7,4], 2, create_using) G.name="Dodecahedral Graph" return G def frucht_graph(create_using=None): """Return the Frucht Graph. The Frucht Graph is the smallest cubical graph whose automorphism group consists only of the identity element. """ G=cycle_graph(7, create_using) G.add_edges_from([[0,7],[1,7],[2,8],[3,9],[4,9],[5,10],[6,10], [7,11],[8,11],[8,9],[10,11]]) G.name="Frucht Graph" return G def heawood_graph(create_using=None): """ Return the Heawood graph, a (3,6) cage. """ G=LCF_graph(14, [5,-5], 7, create_using) G.name="Heawood Graph" return G def house_graph(create_using=None): """Return the House graph (square with triangle on top).""" description=[ "adjacencylist", "House Graph", 5, [[2,3],[1,4],[1,4,5],[2,3,5],[3,4]] ] G=make_small_undirected_graph(description, create_using) return G def house_x_graph(create_using=None): """Return the House graph with a cross inside the house square.""" description=[ "adjacencylist", "House-with-X-inside Graph", 5, [[2,3,4],[1,3,4],[1,2,4,5],[1,2,3,5],[3,4]] ] G=make_small_undirected_graph(description, create_using) return G def icosahedral_graph(create_using=None): """Return the Platonic Icosahedral graph.""" description=[ "adjacencylist", "Platonic Icosahedral Graph", 12, [[2,6,8,9,12],[3,6,7,9],[4,7,9,10],[5,7,10,11], [6,7,11,12],[7,12],[],[9,10,11,12], [10],[11],[12],[]] ] G=make_small_undirected_graph(description, create_using) return G def krackhardt_kite_graph(create_using=None): """ Return the Krackhardt Kite Social Network. A 10 actor social network introduced by David Krackhardt to illustrate: degree, betweenness, centrality, closeness, etc. The traditional labeling is: Andre=1, Beverley=2, Carol=3, Diane=4, Ed=5, Fernando=6, Garth=7, Heather=8, Ike=9, Jane=10. """ description=[ "adjacencylist", "Krackhardt Kite Social Network", 10, [[2,3,4,6],[1,4,5,7],[1,4,6],[1,2,3,5,6,7],[2,4,7], [1,3,4,7,8],[2,4,5,6,8],[6,7,9],[8,10],[9]] ] G=make_small_undirected_graph(description, create_using) return G def moebius_kantor_graph(create_using=None): """Return the Moebius-Kantor graph.""" G=LCF_graph(16, [5,-5], 8, create_using) G.name="Moebius-Kantor Graph" return G def octahedral_graph(create_using=None): """Return the Platonic Octahedral graph.""" description=[ "adjacencylist", "Platonic Octahedral Graph", 6, [[2,3,4,5],[3,4,6],[5,6],[5,6],[6],[]] ] G=make_small_undirected_graph(description, create_using) return G def pappus_graph(): """ Return the Pappus graph.""" G=LCF_graph(18,[5,7,-7,7,-7,-5],3) G.name="Pappus Graph" return G def petersen_graph(create_using=None): """Return the Petersen graph.""" description=[ "adjacencylist", "Petersen Graph", 10, [[2,5,6],[1,3,7],[2,4,8],[3,5,9],[4,1,10],[1,8,9],[2,9,10], [3,6,10],[4,6,7],[5,7,8]] ] G=make_small_undirected_graph(description, create_using) return G def sedgewick_maze_graph(create_using=None): """ Return a small maze with a cycle. This is the maze used in Sedgewick,3rd Edition, Part 5, Graph Algorithms, Chapter 18, e.g. Figure 18.2 and following. Nodes are numbered 0,..,7 """ G=empty_graph(0, create_using) G.add_nodes_from(range(8)) G.add_edges_from([[0,2],[0,7],[0,5]]) G.add_edges_from([[1,7],[2,6]]) G.add_edges_from([[3,4],[3,5]]) G.add_edges_from([[4,5],[4,7],[4,6]]) G.name="Sedgewick Maze" return G def tetrahedral_graph(create_using=None): """ Return the 3-regular Platonic Tetrahedral graph.""" G=complete_graph(4, create_using) G.name="Platonic Tetrahedral graph" return G def truncated_cube_graph(create_using=None): """Return the skeleton of the truncated cube.""" description=[ "adjacencylist", "Truncated Cube Graph", 24, [[2,3,5],[12,15],[4,5],[7,9], [6],[17,19],[8,9],[11,13], [10],[18,21],[12,13],[15], [14],[22,23],[16],[20,24], [18,19],[21],[20],[24], [22],[23],[24],[]] ] G=make_small_undirected_graph(description, create_using) return G def truncated_tetrahedron_graph(create_using=None): """Return the skeleton of the truncated Platonic tetrahedron.""" G=path_graph(12, create_using) # G.add_edges_from([(1,3),(1,10),(2,7),(4,12),(5,12),(6,8),(9,11)]) G.add_edges_from([(0,2),(0,9),(1,6),(3,11),(4,11),(5,7),(8,10)]) G.name="Truncated Tetrahedron Graph" return G def tutte_graph(create_using=None): """Return the Tutte graph.""" description=[ "adjacencylist", "Tutte's Graph", 46, [[2,3,4],[5,27],[11,12],[19,20],[6,34], [7,30],[8,28],[9,15],[10,39],[11,38], [40],[13,40],[14,36],[15,16],[35], [17,23],[18,45],[19,44],[46],[21,46], [22,42],[23,24],[41],[25,28],[26,33], [27,32],[34],[29],[30,33],[31], [32,34],[33],[],[],[36,39], [37],[38,40],[39],[],[], [42,45],[43],[44,46],[45],[],[]] ] G=make_small_undirected_graph(description, create_using) return G

bsd-3-clause

looopTools/sw9-source

.waf-1.9.8-6657823688b736c1d1a4e2c4e8e198b4/waflib/extras/wurf/dependency.py

1

2578

#! /usr/bin/env python # encoding: utf-8 # WARNING! Do not edit! https://waf.io/book/index.html#_obtaining_the_waf_file import hashlib import json import collections import pprint class Dependency(object): def __init__(self,**kwargs): assert"sha1"not in kwargs if'recurse'not in kwargs: kwargs['recurse']=True if'optional'not in kwargs: kwargs['optional']=False if'internal'not in kwargs: kwargs['internal']=False hash_attributes=kwargs.copy() hash_attributes.pop('optional',None) hash_attributes.pop('internal',None) s=json.dumps(hash_attributes,sort_keys=True) sha1=hashlib.sha1(s.encode('utf-8')).hexdigest() object.__setattr__(self,'info',kwargs) self.info['sha1']=sha1 self.info['hash']=None object.__setattr__(self,'read_write',dict()) object.__setattr__(self,'audit',list()) self.error_messages=[] def rewrite(self,attribute,value,reason): if value==None: self.__delete(attribute=attribute,reason=reason) elif attribute not in self.info: self.__create(attribute=attribute,value=value,reason=reason) else: self.__modify(attribute=attribute,value=value,reason=reason) def __delete(self,attribute,reason): if attribute not in self.info: raise AttributeError("Cannot delete non existing attribute {}".format(attribute)) audit='Deleting "{}". Reason: {}'.format(attribute,reason) del self.info[attribute] self.audit.append(audit) def __create(self,attribute,value,reason): audit='Creating "{}" value "{}". Reason: {}'.format(attribute,value,reason) self.audit.append(audit) self.info[attribute]=value def __modify(self,attribute,value,reason): audit='Modifying "{}" from "{}" to "{}". Reason: {}'.format(attribute,self.info[attribute],value,reason) self.audit.append(audit) self.info[attribute]=value def __getattr__(self,attribute): if attribute in self.info: return self.info[attribute] elif attribute in self.read_write: return self.read_write[attribute] else: return None def __setattr__(self,attribute,value): if attribute in self.info: raise AttributeError("Attribute {} read-only.".format(attribute)) else: self.read_write[attribute]=value def __contains__(self,attribute): return(attribute in self.info)or(attribute in self.read_write) def __str__(self): return"Dependency info:\n{}\nread_write: {}\naudit: {}".format(pprint.pformat(self.info,indent=2),pprint.pformat(self.read_write,indent=2),pprint.pformat(self.audit,indent=2)) def __hash__(self): if not self.info['hash']: self.info['hash']=hash(self.info['sha1']) return self.info['hash']

mit

Artanicus/python-cozify

util/device-fade-test.py

1

1301

#!/usr/bin/env python3 from cozify import hub import numpy, time from absl import flags, app FLAGS = flags.FLAGS flags.DEFINE_string('device', None, 'Device to operate on.') flags.DEFINE_float('delay', 0.5, 'Step length in seconds.') flags.DEFINE_float('steps', 20, 'Amount of steps to divide into.') flags.DEFINE_bool('verify', False, 'Verify if value went through as-is.') green = '\u001b[32m' yellow = '\u001b[33m' red = '\u001b[31m' reset = '\u001b[0m' def main(argv): del argv previous = None for step in numpy.flipud(numpy.linspace(0.0, 1.0, num=FLAGS.steps)): hub.light_brightness(FLAGS.device, step) time.sleep(FLAGS.delay) read = 'N/A' result = '?' if FLAGS.verify: devs = hub.devices() read = devs[FLAGS.device]['state']['brightness'] if step == read: result = '✔' color = green else: result = '✖' if read == previous: color = yellow else: color = red previous = step print('{3}[{2}] set: {0} vs. read: {1}{4}'.format(step, read, result, color, reset)) if __name__ == "__main__": flags.mark_flag_as_required('device') app.run(main)

mit

v1k45/django-notify-x

notify/models.py

1

14033

from django.contrib.contenttypes.fields import GenericForeignKey from django.contrib.contenttypes.models import ContentType from django.db import models from django.conf import settings from django.db.models import QuerySet from jsonfield.fields import JSONField from six import python_2_unicode_compatible from django.utils.html import escape from django.utils.timesince import timesince from django.utils.translation import ugettext_lazy as _ from django.utils.encoding import force_text from django.utils.functional import cached_property from .utils import prefetch_relations class NotificationQueryset(QuerySet): """ Chain-able QuerySets using ```.as_manager()``. """ def prefetch(self): """ Marks the current queryset to prefetch all generic relations. """ qs = self.select_related() qs._prefetch_relations = True return qs def _fetch_all(self): if self._result_cache is None: if hasattr(self, '_prefetch_relations'): # removes the flag since prefetch_relations is recursive del self._prefetch_relations prefetch_relations(self) self._prefetch_relations = True return super(NotificationQueryset, self)._fetch_all() def _clone(self, **kwargs): clone = super(NotificationQueryset, self)._clone(**kwargs) if hasattr(self, '_prefetch_relations'): clone._prefetch_relations = True return clone def active(self): """ QuerySet filter() for retrieving both read and unread notifications which are not soft-deleted. :return: Non soft-deleted notifications. """ return self.filter(deleted=False) def read(self): """ QuerySet filter() for retrieving read notifications. :return: Read and active Notifications filter(). """ return self.filter(deleted=False, read=True) def unread(self): """ QuerySet filter() for retrieving unread notifications. :return: Unread and active Notifications filter(). """ return self.filter(deleted=False, read=False) def unread_all(self, user=None): """ Marks all notifications as unread for a user (if supplied) :param user: Notification recipient. :return: Updates QuerySet as unread. """ qs = self.read() if user: qs = qs.filter(recipient=user) qs.update(read=False) def read_all(self, user=None): """ Marks all notifications as read for a user (if supplied) :param user: Notification recipient. :return: Updates QuerySet as read. """ qs = self.unread() if user: qs = qs.filter(recipient=user) qs.update(read=True) def delete_all(self, user=None): """ Method to soft-delete all notifications of a User (if supplied) :param user: Notification recipient. :return: Updates QuerySet as soft-deleted. """ qs = self.active() if user: qs = qs.filter(recipient=user) soft_delete = getattr(settings, 'NOTIFY_SOFT_DELETE', True) if soft_delete: qs.update(deleted=True) else: qs.delete() def active_all(self, user=None): """ Method to soft-delete all notifications of a User (if supplied) :param user: Notification recipient. :return: Updates QuerySet as soft-deleted. """ qs = self.deleted() if user: qs = qs.filter(recipient=user) qs.update(deleted=False) def deleted(self): """ QuerySet ``filter()`` for retrieving soft-deleted notifications. :return: Soft deleted notification filter() """ return self.filter(deleted=True) @python_2_unicode_compatible class Notification(models.Model): """ **Notification Model for storing notifications. (Yeah, too obvious)** This model is pretty-much a replica of ``django-notifications``'s model. The newly added fields just adds a feature to allow anonymous ``actors``, ``targets`` and ``object``. **Attributes**: :recipient: The user who receives notification. :verb: Action performed by actor (not necessarily). :description: Option description for your notification. :actor_text: Anonymous actor who is not in content-type. :actor_url: Since the actor is not in content-type, a custom URL for it. *...Same for target and obj*. :nf_type: | Each notification is different, they must be formatted | differently during HTML rendering. For this, each | notification gets to carry it own *notification type*. | | This notification type will be used to search | the special template for the notification located at | ``notifications/includes/NF_TYPE.html`` of your | template directory. | | The main reason to add this field is to save you | from the pain of writing ``if...elif...else`` blocks | in your template file just for handling how | notifications will get rendered. | | With this, you can just save template for an individual | notification type and call the *template-tag* to render | all notifications for you without writing a single | ``if...elif...else block``. | | You'll just need to do a | ``{% render_notifications using NOTIFICATION_OBJ %}`` | and you'll get your notifications rendered. | | By default, every ``nf_type`` is set to ``default``. :extra: **JSONField**, holds other optional data you want the notification to carry in JSON format. :deleted: Useful when you want to *soft delete* your notifications. """ recipient = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='notifications', on_delete=models.CASCADE, verbose_name=_('Notification receiver')) # actor attributes. actor_content_type = models.ForeignKey( ContentType, null=True, blank=True, related_name='notify_actor', on_delete=models.CASCADE, verbose_name=_('Content type of actor object')) actor_object_id = models.PositiveIntegerField( null=True, blank=True, verbose_name=_('ID of the actor object')) actor_content_object = GenericForeignKey('actor_content_type', 'actor_object_id') actor_text = models.CharField( max_length=50, blank=True, null=True, verbose_name=_('Anonymous text for actor')) actor_url_text = models.CharField( blank=True, null=True, max_length=200, verbose_name=_('Anonymous URL for actor')) # basic details. verb = models.CharField(max_length=100, verbose_name=_('Verb of the action')) description = models.CharField( max_length=255, blank=True, null=True, verbose_name=_('Description of the notification')) nf_type = models.CharField(max_length=20, default='default', verbose_name=_('Type of notification')) # TODO: Add a field to store notification cover images. # target attributes. target_content_type = models.ForeignKey( ContentType, null=True, blank=True, related_name='notify_target', on_delete=models.CASCADE, verbose_name=_('Content type of target object')) target_object_id = models.PositiveIntegerField( null=True, blank=True, verbose_name=_('ID of the target object')) target_content_object = GenericForeignKey('target_content_type', 'target_object_id') target_text = models.CharField( max_length=50, blank=True, null=True, verbose_name=_('Anonymous text for target')) target_url_text = models.CharField( blank=True, null=True, max_length=200, verbose_name=_('Anonymous URL for target')) # obj attributes. obj_content_type = models.ForeignKey( ContentType, null=True, blank=True, related_name='notify_object', on_delete=models.CASCADE, verbose_name=_('Content type of action object')) obj_object_id = models.PositiveIntegerField( null=True, blank=True, verbose_name=_('ID of the target object')) obj_content_object = GenericForeignKey('obj_content_type', 'obj_object_id') obj_text = models.CharField( max_length=50, blank=True, null=True, verbose_name=_('Anonymous text for action object')) obj_url_text = models.CharField( blank=True, null=True, max_length=200, verbose_name=_('Anonymous URL for action object')) extra = JSONField(null=True, blank=True, verbose_name=_('JSONField to store addtional data')) # Advanced details. created = models.DateTimeField(auto_now=False, auto_now_add=True) read = models.BooleanField(default=False, verbose_name=_('Read status')) deleted = models.BooleanField(default=False, verbose_name=_('Soft delete status')) objects = NotificationQueryset.as_manager() class Meta(object): ordering = ('-created', ) def __str__(self): ctx = { 'actor': self.actor or self.actor_text, 'verb': self.verb, 'description': self.description, 'target': self.target or self.target_text, 'obj': self.obj or self.obj_text, 'at': timesince(self.created), } if ctx['actor']: if not ctx['target']: return _("{actor} {verb} {at} ago").format(**ctx) elif not ctx['obj']: return _("{actor} {verb} on {target} {at} ago").format(**ctx) elif ctx['obj']: return _( "{actor} {verb} {obj} on {target} {at} ago").format(**ctx) return _("{description} -- {at} ago").format(**ctx) def mark_as_read(self): """ Marks notification as read """ self.read = True self.save() def mark_as_unread(self): """ Marks notification as unread. """ self.read = False self.save() @cached_property def actor(self): """ Property to return actor object/text to keep things DRY. :return: Actor object or Text or None. """ return self.actor_content_object or self.actor_text @cached_property def actor_url(self): """ Property to return permalink of the actor. Uses ``get_absolute_url()``. If ``get_absolute_url()`` method fails, it tries to grab URL from ``actor_url_text``, if it fails again, returns a "#". :return: URL for the actor. """ try: url = self.actor_content_object.get_absolute_url() except AttributeError: url = self.actor_url_text or "#" return url @cached_property def target(self): """ See ``actor`` property :return: Target object or Text or None """ return self.target_content_object or self.target_text @cached_property def target_url(self): """ See ``actor_url`` property. :return: URL for the target. """ try: url = self.target_content_object.get_absolute_url() except AttributeError: url = self.target_url_text or "#" return url @cached_property def obj(self): """ See ``actor`` property. :return: Action Object or Text or None. """ return self.obj_content_object or self.obj_text @cached_property def obj_url(self): """ See ``actor_url`` property. :return: URL for Action Object. """ try: url = self.obj_content_object.get_absolute_url() except AttributeError: url = self.obj_url_text or "#" return url @staticmethod def do_escape(obj): """ Method to HTML escape an object or set it to None conditionally. performs ``force_text()`` on the argument so that a foreignkey gets serialized? and spit out the ``__str__`` output instead of an Object. :param obj: Object to escape. :return: HTML escaped and JSON-friendly data. """ return escape(force_text(obj)) if obj else None def as_json(self): """ Notification data in a Python dictionary to which later gets supplied to JSONResponse so that it gets JSON serialized the *django-way* :return: Dictionary format of the QuerySet object. """ data = { "id": self.id, "actor": self.do_escape(self.actor), "actor_url": self.do_escape(self.actor_url), "verb": self.do_escape(self.verb), "description": self.do_escape(self.description), "read": self.read, "nf_type": self.do_escape(self.nf_type), "target": self.do_escape(self.target), "target_url": self.do_escape(self.target_url), "obj": self.do_escape(self.obj), "obj_url": self.do_escape(self.obj_url), "created": self.created, "data": self.extra, } return data

mit

GoogleCloudDataproc/cloud-dataproc

codelabs/spark-nlp/topic_model.py

1

8715

# Copyright 2019 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # This code accompanies this codelab: https://codelabs.developers.google.com/codelabs/spark-nlp. # In this example, we will build a topic model using spark-nlp and Spark ML. # In order for this code to work properly, a bucket name must be provided. # Python imports import sys # spark-nlp components. Each one is incorporated into our pipeline. from sparknlp.annotator import Lemmatizer, Stemmer, Tokenizer, Normalizer from sparknlp.base import DocumentAssembler, Finisher # A Spark Session is how we interact with Spark SQL to create Dataframes from pyspark.sql import SparkSession # These allow us to create a schema for our data from pyspark.sql.types import StructField, StructType, StringType, LongType # Spark Pipelines allow us to sequentially add components such as transformers from pyspark.ml import Pipeline # These are components we will incorporate into our pipeline. from pyspark.ml.feature import StopWordsRemover, CountVectorizer, IDF # LDA is our model of choice for topic modeling from pyspark.ml.clustering import LDA # Some transformers require the usage of other Spark ML functions. We import them here from pyspark.sql.functions import col, lit, concat, regexp_replace # This will help catch some PySpark errors from pyspark.sql.utils import AnalysisException # Assign bucket where the data lives try: bucket = sys.argv[1] except IndexError: print("Please provide a bucket name") sys.exit(1) # Create a SparkSession under the name "reddit". Viewable via the Spark UI spark = SparkSession.builder.appName("reddit topic model").getOrCreate() # Create a three column schema consisting of two strings and a long integer fields = [StructField("title", StringType(), True), StructField("body", StringType(), True), StructField("created_at", LongType(), True)] schema = StructType(fields) # We'll attempt to process every year / month combination below. years = ['2016', '2017', '2018', '2019'] months = ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12'] # This is the subreddit we're working with. subreddit = "food" # Create a base dataframe. reddit_data = spark.createDataFrame([], schema) # Keep a running list of all files that will be processed files_read = [] for year in years: for month in months: # In the form of <project-id>.<dataset>.<table> gs_uri = f"gs://{bucket}/reddit_posts/{year}/{month}/{subreddit}.csv.gz" # If the table doesn't exist we will simply continue and not # log it into our "tables_read" list try: reddit_data = ( spark.read.format('csv') .options(codec="org.apache.hadoop.io.compress.GzipCodec") .load(gs_uri, schema=schema) .union(reddit_data) ) files_read.append(gs_uri) except AnalysisException: continue if len(files_read) == 0: print('No files read') sys.exit(1) # Replacing null values with their respective typed-equivalent is usually # easier to work with. In this case, we'll replace nulls with empty strings. # Since some of our data doesn't have a body, we can combine all of the text # for the titles and bodies so that every row has useful data. df_train = ( reddit_data # Replace null values with an empty string .fillna("") .select( # Combine columns concat( # First column to concatenate. col() is used to specify that we're referencing a column col("title"), # Literal character that will be between the concatenated columns. lit(" "), # Second column to concatenate. col("body") # Change the name of the new column ).alias("text") ) # The text has several tags including [REMOVED] or [DELETED] for redacted content. # We'll replace these with empty strings. .select( regexp_replace(col("text"), "\[.*?\]", "") .alias("text") ) ) # Now, we begin assembling our pipeline. Each component here is used to some transformation to the data. # The Document Assembler takes the raw text data and convert it into a format that can # be tokenized. It becomes one of spark-nlp native object types, the "Document". document_assembler = DocumentAssembler().setInputCol("text").setOutputCol("document") # The Tokenizer takes data that is of the "Document" type and tokenizes it. # While slightly more involved than this, this is effectively taking a string and splitting # it along ths spaces, so each word is its own string. The data then becomes the # spark-nlp native type "Token". tokenizer = Tokenizer().setInputCols(["document"]).setOutputCol("token") # The Normalizer will group words together based on similar semantic meaning. normalizer = Normalizer().setInputCols(["token"]).setOutputCol("normalizer") # The Stemmer takes objects of class "Token" and converts the words into their # root meaning. For instance, the words "cars", "cars'" and "car's" would all be replaced # with the word "car". stemmer = Stemmer().setInputCols(["normalizer"]).setOutputCol("stem") # The Finisher signals to spark-nlp allows us to access the data outside of spark-nlp # components. For instance, we can now feed the data into components from Spark MLlib. finisher = Finisher().setInputCols(["stem"]).setOutputCols(["to_spark"]).setValueSplitSymbol(" ") # Stopwords are common words that generally don't add much detail to the meaning # of a body of text. In English, these are mostly "articles" such as the words "the" # and "of". stopword_remover = StopWordsRemover(inputCol="to_spark", outputCol="filtered") # Here we implement TF-IDF as an input to our LDA model. CountVectorizer (TF) keeps track # of the vocabulary that's being created so we can map our topics back to their # corresponding words. # TF (term frequency) creates a matrix that counts how many times each word in the # vocabulary appears in each body of text. This then gives each word a weight based # on it's frequency. tf = CountVectorizer(inputCol="filtered", outputCol="raw_features") # Here we implement the IDF portion. IDF (Inverse document frequency) reduces # the weights of commonly-appearing words. idf = IDF(inputCol="raw_features", outputCol="features") # LDA creates a statistical representation of how frequently words appear # together in order to create "topics" or groups of commonly appearing words. # In this case, we'll create 5 topics. lda = LDA(k=5) # We add all of the transformers into a Pipeline object. Each transformer # will execute in the ordered provided to the "stages" parameter pipeline = Pipeline( stages = [ document_assembler, tokenizer, normalizer, stemmer, finisher, stopword_remover, tf, idf, lda ] ) # We fit the data to the model. model = pipeline.fit(df_train) # Now that we have completed a pipeline, we want to output the topics as human-readable. # To do this, we need to grab the vocabulary generated from our pipeline, grab the topic # model and do the appropriate mapping. The output from each individual component lives # in the model object. We can access them by referring to them by their position in # the pipeline via model.stages[<ind>] # Let's create a reference our vocabulary. vocab = model.stages[-3].vocabulary # Next, let's grab the topics generated by our LDA model via describeTopics(). Using collect(), # we load the output into a Python array. raw_topics = model.stages[-1].describeTopics(maxTermsPerTopic=5).collect() # Lastly, let's get the indices of the vocabulary terms from our topics topic_inds = [ind.termIndices for ind in raw_topics] # The indices we just grab directly map to the term at position <ind> from our vocabulary. # Using the below code, we can generate the mappings from our topic indicies to our vocabulary. topics = [] for topic in topic_inds: _topic = [] for ind in topic: _topic.append(vocab[ind]) topics.append(_topic) # Let's see our topics! for i, topic in enumerate(topics, start=1): print(f"topic {i}: {topic}")

apache-2.0

Spiderlover/Toontown

toontown/suit/SuitBase.py

1

3300

import SuitDNA from SuitLegList import * import SuitTimings from direct.directnotify import DirectNotifyGlobal from direct.distributed.ClockDelta import * from pandac.PandaModules import * from pandac.PandaModules import Point3 from toontown.battle import SuitBattleGlobals from toontown.toonbase import TTLocalizer TIME_BUFFER_PER_WPT = 0.25 TIME_DIVISOR = 100 DISTRIBUTE_TASK_CREATION = 0 class SuitBase: notify = DirectNotifyGlobal.directNotify.newCategory('SuitBase') def __init__(self): self.dna = None self.level = 0 self.maxHP = 10 self.currHP = 10 self.isSkelecog = 0 self.isWaiter = 0 self.isVirtual = 0 self.isRental = 0 return def delete(self): if hasattr(self, 'legList'): del self.legList def getCurrHp(self): if hasattr(self, 'currHP') and self.currHP: return self.currHP else: self.notify.error('currHP is None') return 'unknown' def getMaxHp(self): if hasattr(self, 'maxHP') and self.maxHP: return self.maxHP else: self.notify.error('maxHP is None') return 'unknown' def getStyleName(self): if hasattr(self, 'dna') and self.dna: return self.dna.name else: self.notify.error('called getStyleName() before dna was set!') return 'unknown' def getStyleDept(self): if hasattr(self, 'dna') and self.dna: return SuitDNA.getDeptFullname(self.dna.dept) else: self.notify.error('called getStyleDept() before dna was set!') return 'unknown' def getLevel(self): return self.level def setLevel(self, level): self.level = level nameWLevel = TTLocalizer.SuitBaseNameWithLevel % {'name': self.name, 'dept': self.getStyleDept(), 'level': self.getActualLevel()} self.setDisplayName(nameWLevel) attributes = SuitBattleGlobals.SuitAttributes[self.dna.name] self.maxHP = attributes['hp'][self.level] self.currHP = self.maxHP def getSkelecog(self): return self.isSkelecog def setSkelecog(self, flag): self.isSkelecog = flag def setWaiter(self, flag): self.isWaiter = flag def setVirtual(self, flag): self.isVirtual = flag def setRental(self, flag): self.isRental = flag def getActualLevel(self): if hasattr(self, 'dna'): return SuitBattleGlobals.getActualFromRelativeLevel(self.getStyleName(), self.level) + 1 else: self.notify.warning('called getActualLevel with no DNA, returning 1 for level') return 1 def setPath(self, path): self.path = path self.pathLength = self.path.getNumPoints() def getPath(self): return self.path def printPath(self): print '%d points in path' % self.pathLength for currPathPt in xrange(self.pathLength): indexVal = self.path.getPointIndex(currPathPt) print '\t', self.sp.dnaStore.getSuitPointWithIndex(indexVal) def makeLegList(self): self.legList = SuitLegList(self.path, self.sp.dnaStore)

mit

pattywgm/funny-spider

douban/douban/spiders/movie_awards.py

1

2888

#!/usr/bin/env python # encoding: utf-8 """ @version: 1.0 @file: movie_awards.py @time: 17/10/19 下午10:35 @desc: 电影获奖数据抓取 28items/每分钟 被ban """ import re from copy import deepcopy from os.path import exists import scrapy from douban.items import AwardsItem from douban.utils.my_utils import load_obj, replace_dot _META_VERSION = 'v1.0' _AWARDS = 'https://movie.douban.com/subject/{}/awards/' class MovieAwards(scrapy.Spider): name = 'movie_awards' meta_version = _META_VERSION def __init__(self): """ :param urls: :param done: 已经抓取完成的,用于断点续爬 :return: """ self.urls = load_obj('./records/urls.pkl') self.done = list() if exists('./records/{}_done.pkl'.format(self.name)): self.done = load_obj('./records/{}_done.pkl'.format(self.name)) self.new_done = deepcopy(self.done) def start_requests(self): req = list() for url in self.urls: movie_code = re.findall('\d+', url)[0] award_url = _AWARDS.format(movie_code) if award_url not in self.done: req.append(scrapy.Request(award_url, callback=self.parse, meta={'movie_code': movie_code})) return req def parse(self, response): url = response.url self.logger.info('Crawl {}'.format(url)) item = AwardsItem() item['url'] = url item['movie_code'] = response.meta['movie_code'] award_divs = response.xpath('//div[@class="awards"]') item['awards'] = [self.parse_award_detail(div) for div in award_divs] yield item def parse_award_detail(self, award_div): """ 解析获奖详细信息 :param award_div: :return: """ award_detail = dict() # 颁奖方及年份 url = award_div.xpath('.//h2/a/@href').extract_first() name = award_div.xpath('.//h2/a/text()').extract_first() year = award_div.xpath('.//h2/span/text()').extract_first().replace('(', '').replace(')', '').strip() award_detail.update({'award_provider': {name: url}, 'year': year}) # 具体奖项名及获奖者 awards = list() for ul in award_div.xpath('.//ul[@class="award"]'): award_name = ul.xpath('./li[1]/text()').extract_first() award_persons = list() for person in ul.xpath('./li[position()>1]'): if person.xpath('./a').extract_first() is None: break p_name = replace_dot(person.xpath('./a/text()').extract()) p_url = person.xpath('./a/@href').extract() award_persons.append(dict(zip(p_name, p_url))) awards.append({award_name: award_persons}) award_detail.update({'awards': awards}) return award_detail

gpl-3.0

rsignell-usgs/yaml2ncml

setup.py

1

1966

import os import sys from setuptools import setup from setuptools.command.test import test as TestCommand class PyTest(TestCommand): def finalize_options(self): TestCommand.finalize_options(self) self.test_args = ['--verbose'] self.test_suite = True def run_tests(self): import pytest errno = pytest.main(self.test_args) sys.exit(errno) def extract_version(): version = None fdir = os.path.dirname(__file__) fnme = os.path.join(fdir, 'yaml2ncml', '__init__.py') with open(fnme) as fd: for line in fd: if (line.startswith('__version__')): _, version = line.split('=') version = version.strip()[1:-1] break return version rootpath = os.path.abspath(os.path.dirname(__file__)) def read(*parts): return open(os.path.join(rootpath, *parts), 'r').read() long_description = '{}\n{}'.format(read('README.rst'), read('CHANGES.txt')) LICENSE = read('LICENSE.txt') with open('requirements.txt') as f: require = f.readlines() install_requires = [r.strip() for r in require] setup(name='yaml2ncml', version=extract_version(), packages=['yaml2ncml'], license=LICENSE, description='ncML aggregation from YAML specifications', long_description=long_description, author='Rich Signell', author_email='rsignell@usgs.gov', install_requires=install_requires, entry_points=dict(console_scripts=[ 'yaml2ncml = yaml2ncml.yaml2ncml:main'] ), url='https://github.com/rsignell-usgs/yaml2ncml', keywords=['YAML', 'ncml'], classifiers=['Development Status :: 4 - Beta', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3.4', 'License :: OSI Approved :: MIT License'], tests_require=['pytest'], cmdclass=dict(test=PyTest), zip_safe=False)

mit

opencord/voltha

ofagent/main.py

1

9975

#!/usr/bin/env python # # Copyright 2017 the original author or authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import argparse import os import yaml from twisted.internet import reactor from twisted.internet.defer import inlineCallbacks from common.structlog_setup import setup_logging from common.utils.dockerhelpers import get_my_containers_name from common.utils.nethelpers import get_my_primary_local_ipv4 from connection_mgr import ConnectionManager defs = dict( config=os.environ.get('CONFIG', './ofagent.yml'), logconfig=os.environ.get('LOGCONFIG', './logconfig.yml'), consul=os.environ.get('CONSUL', 'localhost:8500'), controller=os.environ.get('CONTROLLER', 'localhost:6653'), external_host_address=os.environ.get('EXTERNAL_HOST_ADDRESS', get_my_primary_local_ipv4()), grpc_endpoint=os.environ.get('GRPC_ENDPOINT', 'localhost:50055'), instance_id=os.environ.get('INSTANCE_ID', os.environ.get('HOSTNAME', '1')), internal_host_address=os.environ.get('INTERNAL_HOST_ADDRESS', get_my_primary_local_ipv4()), work_dir=os.environ.get('WORK_DIR', '/tmp/ofagent'), key_file=os.environ.get('KEY_FILE', '/ofagent/pki/voltha.key'), cert_file=os.environ.get('CERT_FILE', '/ofagent/pki/voltha.crt') ) def parse_args(): parser = argparse.ArgumentParser() _help = ('Path to ofagent.yml config file (default: %s). ' 'If relative, it is relative to main.py of ofagent.' % defs['config']) parser.add_argument('-c', '--config', dest='config', action='store', default=defs['config'], help=_help) _help = ('Path to logconfig.yml config file (default: %s). ' 'If relative, it is relative to main.py of voltha.' % defs['logconfig']) parser.add_argument('-l', '--logconfig', dest='logconfig', action='store', default=defs['logconfig'], help=_help) _help = '<hostname>:<port> to consul agent (default: %s)' % defs['consul'] parser.add_argument( '-C', '--consul', dest='consul', action='store', default=defs['consul'], help=_help) _help = '<hostname1>:<port1> <hostname2>:<port2> <hostname3>:<port3> ... <hostnamen>:<portn> to openflow controller (default: %s)' % \ defs['controller'] parser.add_argument( '-O', '--controller',nargs = '*', dest='controller', action='store', default=defs['controller'], help=_help) _help = ('<hostname> or <ip> at which ofagent is reachable from outside ' 'the cluster (default: %s)' % defs['external_host_address']) parser.add_argument('-E', '--external-host-address', dest='external_host_address', action='store', default=defs['external_host_address'], help=_help) _help = ('gRPC end-point to connect to. It can either be a direct' 'definition in the form of <hostname>:<port>, or it can be an' 'indirect definition in the form of @<service-name> where' '<service-name> is the name of the grpc service as registered' 'in consul (example: @voltha-grpc). (default: %s' % defs['grpc_endpoint']) parser.add_argument('-G', '--grpc-endpoint', dest='grpc_endpoint', action='store', default=defs['grpc_endpoint'], help=_help) _help = ('<hostname> or <ip> at which ofagent is reachable from inside' 'the cluster (default: %s)' % defs['internal_host_address']) parser.add_argument('-H', '--internal-host-address', dest='internal_host_address', action='store', default=defs['internal_host_address'], help=_help) _help = ('unique string id of this ofagent instance (default: %s)' % defs['instance_id']) parser.add_argument('-i', '--instance-id', dest='instance_id', action='store', default=defs['instance_id'], help=_help) _help = 'omit startup banner log lines' parser.add_argument('-n', '--no-banner', dest='no_banner', action='store_true', default=False, help=_help) _help = "suppress debug and info logs" parser.add_argument('-q', '--quiet', dest='quiet', action='count', help=_help) _help = 'enable verbose logging' parser.add_argument('-v', '--verbose', dest='verbose', action='count', help=_help) _help = ('work dir to compile and assemble generated files (default=%s)' % defs['work_dir']) parser.add_argument('-w', '--work-dir', dest='work_dir', action='store', default=defs['work_dir'], help=_help) _help = ('use docker container name as ofagent instance id' ' (overrides -i/--instance-id option)') parser.add_argument('--instance-id-is-container-name', dest='instance_id_is_container_name', action='store_true', default=False, help=_help) _help = ('Specify this option to enable TLS security between ofagent \ and onos.') parser.add_argument('-t', '--enable-tls', dest='enable_tls', action='store_true', help=_help) _help = ('key file to be used for tls security (default=%s)' % defs['key_file']) parser.add_argument('-k', '--key-file', dest='key_file', action='store', default=defs['key_file'], help=_help) _help = ('certificate file to be used for tls security (default=%s)' % defs['cert_file']) parser.add_argument('-r', '--cert-file', dest='cert_file', action='store', default=defs['cert_file'], help=_help) args = parser.parse_args() # post-processing if args.instance_id_is_container_name: args.instance_id = get_my_containers_name() return args def load_config(args, configname='config'): argdict = vars(args) path = argdict[configname] if path.startswith('.'): dir = os.path.dirname(os.path.abspath(__file__)) path = os.path.join(dir, path) path = os.path.abspath(path) with open(path) as fd: config = yaml.load(fd) return config banner = r''' ___ _____ _ _ / _ \| ___/ \ __ _ ___ _ __ | |_ | | | | |_ / _ \ / _` |/ _ \ '_ \| __| | |_| | _/ ___ \ (_| | __/ | | | |_ \___/|_|/_/ \_\__, |\___|_| |_|\__| |___/ ''' def print_banner(log): for line in banner.strip('\n').splitlines(): log.info(line) log.info('(to stop: press Ctrl-C)') class Main(object): def __init__(self): self.args = args = parse_args() self.config = load_config(args) self.logconfig = load_config(args, 'logconfig') # May want to specify the gRPC timeout as an arg (in future) # Right now, set a default value self.grpc_timeout = 120 verbosity_adjust = (args.verbose or 0) - (args.quiet or 0) self.log = setup_logging(self.logconfig, args.instance_id, verbosity_adjust=verbosity_adjust) # components self.connection_manager = None self.exiting = False if not args.no_banner: print_banner(self.log) self.startup_components() def start(self): self.start_reactor() # will not return except Keyboard interrupt @inlineCallbacks def startup_components(self): self.log.info('starting-internal-components') args = self.args self.connection_manager = yield ConnectionManager( args.consul, args.grpc_endpoint, self.grpc_timeout, args.controller, args.instance_id, args.enable_tls, args.key_file, args.cert_file).start() self.log.info('started-internal-services') @inlineCallbacks def shutdown_components(self): """Execute before the reactor is shut down""" self.log.info('exiting-on-keyboard-interrupt') self.exiting = True if self.connection_manager is not None: yield self.connection_manager.stop() def start_reactor(self): reactor.callWhenRunning( lambda: self.log.info('twisted-reactor-started')) reactor.addSystemEventTrigger('before', 'shutdown', self.shutdown_components) reactor.suggestThreadPoolSize(30) reactor.run() if __name__ == '__main__': Main().start()

apache-2.0

ludojmj/treelud

server/paramiko/sftp_client.py

1

32863

# Copyright (C) 2003-2007 Robey Pointer <robeypointer@gmail.com> # # This file is part of Paramiko. # # Paramiko is free software; you can redistribute it and/or modify it under the # terms of the GNU Lesser General Public License as published by the Free # Software Foundation; either version 2.1 of the License, or (at your option) # any later version. # # Paramiko is distributed in the hope that it will be useful, but WITHOUT ANY # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with Paramiko; if not, write to the Free Software Foundation, Inc., # 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. from binascii import hexlify import errno import os import stat import threading import time import weakref from paramiko import util from paramiko.channel import Channel from paramiko.message import Message from paramiko.common import INFO, DEBUG, o777 from paramiko.py3compat import bytestring, b, u, long, string_types, bytes_types from paramiko.sftp import BaseSFTP, CMD_OPENDIR, CMD_HANDLE, SFTPError, CMD_READDIR, \ CMD_NAME, CMD_CLOSE, SFTP_FLAG_READ, SFTP_FLAG_WRITE, SFTP_FLAG_CREATE, \ SFTP_FLAG_TRUNC, SFTP_FLAG_APPEND, SFTP_FLAG_EXCL, CMD_OPEN, CMD_REMOVE, \ CMD_RENAME, CMD_MKDIR, CMD_RMDIR, CMD_STAT, CMD_ATTRS, CMD_LSTAT, \ CMD_SYMLINK, CMD_SETSTAT, CMD_READLINK, CMD_REALPATH, CMD_STATUS, SFTP_OK, \ SFTP_EOF, SFTP_NO_SUCH_FILE, SFTP_PERMISSION_DENIED from paramiko.sftp_attr import SFTPAttributes from paramiko.ssh_exception import SSHException from paramiko.sftp_file import SFTPFile from paramiko.util import ClosingContextManager def _to_unicode(s): """ decode a string as ascii or utf8 if possible (as required by the sftp protocol). if neither works, just return a byte string because the server probably doesn't know the filename's encoding. """ try: return s.encode('ascii') except (UnicodeError, AttributeError): try: return s.decode('utf-8') except UnicodeError: return s b_slash = b'/' class SFTPClient(BaseSFTP, ClosingContextManager): """ SFTP client object. Used to open an SFTP session across an open SSH `.Transport` and perform remote file operations. Instances of this class may be used as context managers. """ def __init__(self, sock): """ Create an SFTP client from an existing `.Channel`. The channel should already have requested the ``"sftp"`` subsystem. An alternate way to create an SFTP client context is by using `from_transport`. :param .Channel sock: an open `.Channel` using the ``"sftp"`` subsystem :raises SSHException: if there's an exception while negotiating sftp """ BaseSFTP.__init__(self) self.sock = sock self.ultra_debug = False self.request_number = 1 # lock for request_number self._lock = threading.Lock() self._cwd = None # request # -> SFTPFile self._expecting = weakref.WeakValueDictionary() if type(sock) is Channel: # override default logger transport = self.sock.get_transport() self.logger = util.get_logger(transport.get_log_channel() + '.sftp') self.ultra_debug = transport.get_hexdump() try: server_version = self._send_version() except EOFError: raise SSHException('EOF during negotiation') self._log(INFO, 'Opened sftp connection (server version %d)' % server_version) def from_transport(cls, t, window_size=None, max_packet_size=None): """ Create an SFTP client channel from an open `.Transport`. Setting the window and packet sizes might affect the transfer speed. The default settings in the `.Transport` class are the same as in OpenSSH and should work adequately for both files transfers and interactive sessions. :param .Transport t: an open `.Transport` which is already authenticated :param int window_size: optional window size for the `.SFTPClient` session. :param int max_packet_size: optional max packet size for the `.SFTPClient` session.. :return: a new `.SFTPClient` object, referring to an sftp session (channel) across the transport .. versionchanged:: 1.15 Added the ``window_size`` and ``max_packet_size`` arguments. """ chan = t.open_session(window_size=window_size, max_packet_size=max_packet_size) if chan is None: return None chan.invoke_subsystem('sftp') return cls(chan) from_transport = classmethod(from_transport) def _log(self, level, msg, *args): if isinstance(msg, list): for m in msg: self._log(level, m, *args) else: # escape '%' in msg (they could come from file or directory names) before logging msg = msg.replace('%','%%') super(SFTPClient, self)._log(level, "[chan %s] " + msg, *([self.sock.get_name()] + list(args))) def close(self): """ Close the SFTP session and its underlying channel. .. versionadded:: 1.4 """ self._log(INFO, 'sftp session closed.') self.sock.close() def get_channel(self): """ Return the underlying `.Channel` object for this SFTP session. This might be useful for doing things like setting a timeout on the channel. .. versionadded:: 1.7.1 """ return self.sock def listdir(self, path='.'): """ Return a list containing the names of the entries in the given ``path``. The list is in arbitrary order. It does not include the special entries ``'.'`` and ``'..'`` even if they are present in the folder. This method is meant to mirror ``os.listdir`` as closely as possible. For a list of full `.SFTPAttributes` objects, see `listdir_attr`. :param str path: path to list (defaults to ``'.'``) """ return [f.filename for f in self.listdir_attr(path)] def listdir_attr(self, path='.'): """ Return a list containing `.SFTPAttributes` objects corresponding to files in the given ``path``. The list is in arbitrary order. It does not include the special entries ``'.'`` and ``'..'`` even if they are present in the folder. The returned `.SFTPAttributes` objects will each have an additional field: ``longname``, which may contain a formatted string of the file's attributes, in unix format. The content of this string will probably depend on the SFTP server implementation. :param str path: path to list (defaults to ``'.'``) :return: list of `.SFTPAttributes` objects .. versionadded:: 1.2 """ path = self._adjust_cwd(path) self._log(DEBUG, 'listdir(%r)' % path) t, msg = self._request(CMD_OPENDIR, path) if t != CMD_HANDLE: raise SFTPError('Expected handle') handle = msg.get_binary() filelist = [] while True: try: t, msg = self._request(CMD_READDIR, handle) except EOFError: # done with handle break if t != CMD_NAME: raise SFTPError('Expected name response') count = msg.get_int() for i in range(count): filename = msg.get_text() longname = msg.get_text() attr = SFTPAttributes._from_msg(msg, filename, longname) if (filename != '.') and (filename != '..'): filelist.append(attr) self._request(CMD_CLOSE, handle) return filelist def listdir_iter(self, path='.', read_aheads=50): """ Generator version of `.listdir_attr`. See the API docs for `.listdir_attr` for overall details. This function adds one more kwarg on top of `.listdir_attr`: ``read_aheads``, an integer controlling how many ``SSH_FXP_READDIR`` requests are made to the server. The default of 50 should suffice for most file listings as each request/response cycle may contain multiple files (dependant on server implementation.) .. versionadded:: 1.15 """ path = self._adjust_cwd(path) self._log(DEBUG, 'listdir(%r)' % path) t, msg = self._request(CMD_OPENDIR, path) if t != CMD_HANDLE: raise SFTPError('Expected handle') handle = msg.get_string() nums = list() while True: try: # Send out a bunch of readdir requests so that we can read the # responses later on Section 6.7 of the SSH file transfer RFC # explains this # http://filezilla-project.org/specs/draft-ietf-secsh-filexfer-02.txt for i in range(read_aheads): num = self._async_request(type(None), CMD_READDIR, handle) nums.append(num) # For each of our sent requests # Read and parse the corresponding packets # If we're at the end of our queued requests, then fire off # some more requests # Exit the loop when we've reached the end of the directory # handle for num in nums: t, pkt_data = self._read_packet() msg = Message(pkt_data) new_num = msg.get_int() if num == new_num: if t == CMD_STATUS: self._convert_status(msg) count = msg.get_int() for i in range(count): filename = msg.get_text() longname = msg.get_text() attr = SFTPAttributes._from_msg( msg, filename, longname) if (filename != '.') and (filename != '..'): yield attr # If we've hit the end of our queued requests, reset nums. nums = list() except EOFError: self._request(CMD_CLOSE, handle) return def open(self, filename, mode='r', bufsize=-1): """ Open a file on the remote server. The arguments are the same as for Python's built-in `python:file` (aka `python:open`). A file-like object is returned, which closely mimics the behavior of a normal Python file object, including the ability to be used as a context manager. The mode indicates how the file is to be opened: ``'r'`` for reading, ``'w'`` for writing (truncating an existing file), ``'a'`` for appending, ``'r+'`` for reading/writing, ``'w+'`` for reading/writing (truncating an existing file), ``'a+'`` for reading/appending. The Python ``'b'`` flag is ignored, since SSH treats all files as binary. The ``'U'`` flag is supported in a compatible way. Since 1.5.2, an ``'x'`` flag indicates that the operation should only succeed if the file was created and did not previously exist. This has no direct mapping to Python's file flags, but is commonly known as the ``O_EXCL`` flag in posix. The file will be buffered in standard Python style by default, but can be altered with the ``bufsize`` parameter. ``0`` turns off buffering, ``1`` uses line buffering, and any number greater than 1 (``>1``) uses that specific buffer size. :param str filename: name of the file to open :param str mode: mode (Python-style) to open in :param int bufsize: desired buffering (-1 = default buffer size) :return: an `.SFTPFile` object representing the open file :raises IOError: if the file could not be opened. """ filename = self._adjust_cwd(filename) self._log(DEBUG, 'open(%r, %r)' % (filename, mode)) imode = 0 if ('r' in mode) or ('+' in mode): imode |= SFTP_FLAG_READ if ('w' in mode) or ('+' in mode) or ('a' in mode): imode |= SFTP_FLAG_WRITE if 'w' in mode: imode |= SFTP_FLAG_CREATE | SFTP_FLAG_TRUNC if 'a' in mode: imode |= SFTP_FLAG_CREATE | SFTP_FLAG_APPEND if 'x' in mode: imode |= SFTP_FLAG_CREATE | SFTP_FLAG_EXCL attrblock = SFTPAttributes() t, msg = self._request(CMD_OPEN, filename, imode, attrblock) if t != CMD_HANDLE: raise SFTPError('Expected handle') handle = msg.get_binary() self._log(DEBUG, 'open(%r, %r) -> %s' % (filename, mode, hexlify(handle))) return SFTPFile(self, handle, mode, bufsize) # Python continues to vacillate about "open" vs "file"... file = open def remove(self, path): """ Remove the file at the given path. This only works on files; for removing folders (directories), use `rmdir`. :param str path: path (absolute or relative) of the file to remove :raises IOError: if the path refers to a folder (directory) """ path = self._adjust_cwd(path) self._log(DEBUG, 'remove(%r)' % path) self._request(CMD_REMOVE, path) unlink = remove def rename(self, oldpath, newpath): """ Rename a file or folder from ``oldpath`` to ``newpath``. :param str oldpath: existing name of the file or folder :param str newpath: new name for the file or folder :raises IOError: if ``newpath`` is a folder, or something else goes wrong """ oldpath = self._adjust_cwd(oldpath) newpath = self._adjust_cwd(newpath) self._log(DEBUG, 'rename(%r, %r)' % (oldpath, newpath)) self._request(CMD_RENAME, oldpath, newpath) def mkdir(self, path, mode=o777): """ Create a folder (directory) named ``path`` with numeric mode ``mode``. The default mode is 0777 (octal). On some systems, mode is ignored. Where it is used, the current umask value is first masked out. :param str path: name of the folder to create :param int mode: permissions (posix-style) for the newly-created folder """ path = self._adjust_cwd(path) self._log(DEBUG, 'mkdir(%r, %r)' % (path, mode)) attr = SFTPAttributes() attr.st_mode = mode self._request(CMD_MKDIR, path, attr) def rmdir(self, path): """ Remove the folder named ``path``. :param str path: name of the folder to remove """ path = self._adjust_cwd(path) self._log(DEBUG, 'rmdir(%r)' % path) self._request(CMD_RMDIR, path) def stat(self, path): """ Retrieve information about a file on the remote system. The return value is an object whose attributes correspond to the attributes of Python's ``stat`` structure as returned by ``os.stat``, except that it contains fewer fields. An SFTP server may return as much or as little info as it wants, so the results may vary from server to server. Unlike a Python `python:stat` object, the result may not be accessed as a tuple. This is mostly due to the author's slack factor. The fields supported are: ``st_mode``, ``st_size``, ``st_uid``, ``st_gid``, ``st_atime``, and ``st_mtime``. :param str path: the filename to stat :return: an `.SFTPAttributes` object containing attributes about the given file """ path = self._adjust_cwd(path) self._log(DEBUG, 'stat(%r)' % path) t, msg = self._request(CMD_STAT, path) if t != CMD_ATTRS: raise SFTPError('Expected attributes') return SFTPAttributes._from_msg(msg) def lstat(self, path): """ Retrieve information about a file on the remote system, without following symbolic links (shortcuts). This otherwise behaves exactly the same as `stat`. :param str path: the filename to stat :return: an `.SFTPAttributes` object containing attributes about the given file """ path = self._adjust_cwd(path) self._log(DEBUG, 'lstat(%r)' % path) t, msg = self._request(CMD_LSTAT, path) if t != CMD_ATTRS: raise SFTPError('Expected attributes') return SFTPAttributes._from_msg(msg) def symlink(self, source, dest): """ Create a symbolic link (shortcut) of the ``source`` path at ``destination``. :param str source: path of the original file :param str dest: path of the newly created symlink """ dest = self._adjust_cwd(dest) self._log(DEBUG, 'symlink(%r, %r)' % (source, dest)) source = bytestring(source) self._request(CMD_SYMLINK, source, dest) def chmod(self, path, mode): """ Change the mode (permissions) of a file. The permissions are unix-style and identical to those used by Python's `os.chmod` function. :param str path: path of the file to change the permissions of :param int mode: new permissions """ path = self._adjust_cwd(path) self._log(DEBUG, 'chmod(%r, %r)' % (path, mode)) attr = SFTPAttributes() attr.st_mode = mode self._request(CMD_SETSTAT, path, attr) def chown(self, path, uid, gid): """ Change the owner (``uid``) and group (``gid``) of a file. As with Python's `os.chown` function, you must pass both arguments, so if you only want to change one, use `stat` first to retrieve the current owner and group. :param str path: path of the file to change the owner and group of :param int uid: new owner's uid :param int gid: new group id """ path = self._adjust_cwd(path) self._log(DEBUG, 'chown(%r, %r, %r)' % (path, uid, gid)) attr = SFTPAttributes() attr.st_uid, attr.st_gid = uid, gid self._request(CMD_SETSTAT, path, attr) def utime(self, path, times): """ Set the access and modified times of the file specified by ``path``. If ``times`` is ``None``, then the file's access and modified times are set to the current time. Otherwise, ``times`` must be a 2-tuple of numbers, of the form ``(atime, mtime)``, which is used to set the access and modified times, respectively. This bizarre API is mimicked from Python for the sake of consistency -- I apologize. :param str path: path of the file to modify :param tuple times: ``None`` or a tuple of (access time, modified time) in standard internet epoch time (seconds since 01 January 1970 GMT) """ path = self._adjust_cwd(path) if times is None: times = (time.time(), time.time()) self._log(DEBUG, 'utime(%r, %r)' % (path, times)) attr = SFTPAttributes() attr.st_atime, attr.st_mtime = times self._request(CMD_SETSTAT, path, attr) def truncate(self, path, size): """ Change the size of the file specified by ``path``. This usually extends or shrinks the size of the file, just like the `~file.truncate` method on Python file objects. :param str path: path of the file to modify :param size: the new size of the file :type size: int or long """ path = self._adjust_cwd(path) self._log(DEBUG, 'truncate(%r, %r)' % (path, size)) attr = SFTPAttributes() attr.st_size = size self._request(CMD_SETSTAT, path, attr) def readlink(self, path): """ Return the target of a symbolic link (shortcut). You can use `symlink` to create these. The result may be either an absolute or relative pathname. :param str path: path of the symbolic link file :return: target path, as a `str` """ path = self._adjust_cwd(path) self._log(DEBUG, 'readlink(%r)' % path) t, msg = self._request(CMD_READLINK, path) if t != CMD_NAME: raise SFTPError('Expected name response') count = msg.get_int() if count == 0: return None if count != 1: raise SFTPError('Readlink returned %d results' % count) return _to_unicode(msg.get_string()) def normalize(self, path): """ Return the normalized path (on the server) of a given path. This can be used to quickly resolve symbolic links or determine what the server is considering to be the "current folder" (by passing ``'.'`` as ``path``). :param str path: path to be normalized :return: normalized form of the given path (as a `str`) :raises IOError: if the path can't be resolved on the server """ path = self._adjust_cwd(path) self._log(DEBUG, 'normalize(%r)' % path) t, msg = self._request(CMD_REALPATH, path) if t != CMD_NAME: raise SFTPError('Expected name response') count = msg.get_int() if count != 1: raise SFTPError('Realpath returned %d results' % count) return msg.get_text() def chdir(self, path=None): """ Change the "current directory" of this SFTP session. Since SFTP doesn't really have the concept of a current working directory, this is emulated by Paramiko. Once you use this method to set a working directory, all operations on this `.SFTPClient` object will be relative to that path. You can pass in ``None`` to stop using a current working directory. :param str path: new current working directory :raises IOError: if the requested path doesn't exist on the server .. versionadded:: 1.4 """ if path is None: self._cwd = None return if not stat.S_ISDIR(self.stat(path).st_mode): raise SFTPError(errno.ENOTDIR, "%s: %s" % (os.strerror(errno.ENOTDIR), path)) self._cwd = b(self.normalize(path)) def getcwd(self): """ Return the "current working directory" for this SFTP session, as emulated by Paramiko. If no directory has been set with `chdir`, this method will return ``None``. .. versionadded:: 1.4 """ return self._cwd and u(self._cwd) def putfo(self, fl, remotepath, file_size=0, callback=None, confirm=True): """ Copy the contents of an open file object (``fl``) to the SFTP server as ``remotepath``. Any exception raised by operations will be passed through. The SFTP operations use pipelining for speed. :param file fl: opened file or file-like object to copy :param str remotepath: the destination path on the SFTP server :param int file_size: optional size parameter passed to callback. If none is specified, size defaults to 0 :param callable callback: optional callback function (form: ``func(int, int)``) that accepts the bytes transferred so far and the total bytes to be transferred (since 1.7.4) :param bool confirm: whether to do a stat() on the file afterwards to confirm the file size (since 1.7.7) :return: an `.SFTPAttributes` object containing attributes about the given file. .. versionadded:: 1.10 """ with self.file(remotepath, 'wb') as fr: fr.set_pipelined(True) size = 0 while True: data = fl.read(32768) fr.write(data) size += len(data) if callback is not None: callback(size, file_size) if len(data) == 0: break if confirm: s = self.stat(remotepath) if s.st_size != size: raise IOError('size mismatch in put! %d != %d' % (s.st_size, size)) else: s = SFTPAttributes() return s def put(self, localpath, remotepath, callback=None, confirm=True): """ Copy a local file (``localpath``) to the SFTP server as ``remotepath``. Any exception raised by operations will be passed through. This method is primarily provided as a convenience. The SFTP operations use pipelining for speed. :param str localpath: the local file to copy :param str remotepath: the destination path on the SFTP server. Note that the filename should be included. Only specifying a directory may result in an error. :param callable callback: optional callback function (form: ``func(int, int)``) that accepts the bytes transferred so far and the total bytes to be transferred :param bool confirm: whether to do a stat() on the file afterwards to confirm the file size :return: an `.SFTPAttributes` object containing attributes about the given file .. versionadded:: 1.4 .. versionchanged:: 1.7.4 ``callback`` and rich attribute return value added. .. versionchanged:: 1.7.7 ``confirm`` param added. """ file_size = os.stat(localpath).st_size with open(localpath, 'rb') as fl: return self.putfo(fl, remotepath, file_size, callback, confirm) def getfo(self, remotepath, fl, callback=None): """ Copy a remote file (``remotepath``) from the SFTP server and write to an open file or file-like object, ``fl``. Any exception raised by operations will be passed through. This method is primarily provided as a convenience. :param object remotepath: opened file or file-like object to copy to :param str fl: the destination path on the local host or open file object :param callable callback: optional callback function (form: ``func(int, int)``) that accepts the bytes transferred so far and the total bytes to be transferred :return: the `number <int>` of bytes written to the opened file object .. versionadded:: 1.10 """ with self.open(remotepath, 'rb') as fr: file_size = self.stat(remotepath).st_size fr.prefetch() size = 0 while True: data = fr.read(32768) fl.write(data) size += len(data) if callback is not None: callback(size, file_size) if len(data) == 0: break return size def get(self, remotepath, localpath, callback=None): """ Copy a remote file (``remotepath``) from the SFTP server to the local host as ``localpath``. Any exception raised by operations will be passed through. This method is primarily provided as a convenience. :param str remotepath: the remote file to copy :param str localpath: the destination path on the local host :param callable callback: optional callback function (form: ``func(int, int)``) that accepts the bytes transferred so far and the total bytes to be transferred .. versionadded:: 1.4 .. versionchanged:: 1.7.4 Added the ``callback`` param """ file_size = self.stat(remotepath).st_size with open(localpath, 'wb') as fl: size = self.getfo(remotepath, fl, callback) s = os.stat(localpath) if s.st_size != size: raise IOError('size mismatch in get! %d != %d' % (s.st_size, size)) ### internals... def _request(self, t, *arg): num = self._async_request(type(None), t, *arg) return self._read_response(num) def _async_request(self, fileobj, t, *arg): # this method may be called from other threads (prefetch) self._lock.acquire() try: msg = Message() msg.add_int(self.request_number) for item in arg: if isinstance(item, long): msg.add_int64(item) elif isinstance(item, int): msg.add_int(item) elif isinstance(item, (string_types, bytes_types)): msg.add_string(item) elif isinstance(item, SFTPAttributes): item._pack(msg) else: raise Exception('unknown type for %r type %r' % (item, type(item))) num = self.request_number self._expecting[num] = fileobj self._send_packet(t, msg) self.request_number += 1 finally: self._lock.release() return num def _read_response(self, waitfor=None): while True: try: t, data = self._read_packet() except EOFError as e: raise SSHException('Server connection dropped: %s' % str(e)) msg = Message(data) num = msg.get_int() if num not in self._expecting: # might be response for a file that was closed before responses came back self._log(DEBUG, 'Unexpected response #%d' % (num,)) if waitfor is None: # just doing a single check break continue fileobj = self._expecting[num] del self._expecting[num] if num == waitfor: # synchronous if t == CMD_STATUS: self._convert_status(msg) return t, msg if fileobj is not type(None): fileobj._async_response(t, msg, num) if waitfor is None: # just doing a single check break return None, None def _finish_responses(self, fileobj): while fileobj in self._expecting.values(): self._read_response() fileobj._check_exception() def _convert_status(self, msg): """ Raises EOFError or IOError on error status; otherwise does nothing. """ code = msg.get_int() text = msg.get_text() if code == SFTP_OK: return elif code == SFTP_EOF: raise EOFError(text) elif code == SFTP_NO_SUCH_FILE: # clever idea from john a. meinel: map the error codes to errno raise IOError(errno.ENOENT, text) elif code == SFTP_PERMISSION_DENIED: raise IOError(errno.EACCES, text) else: raise IOError(text) def _adjust_cwd(self, path): """ Return an adjusted path if we're emulating a "current working directory" for the server. """ path = b(path) if self._cwd is None: return path if len(path) and path[0:1] == b_slash: # absolute path return path if self._cwd == b_slash: return self._cwd + path return self._cwd + b_slash + path class SFTP(SFTPClient): """ An alias for `.SFTPClient` for backwards compatability. """ pass

mit

praekelt/txtalert

txtalert/apps/gateway/migrations/0002_auto__add_field_sendsms_group__add_field_pleasecallme_group.py

1

4637

# encoding: utf-8 import datetime from south.db import db from south.v2 import SchemaMigration from django.db import models class Migration(SchemaMigration): def forwards(self, orm): # all previous data belongs to Temba Lethu Clinic from django.contrib.auth.models import Group group, created = Group.objects.get_or_create(name="Temba Lethu") # Adding field 'SendSMS.group' db.add_column('gateway_sendsms', 'group', self.gf('django.db.models.fields.related.ForeignKey')(default=group.pk, to=orm['auth.Group']), keep_default=False) # Adding field 'PleaseCallMe.group' db.add_column('gateway_pleasecallme', 'group', self.gf('django.db.models.fields.related.ForeignKey')(default=group.pk, related_name='gateway_pleasecallme_set', to=orm['auth.Group']), keep_default=False) def backwards(self, orm): # Deleting field 'SendSMS.group' db.delete_column('gateway_sendsms', 'group_id') # Deleting field 'PleaseCallMe.group' db.delete_column('gateway_pleasecallme', 'group_id') models = { 'auth.group': { 'Meta': {'object_name': 'Group'}, 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}), 'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}) }, 'auth.permission': { 'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'}, 'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}) }, 'contenttypes.contenttype': { 'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"}, 'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}) }, 'gateway.pleasecallme': { 'Meta': {'ordering': "['created_at']", 'object_name': 'PleaseCallMe'}, 'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}), 'group': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'gateway_pleasecallme_set'", 'to': "orm['auth.Group']"}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'message': ('django.db.models.fields.TextField', [], {'blank': 'True'}), 'recipient_msisdn': ('django.db.models.fields.CharField', [], {'max_length': '255'}), 'sender_msisdn': ('django.db.models.fields.CharField', [], {'max_length': '255'}), 'sms_id': ('django.db.models.fields.CharField', [], {'max_length': '80'}) }, 'gateway.sendsms': { 'Meta': {'object_name': 'SendSMS'}, 'delivery': ('django.db.models.fields.DateTimeField', [], {}), 'delivery_timestamp': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}), 'expiry': ('django.db.models.fields.DateTimeField', [], {}), 'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.Group']"}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'identifier': ('django.db.models.fields.CharField', [], {'max_length': '8'}), 'msisdn': ('django.db.models.fields.CharField', [], {'max_length': '12'}), 'priority': ('django.db.models.fields.CharField', [], {'max_length': '80'}), 'receipt': ('django.db.models.fields.CharField', [], {'max_length': '1'}), 'smstext': ('django.db.models.fields.TextField', [], {}), 'status': ('django.db.models.fields.CharField', [], {'default': "'v'", 'max_length': '1'}) } } complete_apps = ['gateway']

gpl-3.0

lizardsystem/freq

freq/lizard_connector.py

1

30266

import copy import datetime as dt import json import logging from pprint import pprint # left here for debugging purposes from time import time from time import sleep import urllib import numpy as np import django.core.exceptions from freq import jsdatetime try: from django.conf import settings USR, PWD = settings.USR, settings.PWD except django.core.exceptions.ImproperlyConfigured: print('WARNING: no USR and PWD found in settings. USR and PWD should have' 'been set beforehand') USR = None PWD = None # When you use this script stand alone, please set your login information here: # USR = ****** # Replace the stars with your user name. # PWD = ****** # Replace the stars with your password. logger = logging.getLogger(__name__) def join_urls(*args): return '/'.join(args) class LizardApiError(Exception): pass class Base(object): """ Base class to connect to the different endpoints of the lizard-api. :param data_type: endpoint of the lizard-api one wishes to connect to. :param username: login username :param password: login password :param use_header: no login and password is send with the query when set to False :param extra_queries: In case one wishes to set default queries for a certain data type this is the plase. :param max_results: """ username = USR password = PWD max_results = 1000 @property def extra_queries(self): """ Overwrite class to add queries :return: dictionary with extra queries """ return {} def organisation_query(self, organisation, add_query_string='location__'): org_query = {} if isinstance(organisation, str): org_query.update({add_query_string + "organisation__unique_id": organisation}) elif organisation: org_query.update({ add_query_string + "organisation__unique_id": ','.join( org for org in organisation) }) if org_query: return dict([urllib.parse.urlencode(org_query).split('=')]) else: return {} def __init__(self, base="https://ggmn.lizard.net", use_header=False, data_type=None): """ :param base: the site one wishes to connect to. Defaults to the Lizard ggmn production site. """ if data_type: self.data_type = data_type self.use_header = use_header self.queries = {} self.results = [] if base.startswith('http'): self.base = base else: self.base = join_urls('https:/', base) # without extra '/' ^^, this is added in join_urls self.base_url = join_urls(self.base, 'api/v2', self.data_type) + '/' def get(self, count=True, uuid=None, **queries): """ Query the api. For possible queries see: https://nxt.staging.lizard.net/doc/api.html Stores the api-response as a dict in the results attribute. :param queries: all keyword arguments are used as queries. :return: a dictionary of the api-response. """ if self.max_results: queries.update({'page_size': self.max_results, 'format': 'json'}) queries.update(self.extra_queries) queries.update(getattr(self, "queries", {})) query = '?' + '&'.join(str(key) + '=' + (('&' + str(key) + '=').join(value) if isinstance(value, list) else str(value)) for key, value in queries.items()) url = urllib.parse.urljoin(self.base_url, str(uuid)) if uuid else \ self.base_url + query try: self.fetch(url) except urllib.error.HTTPError: # TODO remove hack to prevent 420 error self.json = {'results': [], 'count': 0} try: logger.debug('Number found %s : %s with URL: %s', self.data_type, self.json.get('count', 0), url) except (KeyError, AttributeError): logger.debug('Got results from %s with URL: %s', self.data_type, url) self.parse() return self.results def fetch(self, url): """ GETs parameters from the api based on an url in a JSON format. Stores the JSON response in the json attribute. :param url: full query url: should be of the form: [base_url]/api/v2/[endpoint]/?[query_key]=[query_value]&... :return: the JSON from the response """ if self.use_header: request_obj = urllib.request.Request(url, headers=self.header) else: request_obj = urllib.request.Request(url) try: with urllib.request.urlopen(request_obj) as resp: encoding = resp.headers.get_content_charset() encoding = encoding if encoding else 'UTF-8' content = resp.read().decode(encoding) self.json = json.loads(content) except Exception: logger.exception("got error from: %s", url) raise return self.json def parse(self): """ Parse the json attribute and store it to the results attribute. All pages of a query are parsed. If the max_results attribute is exceeded an ApiError is raised. """ while True: try: if self.json['count'] > self.max_results: raise LizardApiError( 'Too many results: {} found, while max {} are ' 'accepted'.format(self.json['count'], self.max_results) ) self.results += self.json['results'] next_url = self.json.get('next') if next_url: self.fetch(next_url) else: break except KeyError: self.results += [self.json] break except IndexError: break def parse_elements(self, element): """ Get a list of a certain element from the root of the results attribute. :param element: the element you wish to get. :return: A list of all elements in the root of the results attribute. """ self.parse() return [x[element] for x in self.results] @property def header(self): """ The header with credentials for the api. """ if self.use_header: return { "username": self.username, "password": self.password } return {} class Organisations(Base): """ Makes a connection to the organisations endpoint of the lizard api. """ data_type = 'organisations' def all(self, organisation=None): """ :return: a list of organisations belonging one has access to (with the credentials from the header attribute) """ if organisation: self.get(unique_id=organisation) else: self.get() self.parse() return self.parse_elements('unique_id') class Locations(Base): """ Makes a connection to the locations endpoint of the lizard api. """ def __init__(self, base="https://ggmn.lizard.net", use_header=False): self.data_type = 'locations' self.uuids = [] super().__init__(base, use_header) def bbox(self, south_west, north_east, organisation=None): """ Find all locations within a certain bounding box. returns records within bounding box using Bounding Box format (min Lon, min Lat, max Lon, max Lat). Also returns features with overlapping geometry. :param south_west: lattitude and longtitude of the south-western point :param north_east: lattitude and longtitude of the north-eastern point :return: a dictionary of the api-response. """ min_lat, min_lon = south_west max_lat, max_lon = north_east coords = self.commaify(min_lon, min_lat, max_lon, max_lat) org_query = self.organisation_query(organisation, '') self.get(in_bbox=coords, **org_query) def distance_to_point(self, distance, lat, lon, organisation=None): """ Returns records with distance meters from point. Distance in meters is converted to WGS84 degrees and thus an approximation. :param distance: meters from point :param lon: longtitude of point :param lat: latitude of point :return: a dictionary of the api-response. """ coords = self.commaify(lon, lat) org_query = self.organisation_query(organisation, '') self.get(distance=distance, point=coords, **org_query) def commaify(self, *args): """ :return: a comma-seperated string of the given arguments """ return ','.join(str(x) for x in args) def coord_uuid_name(self): """ Filters out the coordinates UUIDs and names of locations in results. Use after a query is made. :return: a dictionary with coordinates, UUIDs and names """ result = {} for x in self.results: if x['uuid'] not in self.uuids: geom = x.get('geometry') or {} result[x['uuid']] = { 'coordinates': geom.get( 'coordinates', ['','']), 'name': x['name'] } self.uuids.append(x['uuid']) return result class TaskAPI(Base): data_type = 'tasks' def poll(self, url=None): if url is None or not url.startswith('http'): return self.fetch(url) @property def status(self): try: logger.debug('Task status: %s', self.json.get("task_status")) status = self.json.get("task_status") if status is None: logger.debug('Task status: NONE') return "NONE" return status except AttributeError: logger.debug('Task status: NONE') return "NONE" def timeseries_csv(self, organisation, extra_queries_ts): if self.status != "SUCCESS": raise LizardApiError('Download not ready.') url = self.json.get("result_url") self.fetch(url) self.results = [] self.parse() csv = ( [result['name'], result['uuid'], jsdatetime.js_to_datestring(event['timestamp']), event['max']] for result in self.results for event in result['events'] ) loc = Locations(use_header=self.use_header) extra_queries = { key if not key.startswith("location__") else key[10:]: value for key, value in extra_queries_ts.items() } org_query = self.organisation_query(organisation, '') extra_queries.update(**org_query) loc.get(**extra_queries) coords = loc.coord_uuid_name() headers = ( [ r['uuid'], r['name'], coords[r['location']['uuid']]['name'], coords[r['location']['uuid']]['coordinates'][0], coords[r['location']['uuid']]['coordinates'][1] ] for r in self.results ) return headers, csv class TimeSeries(Base): """ Makes a connection to the timeseries endpoint of the lizard api. """ def __init__(self, base="https://ggmn.lizard.net", use_header=False): self.data_type = 'timeseries' self.uuids = [] self.statistic = None super().__init__(base, use_header) def location_name(self, name, organisation=None): """ Returns time series metadata for a location by name. :param name: name of a location :return: a dictionary of with nested location, aquo quantities and events. """ org_query = self.organisation_query(organisation) return self.get(location__name=name, **org_query) def location_uuid(self, loc_uuid, start='0001-01-01T00:00:00Z', end=None, organisation=None): """ Returns time series for a location by location-UUID. :param loc_uuid: name of a location :param start: start timestamp in ISO 8601 format :param end: end timestamp in ISO 8601 format, defaults to now :return: a dictionary of with nested location, aquo quantities and events. """ org_query = self.organisation_query(organisation) self.get(location__uuid=loc_uuid, **org_query) timeseries_uuids = [x['uuid'] for x in self.results] self.results = [] for ts_uuid in timeseries_uuids: ts = TimeSeries(self.base, use_header=self.use_header) ts.uuid(ts_uuid, start, end, organisation) self.results += ts.results return self.results def uuid(self, ts_uuid, start='0001-01-01T00:00:00Z', end=None, organisation=None): """ Returns time series for a timeseries by timeseries-UUID. :param ts_uuid: uuid of a timeseries :param start: start timestamp in ISO 8601 format :param end: end timestamp in ISO 8601 format :return: a dictionary of with nested location, aquo quantities and events. """ if not end: end = jsdatetime.now_iso() old_base_url = self.base_url self.base_url += ts_uuid + "/" org_query = self.organisation_query(organisation) self.get(start=start, end=end, **org_query) self.base_url = old_base_url def start_csv_task(self, start='0001-01-01T00:00:00Z', end=None, organisation=None): if not end: end = jsdatetime.now_iso() if isinstance(start, int): start -= 10000 if isinstance(end, int): end += 10000 org_query = self.organisation_query(organisation) poll_url = self.get( start=start, end=end, async="true", format="json", **org_query )[0]['url'] logger.debug("Async task url %s", poll_url) return poll_url, self.extra_queries def bbox(self, south_west, north_east, statistic=None, start='0001-01-01T00:00:00Z', end=None, organisation=None): """ Find all timeseries within a certain bounding box. Returns records within bounding box using Bounding Box format (min Lon, min Lat, max Lon, max Lat). Also returns features with overlapping geometry. :param south_west: lattitude and longtitude of the south-western point :param north_east: lattitude and longtitude of the north-eastern point :param start_: start timestamp in ISO 8601 format :param end: end timestamp in ISO 8601 format :return: a dictionary of the api-response. """ if not end: end = jsdatetime.now_iso() if isinstance(start, int): start -= 10000 if isinstance(end, int): end += 10000 min_lat, min_lon = south_west max_lat, max_lon = north_east polygon_coordinates = [ [min_lon, min_lat], [min_lon, max_lat], [max_lon, max_lat], [max_lon, min_lat], [min_lon, min_lat], ] points = [' '.join([str(x), str(y)]) for x, y in polygon_coordinates] geom_within = {'a': 'POLYGON ((' + ', '.join(points) + '))'} geom_within = urllib.parse.urlencode(geom_within).split('=')[1] org_query = self.organisation_query(organisation) self.statistic = statistic if statistic == 'mean': statistic = ['count', 'sum'] elif not statistic: statistic = ['min', 'max', 'count', 'sum'] self.statistic = None elif statistic == 'range (max - min)': statistic = ['min', 'max'] elif statistic == 'difference (last - first)': statistic = 'count' elif statistic == 'difference (mean last - first year)': year = dt.timedelta(days=366) first_end = jsdatetime.datetime_to_js(jsdatetime.js_to_datetime(start) + year) last_start = jsdatetime.datetime_to_js(jsdatetime.js_to_datetime(end) - year) self.get( start=start, end=first_end, min_points=1, fields=['count', 'sum'], location__geom_within=geom_within, **org_query ) first_year = {} for r in self.results: try: first_year[r['location']['uuid']] = { 'first_value_timestamp': r['first_value_timestamp'], 'mean': r['events'][0]['sum'] / r['events'][0]['count'] } except IndexError: first_year[r['location']['uuid']] = { 'first_value_timestamp': np.nan, 'mean': np.nan } self.results = [] self.get( start=last_start, end=end, min_points=1, fields=['count', 'sum'], location__geom_within=geom_within, **org_query ) for r in self.results: try: r['events'][0]['difference (mean last - first year)'] = \ r['events'][0]['sum'] / r['events'][0]['count'] - \ first_year[r['location']['uuid']]['mean'] r['first_value_timestamp'] = \ first_year[ r['location']['uuid']]['first_value_timestamp'] except IndexError: r['events'] = [{ 'difference (mean last - first year)': np.nan}] r['first_value_timestamp'] = np.nan r['last_value_timestamp'] = np.nan return self.get( start=start, end=end, min_points=1, fields=statistic, location__geom_within=geom_within, **org_query ) def ts_to_dict(self, statistic=None, values=None, start_date=None, end_date=None, date_time='js'): """ :param date_time: default: js. Several options: 'js': javascript integer datetime representation 'dt': python datetime object 'str': date in date format (dutch representation) """ if len(self.results) == 0: self.response = {} return self.response if values: values = values else: values = {} if not statistic and self.statistic: statistic = self.statistic # np array with cols: 'min', 'max', 'sum', 'count', 'first', 'last' if not statistic: stats1 = ('min', 'max', 'sum', 'count') stats2 = ( (0, 'min'), (1, 'max'), (2, 'mean'), (3, 'range (max - min)'), (4, 'difference (last - first)'), (5, 'difference (mean last - first year)') ) start_index = 6 else: if statistic == 'mean': stats1 = ('sum', 'count') elif statistic == 'range (max - min)': stats1 = ('min', 'max') else: stats1 = (statistic, ) stats2 = ((0, statistic), ) start_index = int(statistic == 'mean') + 1 ts = [] for result in self.results: try: timestamps = [int(result['first_value_timestamp']), int(result['last_value_timestamp'])] except (ValueError, TypeError): timestamps = [np.nan, np.nan] except TypeError: # int(None) timestamps = [np.nan, np.nan] if not len(result['events']): y = 2 if statistic == 'difference (mean last - first year)' \ else 0 ts.append( [np.nan for _ in range(len(stats1) + y)] + timestamps) else: ts.append([float(result['events'][0][s]) for s in stats1] + timestamps) npts = np.array(ts) if statistic: if statistic == 'mean': stat = (npts[:, 0] / npts[:, 1]).reshape(-1, 1) elif statistic == 'range (max - min)': stat = (npts[:, 1] - npts[:, 0]).reshape(-1, 1) elif statistic == 'difference (last - first)': stat = (npts[:, 1] - npts[:, 0]).reshape(-1, 1) else: stat = npts[:, 0].reshape(-1, 1) npts_calculated = np.hstack( (stat, npts[:, slice(start_index, -1)])) else: npts_calculated = np.hstack(( npts[:, 0:2], (npts[:, 2] / npts[:, 3]).reshape(-1, 1), (npts[:, 1] - npts[:, 0]).reshape(-1, 1), npts[:, 4:] )) for i, row in enumerate(npts_calculated): location_uuid = self.results[i]['location']['uuid'] loc_dict = values.get(location_uuid, {}) loc_dict.update({stat: 'NaN' if np.isnan(row[i]) else row[i] for i, stat in stats2}) loc_dict['timeseries_uuid'] = self.results[i]['uuid'] values[location_uuid] = loc_dict npts_min = np.nanmin(npts_calculated, 0) npts_max = np.nanmax(npts_calculated, 0) extremes = { stat: { 'min': npts_min[i] if not np.isnan(npts_min[i]) else 0, 'max': npts_max[i] if not np.isnan(npts_max[i]) else 0 } for i, stat in stats2 } dt_conversion = { 'js': lambda x: x, 'dt': jsdatetime.js_to_datetime, 'str': jsdatetime.js_to_datestring }[date_time] if statistic != 'difference (mean last - first year)': start = dt_conversion(max(jsdatetime.round_js_to_date(start_date), jsdatetime.round_js_to_date(npts_min[-2]))) end = dt_conversion(min(jsdatetime.round_js_to_date(end_date), jsdatetime.round_js_to_date(npts_max[-1]))) else: start = dt_conversion(jsdatetime.round_js_to_date(start_date)) end = dt_conversion(jsdatetime.round_js_to_date(end_date)) self.response = { "extremes": extremes, "dates": { "start": start, "end": end }, "values": values } return self.response class GroundwaterLocations(Locations): """ Makes a connection to the locations endpoint of the lizard api. Only selects GroundwaterStations. """ @property def extra_queries(self): return { "object_type__model": 'filter' } class GroundwaterTimeSeries(TimeSeries): """ Makes a connection to the timeseries endpoint of the lizard api. Only selects GroundwaterStations. """ @property def extra_queries(self): return { "location__object_type__model": 'filter' } class GroundwaterTimeSeriesAndLocations(object): def __init__(self): self.locs = GroundwaterLocations() self.ts = GroundwaterTimeSeries() self.values = {} def bbox(self, south_west, north_east, start='0001-01-01T00:00:00Z', end=None, groundwater_type="GWmMSL"): if not end: self.end = jsdatetime.now_iso() else: self.end = end self.start = start self.ts.queries = {"name": groundwater_type} self.locs.bbox(south_west, north_east) self.ts.bbox(south_west=south_west, north_east=north_east, start=start, end=self.end) def locs_to_dict(self, values=None): if values: self.values = values for loc in self.locs.results: self.values.get(loc['uuid'], {}).update({ 'coordinates': loc['geometry']['coordinates'], 'name': loc['name'] }) self.response = self.values def results_to_dict(self): self.locs_to_dict() self.ts.ts_to_dict(values=self.values) return self.ts.response class RasterFeatureInfo(Base): data_type = 'raster-aggregates' def wms(self, lat, lng, layername, extra_params=None): if 'igrac' in layername: self.base_url = "https://raster.lizard.net/wms" lat_f = float(lat) lng_f = float(lng) self.get( request="getfeatureinfo", layers=layername, width=1, height=1, i=0, j=0, srs="epsg:4326", bbox=','.join( [lng, lat, str(lng_f+0.00001), str(lat_f+0.00001)]), index="world" ) try: self.results = {"data": [self.results[1]]} except IndexError: self.results = {"data": ['null']} elif layername == 'aquifers': self.base_url = "https://ggis.un-igrac.org/geoserver/tbamap2015/wms" extra_params.update({ 'request': 'GetFeatureInfo', 'service': 'WMS', 'srs': 'EPSG:4326', 'info_format': 'application/json' }) self.get(**extra_params) self.results = { 'data': self.results['features'][0]['properties']['aq_name']} else: self.get( agg='curve', geom='POINT(' + lng + '+' + lat + ')', srs='EPSG:4326', raster_names=layername, count=False ) return self.results def parse(self): self.results = self.json class RasterLimits(Base): data_type = 'wms' def __init__(self, base="https://raster.lizard.net", use_header=False): super().__init__(base, use_header) self.base_url = join_urls(base, self.data_type) self.max_results = None def get_limits(self, layername, bbox): try: return self.get( request='getlimits', layers=layername, bbox=bbox, width=16, height=16, srs='epsg:4326' ) except urllib.error.HTTPError: return [[-1000, 1000]] def parse(self): self.results = self.json class Filters(Base): data_type = "filters" def from_timeseries_uuid(self, uuid): # We know the timeseries uuid. Timeseries are connected to locations # and the locations are connected to the filters that contain the # relevant information. # first get the location uuid from the timeseries. ts = Base(use_header=self.use_header, data_type='timeseries') location_data = ts.get(uuid=uuid)[0]['location'] location_uuid = location_data.get('uuid') # surface_level is stored in the extra_metadata field of a location try: surface_level = str(location_data.get("extra_metadata") .get("surface_level")) + " (m)" except AttributeError: surface_level = None # next get the location for the filter id location = Base(use_header=self.use_header, data_type='locations') try: filter_id = location.get(uuid=location_uuid)[0].get( 'object').get('id') except TypeError: # the location doesn't connect to a filter, return empty return {} if filter_id: # next get and return the filter metadata gw_filter = Base(use_header=self.use_header, data_type='filters') result = gw_filter.get(uuid=filter_id)[0] result.update({ "surface_level": surface_level }) return result return {} class Users(Base): data_type = "users" def get_organisations(self, username): self.get(username=username) if len(self.results) > 1 or len(self.results) == 0: if len(self.results): raise LizardApiError("Username is not unique") raise LizardApiError("Username not found") organisations_url = self.results[0].get("organisations_url") organisations = { org['name']: org['unique_id'] for org in self.fetch(organisations_url) } logger.debug('Found %d organisations for url: %s', len(organisations), organisations_url) if settings.DEFAULT_ORGANISATION_NAME in organisations.keys(): default_org = [( settings.DEFAULT_ORGANISATION_NAME, organisations[settings.DEFAULT_ORGANISATION_NAME]) ] del organisations[settings.DEFAULT_ORGANISATION_NAME] return default_org + sorted(organisations.items()) return sorted(organisations.items()) if __name__ == '__main__': end = "1452470400000" start = "-2208988800000" start_time = time() GWinfo = GroundwaterTimeSeriesAndLocations() GWinfo.bbox(south_west=[-65.80277639340238, -223.9453125], north_east=[ 81.46626086056541, 187.3828125], start=start, end=end) x = GWinfo.results_to_dict() print(time() - start_time) pprint(x)

gpl-3.0

mne-tools/mne-python

mne/preprocessing/realign.py

1

4237

# -*- coding: utf-8 -*- # Authors: Eric Larson <larson.eric.d@gmail.com> # License: BSD (3-clause) import numpy as np from numpy.polynomial.polynomial import Polynomial from ..io import BaseRaw from ..utils import _validate_type, warn, logger, verbose @verbose def realign_raw(raw, other, t_raw, t_other, verbose=None): """Realign two simultaneous recordings. Due to clock drift, recordings at a given same sample rate made by two separate devices simultaneously can become out of sync over time. This function uses event times captured by both acquisition devices to resample ``other`` to match ``raw``. Parameters ---------- raw : instance of Raw The first raw instance. other : instance of Raw The second raw instance. It will be resampled to match ``raw``. t_raw : array-like, shape (n_events,) The times of shared events in ``raw`` relative to ``raw.times[0]`` (0). Typically these could be events on some TTL channel like ``find_events(raw)[:, 0] - raw.first_event``. t_other : array-like, shape (n_events,) The times of shared events in ``other`` relative to ``other.times[0]``. %(verbose)s Notes ----- This function operates inplace. It will: 1. Estimate the zero-order (start offset) and first-order (clock drift) correction. 2. Crop the start of ``raw`` or ``other``, depending on which started recording first. 3. Resample ``other`` to match ``raw`` based on the clock drift. 4. Crop the end of ``raw`` or ``other``, depending on which stopped recording first (and the clock drift rate). This function is primarily designed to work on recordings made at the same sample rate, but it can also operate on recordings made at different sample rates to resample and deal with clock drift simultaneously. .. versionadded:: 0.22 """ from scipy import stats _validate_type(raw, BaseRaw, 'raw') _validate_type(other, BaseRaw, 'other') t_raw = np.array(t_raw, float) t_other = np.array(t_other, float) if t_raw.ndim != 1 or t_raw.shape != t_other.shape: raise ValueError('t_raw and t_other must be 1D with the same shape, ' f'got shapes {t_raw.shape} and {t_other.shape}') if len(t_raw) < 20: warn('Fewer than 20 times passed, results may be unreliable') # 1. Compute correction factors poly = Polynomial.fit(x=t_other, y=t_raw, deg=1) converted = poly.convert(domain=(-1, 1)) [zero_ord, first_ord] = converted.coef logger.info(f'Zero order coefficient: {zero_ord} \n' f'First order coefficient: {first_ord}') r, p = stats.pearsonr(t_other, t_raw) msg = f'Linear correlation computed as R={r:0.3f} and p={p:0.2e}' if p > 0.05 or r <= 0: raise ValueError(msg + ', cannot resample safely') if p > 1e-6: warn(msg + ', results may be unreliable') else: logger.info(msg) dr_ms_s = 1000 * abs(1 - first_ord) logger.info( f'Drift rate: {1000 * dr_ms_s:0.1f} μs/sec ' f'(total drift over {raw.times[-1]:0.1f} sec recording: ' f'{raw.times[-1] * dr_ms_s:0.1f} ms)') # 2. Crop start of recordings to match using the zero-order term msg = f'Cropping {zero_ord:0.3f} sec from the start of ' if zero_ord > 0: # need to crop start of raw to match other logger.info(msg + 'raw') raw.crop(zero_ord, None) t_raw -= zero_ord else: # need to crop start of other to match raw logger.info(msg + 'other') other.crop(-zero_ord, None) t_other += zero_ord # 3. Resample data using the first-order term logger.info('Resampling other') sfreq_new = raw.info['sfreq'] * first_ord other.load_data().resample(sfreq_new, verbose=True) other.info['sfreq'] = raw.info['sfreq'] # 4. Crop the end of one of the recordings if necessary delta = raw.times[-1] - other.times[-1] msg = f'Cropping {abs(delta):0.3f} sec from the end of ' if delta > 0: logger.info(msg + 'raw') raw.crop(0, other.times[-1]) elif delta < 0: logger.info(msg + 'other') other.crop(0, raw.times[-1])

bsd-3-clause

jamii/inkling

jottinks/src/NoteTree2.py

1

4804

""" Copyright 2008 Jamie Brandon, Mark Haines This file is part of jottinKs. JottinKs is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. JottinKs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with jottinKs. If not, see <http://www.gnu.org/licenses/>. """ import sys from Note import * import Utils from Writing import * from PyKDE4.kdecore import * from PyKDE4.kdeui import * from PyQt4 import uic from PyQt4.QtGui import * from PyQt4.QtCore import * import cPickle import pickle class NoteTree(QTreeWidget): def __init__(self, root=None): QTreeWidget.__init__(self) self.header().hide() self.setColumnCount(1) if root: self.root = root else: self.root = NoteTreeRoot() self.addTopLevelItem(self.root) self.root.setTitle() self.connect(self,SIGNAL("itemClicked (QTreeWidgetItem *,int)"),self.treeItemClicked) self.actionList = None self.selectedItem = self.root.next() def treeItemClicked(self,item,column): print "Got click", item.noteData.title self.clearSelection() self.selectedItem = item item.setSelected(True) self.scrollToItem(item) self.showNote(item.noteData) item.setTitle() def showNote(self,noteData): self.emit(SIGNAL("showNote(PyQt_PyObject)"),noteData) def click(self,item): print "Sent click", item.noteData.title self.emit(SIGNAL("itemClicked (QTreeWidgetItem *,int)"),item,0) # !!! Do I need this? def addNote(self,note): self.root.addChild(NoteTreeItem(note)) def newNote(self): item = NoteTreeItem(Writing()) self.selectedItem.parent().insertChild(self.selectedItem.index()+1,item) item.setTitle() self.click(item) print "added" , item, item.parent() def newSubNote(self): item = NoteTreeItem(Writing()) self.selectedItem.addChild(item) item.setTitle() self.click(item) def deleteNote(self): print "Will delete:", self.selectedItem print "Parent is:" , self.selectedItem.parent() deletee = self.selectedItem self.click(deletee.previousItem()) deletee.remove() def actions(self): if not self.actionList: newNote = KAction(KIcon("new"),i18n("New note"), self) self.connect(newNote,SIGNAL("triggered()"),self.newNote) newSubNote = KAction(KIcon("new"),i18n("New subnote"), self) self.connect(newSubNote,SIGNAL("triggered()"),self.newSubNote) deleteNote = KAction(KIcon("delete"),i18n("Delete note"), self) self.connect(deleteNote,SIGNAL("triggered()"),self.deleteNote) self.actionList = [newNote, newSubNote, deleteNote] return self.actionList def topLevelItems(self): i = 0 length = self.root.childCount() while i<length: yield self.root.child(i) i += 1 def __reduce__(self): (NoteTree,(self.root,)) def __reduce_ex__(self,i): return self.__reduce__() class NoteTreeItem(QTreeWidgetItem): def __init__(self, noteData=None, children = []): QTreeWidgetItem.__init__(self) self.noteData = noteData for child in children: self.addChild(child) # Cant call this until the item has been added to the tree def setTitle(self): self.treeWidget().setItemWidget(self,0,QLabel("Bugger")) for child in self.children(): child.setTitle() def children(self): children = [] for i in range(0,self.childCount()): children.append(self.child(i)) return children def index(self): return self.parent().indexOfChild(self) def previousItem(self): i = self.index() if i==0: return self.parent() else: return self.parent().child(i-1) def nextItem(self): i = self.index() if i+1 == self.parent().childCount(): return self.parent().nextItem() else: return self.parent().child(i+1) def remove(self): self.parent().removeChild(self) def __reduce__(self): return (NoteTreeItem,(self.noteData,self.children())) class NoteTreeRoot(NoteTreeItem): def __init__(self,children=[]): NoteTreeItem.__init__(self,Writing(),children) self.setText(0,"Root") def parent(self): return self # This makes the new note function work. # If we use index anywhere else it may cause some pain def index(self): return self.childCount() - 1 def previous(self): return self def next(self): if self.childCount(): return self.child(0) else: return self def remove(self): pass def __reduce__(self): return (NoteTreeRoot,(self.children(),))

gpl-3.0

brianjimenez/lightdock

lightdock/scoring/dfire2/driver.py

1

7814

"""DFIRE2 potential scoring function Yuedong Yang, Yaoqi Zhou. Ab initio folding of terminal segments with secondary structures reveals the fine difference between two closely related all-atom statistical energy functions. Protein Science,17:1212-1219(2008) """ import os import numpy as np from lightdock.structure.model import DockingModel from lightdock.scoring.functions import ModelAdapter, ScoringFunction from lightdock.structure.space import SpacePoints from lightdock.scoring.dfire2.c.cdfire2 import calculate_dfire2 from lightdock.constants import DEFAULT_CONTACT_RESTRAINTS_CUTOFF # Potential constants atom_type_number = 167 bin_number = 30 DFIRE2_ATOM_TYPES = {'GLY CA': 40, 'HIS C': 45, 'VAL O': 137, 'GLY O': 42, 'GLY N': 39, 'HIS O': 46, 'HIS N': 43, 'TRP CE3': 151, 'GLY C': 41, 'TRP CE2': 150, 'LYS NZ': 69, 'MET C': 80, 'VAL N': 134, 'PRO CA': 95, 'MET O': 81, 'MET N': 78, 'SER OG': 126, 'ARG NH2': 120, 'VAL C': 136, 'THR CG2': 133, 'ALA CB': 4, 'ALA CA': 1, 'TRP CG': 146, 'TRP CA': 142, 'TRP CB': 145, 'ALA N': 0, 'ILE CB': 57, 'ILE CA': 54, 'TRP CH2': 154, 'GLU CA': 20, 'GLU CB': 23, 'GLU CD': 25, 'GLU CG': 24, 'HIS CG': 48, 'ASP OD1': 17, 'HIS CA': 44, 'CYS N': 5, 'CYS O': 8, 'HIS CE1': 51, 'TYR CG': 160, 'TYR CA': 156, 'TYR CB': 159, 'CYS C': 7, 'ARG CB': 114, 'LYS C': 63, 'ARG CG': 115, 'ARG CD': 116, 'THR OG1': 132, 'LYS O': 64, 'LYS N': 61, 'SER C': 123, 'ILE CD1': 60, 'PRO CB': 98, 'PRO CD': 100, 'PRO CG': 99, 'ARG CZ': 118, 'SER O': 124, 'SER N': 121, 'PHE CD1': 34, 'PHE CD2': 35, 'THR CA': 128, 'HIS CD2': 50, 'THR CB': 131, 'PRO C': 96, 'PRO N': 94, 'PRO O': 97, 'PHE CA': 29, 'MET CE': 85, 'MET CG': 83, 'MET CA': 79, 'ILE C': 55, 'MET CB': 82, 'TRP CD2': 148, 'TRP CD1': 147, 'GLN CD': 107, 'ILE CG1': 58, 'ILE CG2': 59, 'PHE CE2': 37, 'PHE CE1': 36, 'GLU OE1': 26, 'GLU OE2': 27, 'ASP CG': 16, 'ASP CB': 15, 'ASP CA': 12, 'THR O': 130, 'THR N': 127, 'SER CA': 122, 'SER CB': 125, 'PHE CG': 33, 'GLU O': 22, 'GLU N': 19, 'PHE CB': 32, 'VAL CG1': 139, 'GLU C': 21, 'ILE O': 56, 'ILE N': 53, 'GLN CA': 102, 'GLN CB': 105, 'ASN C': 88, 'VAL CG2': 140, 'TRP CZ2': 152, 'TRP CZ3': 153, 'PHE CZ': 38, 'TRP O': 144, 'TRP N': 141, 'LEU CB': 74, 'GLN N': 101, 'GLN O': 104, 'LEU O': 73, 'GLN C': 103, 'TRP C': 143, 'HIS CB': 47, 'GLN NE2': 109, 'LEU CD2': 77, 'ASP OD2': 18, 'LEU CD1': 76, 'VAL CA': 135, 'ASN OD1': 92, 'ALA O': 3, 'MET SD': 84, 'ALA C': 2, 'THR C': 129, 'TYR CD1': 161, 'ARG NH1': 119, 'TYR CD2': 162, 'ASN ND2': 93, 'TRP NE1': 149, 'HIS ND1': 49, 'LEU C': 72, 'ASN O': 89, 'ASN N': 86, 'ASP C': 13, 'LEU CA': 71, 'ASP O': 14, 'ASP N': 11, 'CYS CB': 9, 'LEU N': 70, 'LEU CG': 75, 'CYS CA': 6, 'TYR OH': 166, 'ASN CA': 87, 'ASN CB': 90, 'ASN CG': 91, 'TYR CE2': 164, 'ARG C': 112, 'TYR CE1': 163, 'HIS NE2': 52, 'ARG O': 113, 'ARG N': 110, 'TYR C': 157, 'GLN CG': 106, 'ARG CA': 111, 'TYR N': 155, 'TYR O': 158, 'CYS SG': 10, 'TYR CZ': 165, 'ARG NE': 117, 'VAL CB': 138, 'LYS CB': 65, 'LYS CA': 62, 'PHE C': 30, 'LYS CG': 66, 'LYS CE': 68, 'LYS CD': 67, 'GLN OE1': 108, 'PHE N': 28, 'PHE O': 31} class DFIRE2Potential(object): """Loads DFIRE2 potentials information""" def __init__(self): data_path = os.path.dirname(os.path.realpath(__file__)) + '/data/' self.energy = np.load(data_path + 'dfire2_energies.npy').ravel() class DFIRE2Object(object): def __init__(self, residue_index, atom_index): self.residue_index = residue_index self.atom_index = atom_index class DFIRE2Adapter(ModelAdapter, DFIRE2Potential): """Adapts a given Complex to a DockingModel object suitable for this DFIRE2 scoring function. """ def _get_docking_model(self, molecule, restraints): """Builds a suitable docking model for this scoring function""" objects = [] coordinates = [] parsed_restraints = {} atom_index = 0 for residue in molecule.residues: for rec_atom in residue.atoms: rec_atom_type = rec_atom.residue_name + ' ' + rec_atom.name if rec_atom_type in DFIRE2_ATOM_TYPES: objects.append(DFIRE2Object(residue.number, DFIRE2_ATOM_TYPES[rec_atom_type])) coordinates.append([rec_atom.x, rec_atom.y, rec_atom.z]) # Restraints support res_id = "%s.%s.%s" % (rec_atom.chain_id, residue.name, str(residue.number)) if restraints and res_id in restraints: try: parsed_restraints[res_id].append(atom_index) except: parsed_restraints[res_id] = [atom_index] atom_index += 1 try: return DockingModel(objects, SpacePoints(coordinates), parsed_restraints, n_modes=molecule.n_modes.copy()) except AttributeError: return DockingModel(objects, SpacePoints(coordinates), parsed_restraints) class DFIRE2(ScoringFunction): """Implements DFIRE2 potential""" def __init__(self, weight=1.0): super(DFIRE2, self).__init__(weight) self.cached = False self.potential = DFIRE2Potential() def __call__(self, receptor, receptor_coordinates, ligand, ligand_coordinates): if not self.cached: self.res_index = [] self.atom_index = [] for o in receptor.objects: self.res_index.append(o.residue_index) self.atom_index.append(o.atom_index) last = self.res_index[-1] for o in ligand.objects: self.res_index.append(o.residue_index + last) self.atom_index.append(o.atom_index) self.res_index = np.array(self.res_index, dtype=np.int32) self.atom_index = np.array(self.atom_index, dtype=np.int32) self.molecule_length = len(self.res_index) self.cached = True return self.evaluate_energy(receptor, receptor_coordinates, ligand, ligand_coordinates) def evaluate_energy(self, receptor, receptor_coordinates, ligand, ligand_coordinates): coordinates = np.append(receptor_coordinates.coordinates, ligand_coordinates.coordinates).reshape((-1, 3)) energy, interface_receptor, interface_ligand = calculate_dfire2(self.res_index, self.atom_index, coordinates, self.potential.energy, self.molecule_length, DEFAULT_CONTACT_RESTRAINTS_CUTOFF) # Code to consider contacts in the interface perc_receptor_restraints = ScoringFunction.restraints_satisfied(receptor.restraints, set(interface_receptor)) perc_ligand_restraints = ScoringFunction.restraints_satisfied(ligand.restraints, set(interface_ligand)) return energy + perc_receptor_restraints * energy + perc_ligand_restraints * energy # Needed to dynamically load the scoring functions from command line DefinedScoringFunction = DFIRE2 DefinedModelAdapter = DFIRE2Adapter

gpl-3.0

mvaled/sentry

src/sentry/message_filters.py

1

16944

# TODO RaduW 8.06.2019 remove the sentry.filters package and rename this module to filters from __future__ import absolute_import import collections from collections import namedtuple import re from sentry.models.projectoption import ProjectOption from sentry.utils.data_filters import FilterStatKeys from rest_framework import serializers from sentry.api.fields.multiplechoice import MultipleChoiceField from six.moves.urllib.parse import urlparse from sentry.utils.safe import get_path from ua_parser.user_agent_parser import Parse from sentry.signals import inbound_filter_toggled EventFilteredRet = namedtuple("EventFilteredRet", "should_filter reason") def should_filter_event(project_config, data): """ Checks if an event should be filtered :param project_config: relay config for the request (for the project really) :param data: the event data :return: an EventFilteredRet explaining if the event should be filtered and, if it should the reason for filtering """ for event_filter in get_all_filters(): if _is_filter_enabled(project_config, event_filter) and event_filter(project_config, data): return EventFilteredRet(should_filter=True, reason=event_filter.spec.id) return EventFilteredRet(should_filter=False, reason=None) def get_all_filters(): """ Returns a list of the existing event filters An event filter is a function that receives a project_config and an event data payload and returns a tuple (should_filter:bool, filter_reason: string | None) representing :return: list of registered event filters """ return ( _localhost_filter, _browser_extensions_filter, _legacy_browsers_filter, _web_crawlers_filter, ) def set_filter_state(filter_id, project, state): flt = _filter_from_filter_id(filter_id) if flt is None: raise FilterNotRegistered(filter_id) if flt == _legacy_browsers_filter: if state is None: state = {} option_val = "0" if "active" in state: if state["active"]: option_val = "1" elif "subfilters" in state and len(state["subfilters"]) > 0: option_val = set(state["subfilters"]) ProjectOption.objects.set_value( project=project, key=u"filters:{}".format(filter_id), value=option_val ) return option_val else: # all boolean filters if state is None: state = {"active": True} ProjectOption.objects.set_value( project=project, key=u"filters:{}".format(filter_id), value="1" if state.get("active", False) else "0", ) if state: inbound_filter_toggled.send(project=project, sender=flt) return state.get("active", False) def get_filter_state(filter_id, project): """ Returns the filter state IMPORTANT: this function accesses the database, it should NEVER be used by the ingestion pipe. This api is used by the ProjectFilterDetails and ProjectFilters endpoints :param filter_id: the filter Id :param project: the project for which we want the filter state :return: True if the filter is enabled False otherwise :raises: ValueError if filter id not registered """ flt = _filter_from_filter_id(filter_id) if flt is None: raise FilterNotRegistered(filter_id) filter_state = ProjectOption.objects.get_value( project=project, key=u"filters:{}".format(flt.spec.id) ) if filter_state is None: raise ValueError( "Could not find filter state for filter {0}." " You need to register default filter state in projectoptions.defaults.".format( filter_id ) ) if flt == _legacy_browsers_filter: # special handling for legacy browser state if filter_state == "1": return True if filter_state == "0": return False return filter_state else: return filter_state == "1" class FilterNotRegistered(Exception): pass def _filter_from_filter_id(filter_id): """ Returns the corresponding filter for a filter id or None if no filter with the given id found """ for flt in get_all_filters(): if flt.spec.id == filter_id: return flt return None class _FilterSerializer(serializers.Serializer): active = serializers.BooleanField() class _FilterSpec(object): """ Data associated with a filter, it defines its name, id, default enable state and how its state is serialized in the database """ def __init__(self, id, name, description, serializer_cls=None): self.id = id self.name = name self.description = description if serializer_cls is None: self.serializer_cls = _FilterSerializer else: self.serializer_cls = serializer_cls def _get_filter_settings(project_config, flt): """ Gets the filter options from the relay config or the default option if not specified in the relay config :param project_config: the relay config for the request :param flt: the filter :return: the options for the filter """ filter_settings = project_config.config.get("filter_settings", {}) return filter_settings.get(get_filter_key(flt), None) def _is_filter_enabled(project_config, flt): filter_options = _get_filter_settings(project_config, flt) if filter_options is None: raise ValueError("unknown filter", flt.spec.id) return filter_options["is_enabled"] def get_filter_key(flt): return flt.spec.id.replace("-", "_") # ************* local host filter ************* _LOCAL_IPS = frozenset(["127.0.0.1", "::1"]) _LOCAL_DOMAINS = frozenset(["127.0.0.1", "localhost"]) def _localhost_filter(project_config, data): ip_address = get_path(data, "user", "ip_address") or "" url = get_path(data, "request", "url") or "" domain = urlparse(url).hostname return ip_address in _LOCAL_IPS or domain in _LOCAL_DOMAINS _localhost_filter.spec = _FilterSpec( id=FilterStatKeys.LOCALHOST, name="Filter out events coming from localhost", description="This applies to both IPv4 (``127.0.0.1``) and IPv6 (``::1``) addresses.", ) # ************* browser extensions filter ************* _EXTENSION_EXC_VALUES = re.compile( "|".join( ( re.escape(x) for x in ( # Random plugins/extensions "top.GLOBALS", # See: http://blog.errorception.com/2012/03/tale-of-unfindable-js-error.html "originalCreateNotification", "canvas.contentDocument", "MyApp_RemoveAllHighlights", "http://tt.epicplay.com", "Can't find variable: ZiteReader", "jigsaw is not defined", "ComboSearch is not defined", "http://loading.retry.widdit.com/", "atomicFindClose", # Facebook borked "fb_xd_fragment", # ISP "optimizing" proxy - `Cache-Control: no-transform` seems to # reduce this. (thanks @acdha) # See http://stackoverflow.com/questions/4113268 "bmi_SafeAddOnload", "EBCallBackMessageReceived", # See # https://groups.google.com/a/chromium.org/forum/#!topic/chromium-discuss/7VU0_VvC7mE "_gCrWeb", # See http://toolbar.conduit.com/Debveloper/HtmlAndGadget/Methods/JSInjection.aspx "conduitPage", # Google Search app (iOS) # See: https://github.com/getsentry/raven-js/issues/756 "null is not an object (evaluating 'elt.parentNode')", # Dragon Web Extension from Nuance Communications # See: https://forum.sentry.io/t/error-in-raven-js-plugin-setsuspendstate/481/ "plugin.setSuspendState is not a function", # lastpass "should_do_lastpass_here", # google translate # see https://medium.com/@amir.harel/a-b-target-classname-indexof-is-not-a-function-at-least-not-mine-8e52f7be64ca "a[b].target.className.indexOf is not a function", ) ) ), re.I, ) _EXTENSION_EXC_SOURCES = re.compile( "|".join( ( # Facebook flakiness r"graph\.facebook\.com", # Facebook blocked r"connect\.facebook\.net", # Woopra flakiness r"eatdifferent\.com\.woopra-ns\.com", r"static\.woopra\.com\/js\/woopra\.js", # Chrome extensions r"^chrome(?:-extension)?:\/\/", # Cacaoweb r"127\.0\.0\.1:4001\/isrunning", # Other r"webappstoolbarba\.texthelp\.com\/", r"metrics\.itunes\.apple\.com\.edgesuite\.net\/", # Kaspersky Protection browser extension r"kaspersky-labs\.com", # Google ad server (see http://whois.domaintools.com/2mdn.net) r"2mdn\.net", ) ), re.I, ) def _browser_extensions_filter(project_config, data): if data.get("platform") != "javascript": return False # get exception value try: exc_value = data["exception"]["values"][0]["value"] except (LookupError, TypeError): exc_value = "" if exc_value: if _EXTENSION_EXC_VALUES.search(exc_value): return True # get exception source try: exc_source = data["exception"]["values"][0]["stacktrace"]["frames"][-1]["abs_path"] except (LookupError, TypeError): exc_source = "" if exc_source: if _EXTENSION_EXC_SOURCES.search(exc_source): return True return False _browser_extensions_filter.spec = _FilterSpec( id=FilterStatKeys.BROWSER_EXTENSION, name="Filter out errors known to be caused by browser extensions", description="Certain browser extensions will inject inline scripts and are known to cause errors.", ) # ************* legacy browsers filter ************* MIN_VERSIONS = { "Chrome": 0, "IE": 10, "Firefox": 0, "Safari": 6, "Edge": 0, "Opera": 15, "Android": 4, "Opera Mini": 8, } def _legacy_browsers_filter(project_config, data): def get_user_agent(data): try: for key, value in get_path(data, "request", "headers", filter=True) or (): if key.lower() == "user-agent": return value except LookupError: return "" if data.get("platform") != "javascript": return False value = get_user_agent(data) if not value: return False ua = Parse(value) if not ua: return False browser = ua["user_agent"] if not browser["family"]: return False # IE Desktop and IE Mobile use the same engines, therefore we can treat them as one if browser["family"] == "IE Mobile": browser["family"] = "IE" filter_settings = _get_filter_settings(project_config, _legacy_browsers_filter) # handle old style config if filter_settings is None: return _filter_default(browser) enabled_sub_filters = filter_settings.get("options") if isinstance(enabled_sub_filters, collections.Sequence): for sub_filter_name in enabled_sub_filters: sub_filter = _legacy_browsers_sub_filters.get(sub_filter_name) if sub_filter is not None and sub_filter(browser): return True return False class _LegacyBrowserFilterSerializer(serializers.Serializer): active = serializers.BooleanField() subfilters = MultipleChoiceField( choices=[ "ie_pre_9", "ie9", "ie10", "opera_pre_15", "android_pre_4", "safari_pre_6", "opera_mini_pre_8", ] ) _legacy_browsers_filter.spec = _FilterSpec( id=FilterStatKeys.LEGACY_BROWSER, name="Filter out known errors from legacy browsers", description="Older browsers often give less accurate information, and while they may report valid issues, " "the context to understand them is incorrect or missing.", serializer_cls=_LegacyBrowserFilterSerializer, ) def _filter_default(browser): """ Legacy filter - new users specify individual filters """ try: minimum_version = MIN_VERSIONS[browser["family"]] except KeyError: return False try: major_browser_version = int(browser["major"]) except (TypeError, ValueError): return False if minimum_version > major_browser_version: return True return False def _filter_opera_pre_15(browser): if not browser["family"] == "Opera": return False try: major_browser_version = int(browser["major"]) except (TypeError, ValueError): return False if major_browser_version < 15: return True return False def _filter_safari_pre_6(browser): if not browser["family"] == "Safari": return False try: major_browser_version = int(browser["major"]) except (TypeError, ValueError): return False if major_browser_version < 6: return True return False def _filter_android_pre_4(browser): if not browser["family"] == "Android": return False try: major_browser_version = int(browser["major"]) except (TypeError, ValueError): return False if major_browser_version < 4: return True return False def _filter_opera_mini_pre_8(browser): if not browser["family"] == "Opera Mini": return False try: major_browser_version = int(browser["major"]) except (TypeError, ValueError): return False if major_browser_version < 8: return True return False def _filter_ie10(browser): return _filter_ie_internal(browser, lambda major_ver: major_ver == 10) def _filter_ie9(browser): return _filter_ie_internal(browser, lambda major_ver: major_ver == 9) def _filter_ie_pre_9(browser): return _filter_ie_internal(browser, lambda major_ver: major_ver <= 8) def _filter_ie_internal(browser, compare_version): if not browser["family"] == "IE": return False try: major_browser_version = int(browser["major"]) except (TypeError, ValueError): return False return compare_version(major_browser_version) # list all browser specific sub filters that should be called _legacy_browsers_sub_filters = { "default": _filter_default, "opera_pre_15": _filter_opera_pre_15, "safari_pre_6": _filter_safari_pre_6, "android_pre_4": _filter_android_pre_4, "opera_mini_pre_8": _filter_opera_mini_pre_8, "ie9": _filter_ie9, "ie10": _filter_ie10, "ie_pre_9": _filter_ie_pre_9, } # ************* web crawler filter ************* # not all of these agents are guaranteed to execute JavaScript, but to avoid # overhead of identifying which ones do, and which ones will over time we simply # target all of the major ones _CRAWLERS = re.compile( r"|".join( ( # Google spiders (Adsense and others) # https://support.google.com/webmasters/answer/1061943?hl=en r"Mediapartners\-Google", r"AdsBot\-Google", r"Googlebot", r"FeedFetcher\-Google", # Bing search r"BingBot", r"BingPreview", # Baidu search r"Baiduspider", # Yahoo r"Slurp", # Sogou r"Sogou", # facebook r"facebook", # Alexa r"ia_archiver", # Generic bot r"bots?[\/\s\)\;]", # Generic spider r"spider[\/\s\)\;]", # Slack - see https://api.slack.com/robots r"Slack", # Google indexing bot r"Calypso AppCrawler", # Pingdom r"pingdom", # Lytics r"lyticsbot", ) ), re.I, ) def _web_crawlers_filter(project_config, data): try: for key, value in get_path(data, "request", "headers", filter=True) or (): if key.lower() == "user-agent": if not value: return False return bool(_CRAWLERS.search(value)) return False except LookupError: return False _web_crawlers_filter.spec = _FilterSpec( id=FilterStatKeys.WEB_CRAWLER, name="Filter out known web crawlers", description="Some crawlers may execute pages in incompatible ways which then cause errors that" " are unlikely to be seen by a normal user.", )

bsd-3-clause

eResearchSA/reporting-storage-hcp

ersa_storage_hcp/__init__.py

1

5549

#!/usr/bin/python3 """Application and persistence management.""" # pylint: disable=no-member, import-error, no-init, too-few-public-methods # pylint: disable=cyclic-import, no-name-in-module, invalid-name import os from flask import Flask from flask.ext import restful from flask.ext.cors import CORS from flask.ext.sqlalchemy import SQLAlchemy from sqlalchemy.sql import text from sqlalchemy.dialects.postgresql import UUID app = Flask("storage-hcp") cors = CORS(app) restapi = restful.Api(app) app.config["ERSA_STORAGE_HCP_TOKEN"] = os.getenv("ERSA_STORAGE_HCP_TOKEN") app.config["SQLALCHEMY_DATABASE_URI"] = os.getenv("ERSA_STORAGE_HCP_DATABASE") db = SQLAlchemy(app) def _id_column(): """Generate a UUID column.""" return db.Column(UUID, server_default=text("uuid_generate_v4()"), primary_key=True) class Allocation(db.Model): """Storage Allocation""" id = _id_column() allocation = db.Column(db.Integer, unique=True, nullable=False) tenants = db.relationship("Tenant", backref="allocation") namespaces = db.relationship("Namespace", backref="allocation") def json(self): """Jsonify""" return {"id": self.id, "allocation": self.allocation} class Snapshot(db.Model): """Storage Snapshot""" id = _id_column() ts = db.Column(db.Integer, nullable=False) usage = db.relationship("Usage", backref="snapshot") def json(self): """Jsonify""" return {"id": self.id, "ts": self.ts} class Tenant(db.Model): """HCP Tenant""" id = _id_column() name = db.Column(db.String(256), unique=True, nullable=False) namespaces = db.relationship("Namespace", backref="tenant") allocation_id = db.Column(None, db.ForeignKey("allocation.id")) def json(self, namespaces=True): """Jsonify""" result = {"id": self.id, "name": self.name} if self.allocation: result["allocation"] = self.allocation.json() if namespaces: result["namespaces"] = [namespace.json(tenants=False) for namespace in self.namespaces] return result class Namespace(db.Model): """HCP Namespace""" id = _id_column() name = db.Column(db.String(256), nullable=False) usage = db.relationship("Usage", backref="namespace") tenant_id = db.Column(None, db.ForeignKey("tenant.id"), index=True, nullable=False) allocation_id = db.Column(None, db.ForeignKey("allocation.id")) def json(self, tenants=True): """Jsonify""" result = {"id": self.id, "name": self.name} if self.allocation: result["allocation"] = self.allocation.json() if tenants: result["tenant"] = self.tenant.json(namespaces=False) return result class Usage(db.Model): """HCP Usage""" id = _id_column() start_time = db.Column(db.Integer, index=True, nullable=False) end_time = db.Column(db.Integer, index=True, nullable=False) ingested_bytes = db.Column(db.BigInteger, nullable=False) raw_bytes = db.Column(db.BigInteger, nullable=False) reads = db.Column(db.BigInteger, nullable=False) writes = db.Column(db.BigInteger, nullable=False) deletes = db.Column(db.BigInteger, nullable=False) objects = db.Column(db.BigInteger, nullable=False) bytes_in = db.Column(db.BigInteger, nullable=False) bytes_out = db.Column(db.BigInteger, nullable=False) metadata_only_objects = db.Column(db.BigInteger, nullable=False) metadata_only_bytes = db.Column(db.BigInteger, nullable=False) tiered_objects = db.Column(db.BigInteger, nullable=False) tiered_bytes = db.Column(db.BigInteger, nullable=False) snapshot_id = db.Column(None, db.ForeignKey("snapshot.id"), index=True, nullable=False) namespace_id = db.Column(None, db.ForeignKey("namespace.id"), index=True, nullable=False) def json(self): """Jsonify""" return { "start_time": self.start_time, "end_time": self.end_time, "ingested_bytes": self.ingested_bytes, "raw_bytes": self.raw_bytes, "reads": self.reads, "writes": self.writes, "deletes": self.deletes, "objects": self.objects, "bytes_in": self.bytes_in, "bytes_out": self.bytes_out, "metadata_only_objects": self.metadata_only_objects, "metadata_only_bytes": self.metadata_only_bytes, "tiered_objects": self.tiered_objects, "tiered_bytes": self.tiered_bytes, "snapshot": self.snapshot.json(), "namespace": { "id": self.namespace.id, "name": self.namespace.name } } def run(): """Let's roll.""" db.engine.execute("create extension if not exists \"uuid-ossp\";") db.create_all() from ersa_storage_hcp import api restapi.add_resource(api.PingResource, "/ping") restapi.add_resource(api.AllocationResource, "/allocation") restapi.add_resource(api.StorageResource, "/storage") restapi.add_resource(api.SnapshotResource, "/snapshot") restapi.add_resource(api.UsageResource, "/usage") app.run(host="127.0.0.1", port=int(os.getenv("ERSA_STORAGE_HCP_PORT")))

apache-2.0

varunarya10/oslo.serialization

oslo_serialization/jsonutils.py

1

8936

# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # Copyright 2011 Justin Santa Barbara # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. ''' JSON related utilities. This module provides a few things: #. A handy function for getting an object down to something that can be JSON serialized. See :func:`.to_primitive`. #. Wrappers around :func:`.loads` and :func:`.dumps`. The :func:`.dumps` wrapper will automatically use :func:`.to_primitive` for you if needed. #. This sets up ``anyjson`` to use the :func:`.loads` and :func:`.dumps` wrappers if ``anyjson`` is available. ''' import codecs import datetime import functools import inspect import itertools import sys import uuid is_simplejson = False if sys.version_info < (2, 7): # On Python <= 2.6, json module is not C boosted, so try to use # simplejson module if available try: import simplejson as json # NOTE(mriedem): Make sure we have a new enough version of simplejson # to support the namedobject_as_tuple argument. This can be removed # in the Kilo release when python 2.6 support is dropped. if 'namedtuple_as_object' in inspect.getargspec(json.dumps).args: is_simplejson = True else: import json except ImportError: import json else: import json from oslo_utils import encodeutils from oslo_utils import importutils from oslo_utils import timeutils import six import six.moves.xmlrpc_client as xmlrpclib netaddr = importutils.try_import("netaddr") _nasty_type_tests = [inspect.ismodule, inspect.isclass, inspect.ismethod, inspect.isfunction, inspect.isgeneratorfunction, inspect.isgenerator, inspect.istraceback, inspect.isframe, inspect.iscode, inspect.isbuiltin, inspect.isroutine, inspect.isabstract] _simple_types = (six.string_types + six.integer_types + (type(None), bool, float)) def to_primitive(value, convert_instances=False, convert_datetime=True, level=0, max_depth=3): """Convert a complex object into primitives. Handy for JSON serialization. We can optionally handle instances, but since this is a recursive function, we could have cyclical data structures. To handle cyclical data structures we could track the actual objects visited in a set, but not all objects are hashable. Instead we just track the depth of the object inspections and don't go too deep. Therefore, ``convert_instances=True`` is lossy ... be aware. """ # handle obvious types first - order of basic types determined by running # full tests on nova project, resulting in the following counts: # 572754 <type 'NoneType'> # 460353 <type 'int'> # 379632 <type 'unicode'> # 274610 <type 'str'> # 199918 <type 'dict'> # 114200 <type 'datetime.datetime'> # 51817 <type 'bool'> # 26164 <type 'list'> # 6491 <type 'float'> # 283 <type 'tuple'> # 19 <type 'long'> if isinstance(value, _simple_types): return value if isinstance(value, datetime.datetime): if convert_datetime: return timeutils.strtime(value) else: return value if isinstance(value, uuid.UUID): return six.text_type(value) # value of itertools.count doesn't get caught by nasty_type_tests # and results in infinite loop when list(value) is called. if type(value) == itertools.count: return six.text_type(value) # FIXME(vish): Workaround for LP bug 852095. Without this workaround, # tests that raise an exception in a mocked method that # has a @wrap_exception with a notifier will fail. If # we up the dependency to 0.5.4 (when it is released) we # can remove this workaround. if getattr(value, '__module__', None) == 'mox': return 'mock' if level > max_depth: return '?' # The try block may not be necessary after the class check above, # but just in case ... try: recursive = functools.partial(to_primitive, convert_instances=convert_instances, convert_datetime=convert_datetime, level=level, max_depth=max_depth) if isinstance(value, dict): return dict((k, recursive(v)) for k, v in six.iteritems(value)) # It's not clear why xmlrpclib created their own DateTime type, but # for our purposes, make it a datetime type which is explicitly # handled if isinstance(value, xmlrpclib.DateTime): value = datetime.datetime(*tuple(value.timetuple())[:6]) if convert_datetime and isinstance(value, datetime.datetime): return timeutils.strtime(value) elif hasattr(value, 'iteritems'): return recursive(dict(value.iteritems()), level=level + 1) elif hasattr(value, '__iter__'): return list(map(recursive, value)) elif convert_instances and hasattr(value, '__dict__'): # Likely an instance of something. Watch for cycles. # Ignore class member vars. return recursive(value.__dict__, level=level + 1) elif netaddr and isinstance(value, netaddr.IPAddress): return six.text_type(value) elif any(test(value) for test in _nasty_type_tests): return six.text_type(value) return value except TypeError: # Class objects are tricky since they may define something like # __iter__ defined but it isn't callable as list(). return six.text_type(value) JSONEncoder = json.JSONEncoder JSONDecoder = json.JSONDecoder def dumps(obj, default=to_primitive, **kwargs): """Serialize ``obj`` to a JSON formatted ``str``. :param obj: object to be serialized :param default: function that returns a serializable version of an object :param kwargs: extra named parameters, please see documentation \ of `json.dumps <https://docs.python.org/2/library/json.html#basic-usage>`_ :returns: json formatted string """ if is_simplejson: kwargs['namedtuple_as_object'] = False return json.dumps(obj, default=default, **kwargs) def dump(obj, fp, *args, **kwargs): """Serialize ``obj`` as a JSON formatted stream to ``fp`` :param obj: object to be serialized :param fp: a ``.write()``-supporting file-like object :param default: function that returns a serializable version of an object :param args: extra arguments, please see documentation \ of `json.dump <https://docs.python.org/2/library/json.html#basic-usage>`_ :param kwargs: extra named parameters, please see documentation \ of `json.dump <https://docs.python.org/2/library/json.html#basic-usage>`_ """ default = kwargs.get('default', to_primitive) if is_simplejson: kwargs['namedtuple_as_object'] = False return json.dump(obj, fp, default=default, *args, **kwargs) def loads(s, encoding='utf-8', **kwargs): """Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON :param s: string to deserialize :param encoding: encoding used to interpret the string :param kwargs: extra named parameters, please see documentation \ of `json.loads <https://docs.python.org/2/library/json.html#basic-usage>`_ :returns: python object """ return json.loads(encodeutils.safe_decode(s, encoding), **kwargs) def load(fp, encoding='utf-8', **kwargs): """Deserialize ``fp`` to a Python object. :param fp: a ``.read()`` -supporting file-like object :param encoding: encoding used to interpret the string :param kwargs: extra named parameters, please see documentation \ of `json.loads <https://docs.python.org/2/library/json.html#basic-usage>`_ :returns: python object """ return json.load(codecs.getreader(encoding)(fp), **kwargs) try: import anyjson except ImportError: pass else: anyjson._modules.append((__name__, 'dumps', TypeError, 'loads', ValueError, 'load')) anyjson.force_implementation(__name__)

apache-2.0

ryanjoneil/docker-image-construction

ipynb/examples/example1.py

1

3732

from mosek.fusion import Model, Domain, Expr, ObjectiveSense import sys # Example 1. Full representation of 3-image problem with all maximal cliques. # DICP instance: # # Resource consumption by command: # # C = {A, B, C, D} # # | x = A: 5 | # r(c) = | x = B: 10 | # | x = C: 7 | # | x = D: 12 | # # Images to create: # # I = {1, 2, 3} # # | i = 1: {A, B} | # C(i) = | i = 2: {A, B, C, D} | # | i = 3: {B, C, D} | r = {'A': 5.0, 'B': 10.0, 'C': 7.0, 'D': 12.0} m = Model() binary = (Domain.inRange(0.0, 1.0), Domain.isInteger()) # Provide a variable for each image and command. This is 1 if the command # is not run as part of a clique for the image. x_1_a = m.variable('x_1_a', *binary) x_1_b = m.variable('x_1_b', *binary) x_2_a = m.variable('x_2_a', *binary) x_2_b = m.variable('x_2_b', *binary) x_2_c = m.variable('x_2_c', *binary) x_2_d = m.variable('x_2_d', *binary) x_3_b = m.variable('x_3_b', *binary) x_3_c = m.variable('x_3_c', *binary) x_3_d = m.variable('x_3_d', *binary) # Provide a variable for each maximal clique and maximal sub-clique. x_12_ab = m.variable('x_12_ab', *binary) x_123_b = m.variable('x_123_b', *binary) x_123_b_12_a = m.variable('x_123_b_12_a', *binary) x_123_b_23_cd = m.variable('x_123_b_23_cd', *binary) # Each command must be run once for each image. m.constraint('c_1_a', Expr.add([x_1_a, x_12_ab, x_123_b_12_a]), Domain.equalsTo(1.0)) m.constraint('c_1_b', Expr.add([x_1_b, x_12_ab, x_123_b]), Domain.equalsTo(1.0)) m.constraint('c_2_a', Expr.add([x_2_a, x_12_ab, x_123_b_12_a]), Domain.equalsTo(1.0)) m.constraint('c_2_b', Expr.add([x_2_b, x_12_ab, x_123_b]), Domain.equalsTo(1.0)) m.constraint('c_2_c', Expr.add([x_2_c, x_123_b_23_cd]), Domain.equalsTo(1.0)) m.constraint('c_2_d', Expr.add([x_2_d, x_123_b_23_cd]), Domain.equalsTo(1.0)) m.constraint('c_3_b', Expr.add([x_3_b, x_123_b]), Domain.equalsTo(1.0)) m.constraint('c_3_c', Expr.add([x_3_c, x_123_b_23_cd]), Domain.equalsTo(1.0)) m.constraint('c_3_d', Expr.add([x_3_d, x_123_b_23_cd]), Domain.equalsTo(1.0)) # Add dependency constraints for sub-cliques. m.constraint('d_123_b_12_a', Expr.sub(x_123_b, x_123_b_12_a), Domain.greaterThan(0.0)) m.constraint('d_123_b_23_cd', Expr.sub(x_123_b, x_123_b_23_cd), Domain.greaterThan(0.0)) # Eliminated intersections between cliques. m.constraint('e1', Expr.add([x_12_ab, x_123_b]), Domain.lessThan(1.0)) m.constraint('e2', Expr.add([x_123_b_12_a, x_123_b_23_cd]), Domain.lessThan(1.0)) # Minimize resources required to construct all images. obj = [Expr.mul(c, x) for c, x in [ # Individual image/command pairs (r['A'], x_1_a), (r['B'], x_1_b), (r['A'], x_2_a), (r['B'], x_2_b), (r['C'], x_2_c), (r['D'], x_2_d), (r['B'], x_3_b), (r['C'], x_3_c), (r['D'], x_3_d), # Cliques (r['A'] + r['B'], x_12_ab), (r['B'], x_123_b), (r['A'], x_123_b_12_a), (r['C'] + r['D'], x_123_b_23_cd), ]] m.objective('w', ObjectiveSense.Minimize, Expr.add(obj)) m.setLogHandler(sys.stdout) m.solve() print print 'Image 1:' print '\tx_1_a = %.0f' % x_1_a.level()[0] print '\tx_1_b = %.0f' % x_1_b.level()[0] print print 'Image 2:' print '\tx_2_a = %.0f' % x_2_a.level()[0] print '\tx_2_b = %.0f' % x_2_b.level()[0] print '\tx_2_c = %.0f' % x_2_c.level()[0] print '\tx_2_d = %.0f' % x_2_d.level()[0] print print 'Image 3:' print '\tx_3_b = %.0f' % x_3_b.level()[0] print '\tx_3_c = %.0f' % x_3_c.level()[0] print '\tx_3_d = %.0f' % x_3_d.level()[0] print print 'Cliques:' print '\tx_12_ab = %.0f' % x_12_ab.level()[0] print '\tx_123_b = %.0f' % x_123_b.level()[0] print '\tx_123_b_12_a = %.0f' % x_123_b_12_a.level()[0] print '\tx_123_b_23_cd = %.0f' % x_123_b_23_cd.level()[0] print

mit

clld/tsammalex

tsammalex/util.py

1

4317

from collections import OrderedDict from purl import URL from sqlalchemy.orm import joinedload, contains_eager from clld.web.util.multiselect import MultiSelect from clld.db.meta import DBSession from clld.db.models.common import Language, Unit, Value, ValueSet from clld.web.util.htmllib import HTML from clld.web.util.helpers import maybe_external_link, collapsed from tsammalex.models import split_ids assert split_ids def license_name(license_url): if license_url == "http://commons.wikimedia.org/wiki/GNU_Free_Documentation_License": return 'GNU Free Documentation License' if license_url == 'http://en.wikipedia.org/wiki/Public_domain': license_url = 'http://creativecommons.org/publicdomain/zero/1.0/' license_url_ = URL(license_url) if license_url_.host() != 'creativecommons.org': return license_url comps = license_url_.path().split('/') if len(comps) < 3: return license_url return { 'zero': 'Public Domain', }.get(comps[2], '(CC) %s' % comps[2].upper()) def names_in_2nd_languages(vs): def format_name(n): res = [HTML.i(n.name)] if n.ipa: res.append('&nbsp;[%s]' % n.ipa) return HTML.span(*res) def format_language(vs): return ' '.join([vs.language.name, ', '.join(format_name(n) for n in vs.values)]) query = DBSession.query(ValueSet).join(ValueSet.language)\ .order_by(Language.name)\ .filter(Language.pk.in_([l.pk for l in vs.language.second_languages]))\ .filter(ValueSet.parameter_pk == vs.parameter_pk)\ .options(contains_eager(ValueSet.language), joinedload(ValueSet.values)) res = '; '.join(format_language(vs) for vs in query) if res: res = '(%s)' % res return res def source_link(source): label = source host = URL(source).host() if host == 'commons.wikimedia.org': label = 'wikimedia' elif host == 'en.wikipedia.org': label = 'wikipedia' return maybe_external_link(source, label=label) def with_attr(f): def wrapper(ctx, name, *args, **kw): kw['attr'] = getattr(ctx, name) if not kw['attr']: return '' # pragma: no cover return f(ctx, name, *args, **kw) return wrapper @with_attr def tr_rel(ctx, name, label=None, dt='name', dd='description', attr=None): content = [] for item in attr: content.extend([HTML.dt(getattr(item, dt)), HTML.dd(getattr(item, dd))]) content = HTML.dl(*content, class_='dl-horizontal') if len(attr) > 3: content = collapsed('collapsed-' + name, content) return HTML.tr(HTML.td((label or name.capitalize()) + ':'), HTML.td(content)) @with_attr def tr_attr(ctx, name, label=None, content=None, attr=None): return HTML.tr( HTML.td((label or name.capitalize()) + ':'), HTML.td(content or maybe_external_link(attr))) def format_classification(taxon, with_species=False, with_rank=False): names = OrderedDict() for r in 'kingdom phylum class_ order family'.split(): names[r.replace('_', '')] = getattr(taxon, r) if with_species: names[taxon.rank] = taxon.name return HTML.ul( *[HTML.li(('{0} {1}: {2}' if with_rank else '{0}{2}').format('-' * i, *n)) for i, n in enumerate(n for n in names.items() if n[1])], class_="unstyled") class LanguageMultiSelect(MultiSelect): def __init__(self, ctx, req, name='languages', eid='ms-languages', **kw): kw['selected'] = ctx.languages MultiSelect.__init__(self, req, name, eid, **kw) @classmethod def query(cls): return DBSession.query(Language).order_by(Language.name) def get_options(self): return { 'data': [self.format_result(p) for p in self.query()], 'multiple': True, 'maximumSelectionSize': 2} def parameter_index_html(context=None, request=None, **kw): return dict(select=LanguageMultiSelect(context, request)) def language_detail_html(context=None, request=None, **kw): return dict(categories=list(DBSession.query(Unit) .filter(Unit.language == context).order_by(Unit.name))) def language_index_html(context=None, request=None, **kw): return dict(map_=request.get_map('languages', col='lineage', dt=context))

apache-2.0

tsengj10/physics-admit

admissions/management/commands/jelley.py

1

1202

from django.core.management.base import BaseCommand, CommandError from admissions.models import * class Command(BaseCommand): help = 'Recalculate Jelley scores and ranks' def add_arguments(self, parser): parser.add_argument('tag', nargs='?', default='test') def handle(self, *args, **options): weights = Weights.objects.last() all_students = Candidate.objects.all() for s in all_students: s.stored_jell_score = s.calc_jell_score(weights) s.save() self.stdout.write('Jelley score of {0} is {1}'.format(s.ucas_id, s.stored_jell_score)) ordered = Candidate.objects.order_by('-stored_jell_score').all() first = True index = 1 for s in ordered: if first: s.stored_rank = index previous_score = s.stored_jell_score previous_rank = index first = False else: if s.stored_jell_score == previous_score: s.stored_rank = previous_rank else: s.stored_rank = index previous_score = s.stored_jell_score previous_rank = index s.save() self.stdout.write('Rank of {0} is {1} ({2})'.format(s.ucas_id, s.stored_rank, index)) index = index + 1

gpl-2.0

xiawei0000/Kinectforactiondetect

ChalearnLAPSample.py

1

41779

# coding=gbk #------------------------------------------------------------------------------- # Name: Chalearn LAP sample # Purpose: Provide easy access to Chalearn LAP challenge data samples # # Author: Xavier Baro # # Created: 21/01/2014 # Copyright: (c) Xavier Baro 2014 # Licence: <your licence> #------------------------------------------------------------------------------- import os import zipfile import shutil import cv2 import numpy import csv from PIL import Image, ImageDraw from scipy.misc import imresize class Skeleton(object): """ Class that represents the skeleton information """ """¹Ç¼ÜÀ࣬ÊäÈë¹Ç¼ÜÊý¾Ý£¬½¨Á¢Àà""" #define a class to encode skeleton data def __init__(self,data): """ Constructor. Reads skeleton information from given raw data """ # Create an object from raw data self.joins=dict(); pos=0 self.joins['HipCenter']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['Spine']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['ShoulderCenter']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['Head']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['ShoulderLeft']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['ElbowLeft']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['WristLeft']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['HandLeft']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['ShoulderRight']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['ElbowRight']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['WristRight']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['HandRight']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['HipLeft']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['KneeLeft']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['AnkleLeft']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['FootLeft']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['HipRight']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['KneeRight']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['AnkleRight']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) pos=pos+9 self.joins['FootRight']=(map(float,data[pos:pos+3]),map(float,data[pos+3:pos+7]),map(int,data[pos+7:pos+9])) def getAllData(self): """ Return a dictionary with all the information for each skeleton node """ return self.joins def getWorldCoordinates(self): """ Get World coordinates for each skeleton node """ skel=dict() for key in self.joins.keys(): skel[key]=self.joins[key][0] return skel def getJoinOrientations(self): """ Get orientations of all skeleton nodes """ skel=dict() for key in self.joins.keys(): skel[key]=self.joins[key][1] return skel def getPixelCoordinates(self): """ Get Pixel coordinates for each skeleton node """ skel=dict() for key in self.joins.keys(): skel[key]=self.joins[key][2] return skel def toImage(self,width,height,bgColor): """ Create an image for the skeleton information """ SkeletonConnectionMap = (['HipCenter','Spine'],['Spine','ShoulderCenter'],['ShoulderCenter','Head'],['ShoulderCenter','ShoulderLeft'], \ ['ShoulderLeft','ElbowLeft'],['ElbowLeft','WristLeft'],['WristLeft','HandLeft'],['ShoulderCenter','ShoulderRight'], \ ['ShoulderRight','ElbowRight'],['ElbowRight','WristRight'],['WristRight','HandRight'],['HipCenter','HipRight'], \ ['HipRight','KneeRight'],['KneeRight','AnkleRight'],['AnkleRight','FootRight'],['HipCenter','HipLeft'], \ ['HipLeft','KneeLeft'],['KneeLeft','AnkleLeft'],['AnkleLeft','FootLeft']) im = Image.new('RGB', (width, height), bgColor) draw = ImageDraw.Draw(im) for link in SkeletonConnectionMap: p=self.getPixelCoordinates()[link[1]] p.extend(self.getPixelCoordinates()[link[0]]) draw.line(p, fill=(255,0,0), width=5) for node in self.getPixelCoordinates().keys(): p=self.getPixelCoordinates()[node] r=5 draw.ellipse((p[0]-r,p[1]-r,p[0]+r,p[1]+r),fill=(0,0,255)) del draw image = numpy.array(im) image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) return image ##ÊÖÊÆÊý¾ÝµÄÀ࣬ÊäÈë·¾¶£¬½¨Á¢ÊÖÊÆÊý¾ÝÀà class GestureSample(object): """ Class that allows to access all the information for a certain gesture database sample """ #define class to access gesture data samples #³õʼ»¯£¬¶ÁÈ¡Îļþ def __init__ (self,fileName): """ Constructor. Read the sample file and unzip it if it is necessary. All the data is loaded. sample=GestureSample('Sample0001.zip') """ # Check the given file if not os.path.exists(fileName): #or not os.path.isfile(fileName): raise Exception("Sample path does not exist: " + fileName) # Prepare sample information self.fullFile = fileName self.dataPath = os.path.split(fileName)[0] self.file=os.path.split(fileName)[1] self.seqID=os.path.splitext(self.file)[0] self.samplePath=self.dataPath + os.path.sep + self.seqID; #ÅжÏÊÇzip»¹ÊÇĿ¼ # Unzip sample if it is necessary if os.path.isdir(self.samplePath) : self.unzip = False else: self.unzip = True zipFile=zipfile.ZipFile(self.fullFile,"r") zipFile.extractall(self.samplePath) # Open video access for RGB information rgbVideoPath=self.samplePath + os.path.sep + self.seqID + '_color.mp4' if not os.path.exists(rgbVideoPath): raise Exception("Invalid sample file. RGB data is not available") self.rgb = cv2.VideoCapture(rgbVideoPath) while not self.rgb.isOpened(): self.rgb = cv2.VideoCapture(rgbVideoPath) cv2.waitKey(500) # Open video access for Depth information depthVideoPath=self.samplePath + os.path.sep + self.seqID + '_depth.mp4' if not os.path.exists(depthVideoPath): raise Exception("Invalid sample file. Depth data is not available") self.depth = cv2.VideoCapture(depthVideoPath) while not self.depth.isOpened(): self.depth = cv2.VideoCapture(depthVideoPath) cv2.waitKey(500) # Open video access for User segmentation information userVideoPath=self.samplePath + os.path.sep + self.seqID + '_user.mp4' if not os.path.exists(userVideoPath): raise Exception("Invalid sample file. User segmentation data is not available") self.user = cv2.VideoCapture(userVideoPath) while not self.user.isOpened(): self.user = cv2.VideoCapture(userVideoPath) cv2.waitKey(500) # Read skeleton data skeletonPath=self.samplePath + os.path.sep + self.seqID + '_skeleton.csv' if not os.path.exists(skeletonPath): raise Exception("Invalid sample file. Skeleton data is not available") self.skeletons=[] with open(skeletonPath, 'rb') as csvfile: filereader = csv.reader(csvfile, delimiter=',') for row in filereader: self.skeletons.append(Skeleton(row)) del filereader # Read sample data sampleDataPath=self.samplePath + os.path.sep + self.seqID + '_data.csv' if not os.path.exists(sampleDataPath): raise Exception("Invalid sample file. Sample data is not available") self.data=dict() with open(sampleDataPath, 'rb') as csvfile: filereader = csv.reader(csvfile, delimiter=',') for row in filereader: self.data['numFrames']=int(row[0]) self.data['fps']=int(row[1]) self.data['maxDepth']=int(row[2]) del filereader # Read labels data labelsPath=self.samplePath + os.path.sep + self.seqID + '_labels.csv' if not os.path.exists(labelsPath): #warnings.warn("Labels are not available", Warning) self.labels=[] else: self.labels=[] with open(labelsPath, 'rb') as csvfile: filereader = csv.reader(csvfile, delimiter=',') for row in filereader: self.labels.append(map(int,row)) del filereader #Îö¹¹º¯Êý def __del__(self): """ Destructor. If the object unziped the sample, it remove the temporal data """ if self.unzip: self.clean() def clean(self): """ Clean temporal unziped data """ del self.rgb; del self.depth; del self.user; shutil.rmtree(self.samplePath) #´ÓvideoÖжÁÈ¡Ò»Ö¡·µ»Ø def getFrame(self,video, frameNum): """ Get a single frame from given video object """ # Check frame number # Get total number of frames numFrames = video.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT) # Check the given file if frameNum<1 or frameNum>numFrames: raise Exception("Invalid frame number <" + str(frameNum) + ">. Valid frames are values between 1 and " + str(int(numFrames))) # Set the frame index video.set(cv2.cv.CV_CAP_PROP_POS_FRAMES,frameNum-1) ret,frame=video.read() if ret==False: raise Exception("Cannot read the frame") return frame #ÏÂÃæµÄº¯Êý¶¼ÊÇÕë¶ÔÊý¾Ý³ÉÔ±£¬µÄÌض¨Ö¡²Ù×÷µÄ def getRGB(self, frameNum): """ Get the RGB color image for the given frame """ #get RGB frame return self.getFrame(self.rgb,frameNum) #·µ»ØÉî¶Èͼ£¬Ê¹ÓÃ16int±£´æµÄ def getDepth(self, frameNum): """ Get the depth image for the given frame """ #get Depth frame depthData=self.getFrame(self.depth,frameNum) # Convert to grayscale depthGray=cv2.cvtColor(depthData,cv2.cv.CV_RGB2GRAY) # Convert to float point depth=depthGray.astype(numpy.float32) # Convert to depth values depth=depth/255.0*float(self.data['maxDepth']) depth=depth.round() depth=depth.astype(numpy.uint16) return depth def getUser(self, frameNum): """ Get user segmentation image for the given frame """ #get user segmentation frame return self.getFrame(self.user,frameNum) def getSkeleton(self, frameNum): """ Get the skeleton information for a given frame. It returns a Skeleton object """ #get user skeleton for a given frame # Check frame number # Get total number of frames numFrames = len(self.skeletons) # Check the given file if frameNum<1 or frameNum>numFrames: raise Exception("Invalid frame number <" + str(frameNum) + ">. Valid frames are values between 1 and " + str(int(numFrames))) return self.skeletons[frameNum-1] def getSkeletonImage(self, frameNum): """ Create an image with the skeleton image for a given frame """ return self.getSkeleton(frameNum).toImage(640,480,(255,255,255)) def getNumFrames(self): """ Get the number of frames for this sample """ return self.data['numFrames'] #½«ËùÓеÄÒ»Ö¡Êý¾Ý ´ò°üµ½Ò»¸ö´óµÄ¾ØÕóÀï def getComposedFrame(self, frameNum): """ Get a composition of all the modalities for a given frame """ # get sample modalities rgb=self.getRGB(frameNum) depthValues=self.getDepth(frameNum) user=self.getUser(frameNum) skel=self.getSkeletonImage(frameNum) # Build depth image depth = depthValues.astype(numpy.float32) depth = depth*255.0/float(self.data['maxDepth']) depth = depth.round() depth = depth.astype(numpy.uint8) depth = cv2.applyColorMap(depth,cv2.COLORMAP_JET) # Build final image compSize1=(max(rgb.shape[0],depth.shape[0]),rgb.shape[1]+depth.shape[1]) compSize2=(max(user.shape[0],skel.shape[0]),user.shape[1]+skel.shape[1]) comp = numpy.zeros((compSize1[0]+ compSize2[0],max(compSize1[1],compSize2[1]),3), numpy.uint8) # Create composition comp[:rgb.shape[0],:rgb.shape[1],:]=rgb comp[:depth.shape[0],rgb.shape[1]:rgb.shape[1]+depth.shape[1],:]=depth comp[compSize1[0]:compSize1[0]+user.shape[0],:user.shape[1],:]=user comp[compSize1[0]:compSize1[0]+skel.shape[0],user.shape[1]:user.shape[1]+skel.shape[1],:]=skel return comp def getComposedFrameOverlapUser(self, frameNum): """ Get a composition of all the modalities for a given frame """ # get sample modalities rgb=self.getRGB(frameNum) depthValues=self.getDepth(frameNum) user=self.getUser(frameNum) mask = numpy.mean(user, axis=2) > 150 mask = numpy.tile(mask, (3,1,1)) mask = mask.transpose((1,2,0)) # Build depth image depth = depthValues.astype(numpy.float32) depth = depth*255.0/float(self.data['maxDepth']) depth = depth.round() depth = depth.astype(numpy.uint8) depth = cv2.applyColorMap(depth,cv2.COLORMAP_JET) # Build final image compSize=(max(rgb.shape[0],depth.shape[0]),rgb.shape[1]+depth.shape[1]) comp = numpy.zeros((compSize[0]+ compSize[0],max(compSize[1],compSize[1]),3), numpy.uint8) # Create composition comp[:rgb.shape[0],:rgb.shape[1],:]=rgb comp[:depth.shape[0],rgb.shape[1]:rgb.shape[1]+depth.shape[1],:]= depth comp[compSize[0]:compSize[0]+user.shape[0],:user.shape[1],:]= mask * rgb comp[compSize[0]:compSize[0]+user.shape[0],user.shape[1]:user.shape[1]+user.shape[1],:]= mask * depth return comp def getComposedFrame_480(self, frameNum, ratio=0.5, topCut=60, botCut=140): """ Get a composition of all the modalities for a given frame """ # get sample modalities rgb=self.getRGB(frameNum) rgb = rgb[topCut:-topCut,botCut:-botCut,:] rgb = imresize(rgb, ratio, interp='bilinear') depthValues=self.getDepth(frameNum) user=self.getUser(frameNum) user = user[topCut:-topCut,botCut:-botCut,:] user = imresize(user, ratio, interp='bilinear') mask = numpy.mean(user, axis=2) > 150 mask = numpy.tile(mask, (3,1,1)) mask = mask.transpose((1,2,0)) # Build depth image depth = depthValues.astype(numpy.float32) depth = depth*255.0/float(self.data['maxDepth']) depth = depth.round() depth = depth[topCut:-topCut,botCut:-botCut] depth = imresize(depth, ratio, interp='bilinear') depth = depth.astype(numpy.uint8) depth = cv2.applyColorMap(depth,cv2.COLORMAP_JET) # Build final image compSize=(max(rgb.shape[0],depth.shape[0]),rgb.shape[1]+depth.shape[1]) comp = numpy.zeros((compSize[0]+ compSize[0],max(compSize[1],compSize[1]),3), numpy.uint8) # Create composition comp[:rgb.shape[0],:rgb.shape[1],:]=rgb comp[:depth.shape[0],rgb.shape[1]:rgb.shape[1]+depth.shape[1],:]= depth comp[compSize[0]:compSize[0]+user.shape[0],:user.shape[1],:]= mask * rgb comp[compSize[0]:compSize[0]+user.shape[0],user.shape[1]:user.shape[1]+user.shape[1],:]= mask * depth return comp def getDepth3DCNN(self, frameNum, ratio=0.5, topCut=60, botCut=140): """ Get a composition of all the modalities for a given frame """ # get sample modalities depthValues=self.getDepth(frameNum) user=self.getUser(frameNum) user = user[topCut:-topCut,botCut:-botCut,:] user = imresize(user, ratio, interp='bilinear') mask = numpy.mean(user, axis=2) > 150 # Build depth image depth = depthValues.astype(numpy.float32) depth = depth*255.0/float(self.data['maxDepth']) depth = depth.round() depth = depth[topCut:-topCut,botCut:-botCut] depth = imresize(depth, ratio, interp='bilinear') depth = depth.astype(numpy.uint8) return mask * depth def getDepthOverlapUser(self, frameNum, x_centre, y_centre, pixel_value, extractedFrameSize=224, upshift = 0): """ Get a composition of all the modalities for a given frame """ halfFrameSize = extractedFrameSize/2 user=self.getUser(frameNum) mask = numpy.mean(user, axis=2) > 150 ratio = pixel_value/ 3000 # Build depth image # get sample modalities depthValues=self.getDepth(frameNum) depth = depthValues.astype(numpy.float32) depth = depth*255.0/float(self.data['maxDepth']) mask = imresize(mask, ratio, interp='nearest') depth = imresize(depth, ratio, interp='bilinear') depth_temp = depth * mask depth_extracted = depth_temp[x_centre-halfFrameSize-upshift:x_centre+halfFrameSize-upshift, y_centre-halfFrameSize: y_centre+halfFrameSize] depth = depth.round() depth = depth.astype(numpy.uint8) depth = cv2.applyColorMap(depth,cv2.COLORMAP_JET) depth_extracted = depth_extracted.round() depth_extracted = depth_extracted.astype(numpy.uint8) depth_extracted = cv2.applyColorMap(depth_extracted,cv2.COLORMAP_JET) # Build final image compSize=(depth.shape[0],depth.shape[1]) comp = numpy.zeros((compSize[0] + extractedFrameSize,compSize[1]+compSize[1],3), numpy.uint8) # Create composition comp[:depth.shape[0],:depth.shape[1],:]=depth mask_new = numpy.tile(mask, (3,1,1)) mask_new = mask_new.transpose((1,2,0)) comp[:depth.shape[0],depth.shape[1]:depth.shape[1]+depth.shape[1],:]= mask_new * depth comp[compSize[0]:,:extractedFrameSize,:]= depth_extracted return comp def getDepthCentroid(self, startFrame, endFrame): """ Get a composition of all the modalities for a given frame """ x_centre = [] y_centre = [] pixel_value = [] for frameNum in range(startFrame, endFrame): user=self.getUser(frameNum) depthValues=self.getDepth(frameNum) depth = depthValues.astype(numpy.float32) #depth = depth*255.0/float(self.data['maxDepth']) mask = numpy.mean(user, axis=2) > 150 width, height = mask.shape XX, YY, count, pixel_sum = 0, 0, 0, 0 for x in range(width): for y in range(height): if mask[x, y]: XX += x YY += y count += 1 pixel_sum += depth[x, y] if count>0: x_centre.append(XX/count) y_centre.append(YY/count) pixel_value.append(pixel_sum/count) return [numpy.mean(x_centre), numpy.mean(y_centre), numpy.mean(pixel_value)] def getGestures(self): """ Get the list of gesture for this sample. Each row is a gesture, with the format (gestureID,startFrame,endFrame) """ return self.labels def getGestureName(self,gestureID): """ Get the gesture label from a given gesture ID """ names=('vattene','vieniqui','perfetto','furbo','cheduepalle','chevuoi','daccordo','seipazzo', \ 'combinato','freganiente','ok','cosatifarei','basta','prendere','noncenepiu','fame','tantotempo', \ 'buonissimo','messidaccordo','sonostufo') # Check the given file if gestureID<1 or gestureID>20: raise Exception("Invalid gesture ID <" + str(gestureID) + ">. Valid IDs are values between 1 and 20") return names[gestureID-1] def exportPredictions(self, prediction,predPath): """ Export the given prediction to the correct file in the given predictions path """ if not os.path.exists(predPath): os.makedirs(predPath) output_filename = os.path.join(predPath, self.seqID + '_prediction.csv') output_file = open(output_filename, 'wb') for row in prediction: output_file.write(repr(int(row[0])) + "," + repr(int(row[1])) + "," + repr(int(row[2])) + "\n") output_file.close() def play_video(self): """ play the video, Wudi adds this """ # Open video access for RGB information rgbVideoPath=self.samplePath + os.path.sep + self.seqID + '_color.mp4' if not os.path.exists(rgbVideoPath): raise Exception("Invalid sample file. RGB data is not available") self.rgb = cv2.VideoCapture(rgbVideoPath) while (self.rgb.isOpened()): ret, frame = self.rgb.read() cv2.imshow('frame',frame) if cv2.waitKey(5) & 0xFF == ord('q'): break self.rgb.release() cv2.destroyAllWindows() def evaluate(self,csvpathpred): """ Evaluate this sample agains the ground truth file """ maxGestures=11 seqLength=self.getNumFrames() # Get the list of gestures from the ground truth and frame activation predGestures = [] binvec_pred = numpy.zeros((maxGestures, seqLength)) gtGestures = [] binvec_gt = numpy.zeros((maxGestures, seqLength)) with open(csvpathpred, 'rb') as csvfilegt: csvgt = csv.reader(csvfilegt) for row in csvgt: binvec_pred[int(row[0])-1, int(row[1])-1:int(row[2])-1] = 1 predGestures.append(int(row[0])) # Get the list of gestures from prediction and frame activation for row in self.getActions(): binvec_gt[int(row[0])-1, int(row[1])-1:int(row[2])-1] = 1 gtGestures.append(int(row[0])) # Get the list of gestures without repetitions for ground truth and predicton gtGestures = numpy.unique(gtGestures) predGestures = numpy.unique(predGestures) # Find false positives falsePos=numpy.setdiff1d(gtGestures, numpy.union1d(gtGestures,predGestures)) # Get overlaps for each gesture overlaps = [] for idx in gtGestures: intersec = sum(binvec_gt[idx-1] * binvec_pred[idx-1]) aux = binvec_gt[idx-1] + binvec_pred[idx-1] union = sum(aux > 0) overlaps.append(intersec/union) # Use real gestures and false positive gestures to calculate the final score return sum(overlaps)/(len(overlaps)+len(falsePos)) def get_shift_scale(self, template, ref_depth, start_frame=10, end_frame=20, debug_show=False): """ Wudi add this method for extracting normalizing depth wrt Sample0003 """ from skimage.feature import match_template Feature_all = numpy.zeros(shape=(480, 640, end_frame-start_frame), dtype=numpy.uint16 ) count = 0 for frame_num in range(start_frame,end_frame): depth_original = self.getDepth(frame_num) mask = numpy.mean(self.getUser(frame_num), axis=2) > 150 Feature_all[:, :, count] = depth_original * mask count += 1 depth_image = Feature_all.mean(axis = 2) depth_image_normalized = depth_image * 1.0 / float(self.data['maxDepth']) depth_image_normalized /= depth_image_normalized.max() result = match_template(depth_image_normalized, template, pad_input=True) #############plot x, y = numpy.unravel_index(numpy.argmax(result), result.shape) shift = [depth_image.shape[0]/2-x, depth_image.shape[1]/2-y] subsize = 25 # we use 25 by 25 region as a measurement for median of distance minX = max(x - subsize,0) minY = max(y - subsize,0) maxX = min(x + subsize,depth_image.shape[0]) maxY = min(y + subsize,depth_image.shape[1]) subregion = depth_image[minX:maxX, minY:maxY] distance = numpy.median(subregion[subregion>0]) scaling = distance*1.0 / ref_depth from matplotlib import pyplot as plt print "[x, y, shift, distance, scaling]" print str([x, y, shift, distance, scaling]) if debug_show: fig, (ax1, ax2, ax3, ax4) = plt.subplots(ncols=4, figsize=(8, 4)) ax1.imshow(template) ax1.set_axis_off() ax1.set_title('template') ax2.imshow(depth_image_normalized) ax2.set_axis_off() ax2.set_title('image') # highlight matched region hcoin, wcoin = template.shape rect = plt.Rectangle((y-hcoin/2, x-wcoin/2), wcoin, hcoin, edgecolor='r', facecolor='none') ax2.add_patch(rect) import cv2 from scipy.misc import imresize rows,cols = depth_image_normalized.shape M = numpy.float32([[1,0, shift[1]],[0,1, shift[0]]]) affine_image = cv2.warpAffine(depth_image_normalized, M, (cols, rows)) resize_image = imresize(affine_image, scaling) resize_image_median = cv2.medianBlur(resize_image,5) ax3.imshow(resize_image_median) ax3.set_axis_off() ax3.set_title('image_transformed') # highlight matched region hcoin, wcoin = resize_image_median.shape rect = plt.Rectangle((wcoin/2-160, hcoin/2-160), 320, 320, edgecolor='r', facecolor='none') ax3.add_patch(rect) ax4.imshow(result) ax4.set_axis_off() ax4.set_title('`match_template`\nresult') # highlight matched region ax4.autoscale(False) ax4.plot(x, y, 'o', markeredgecolor='r', markerfacecolor='none', markersize=10) plt.show() return [shift, scaling] def get_shift_scale_depth(self, shift, scale, framenumber, IM_SZ, show_flag=False): """ Wudi added this method to extract segmented depth frame, by a shift and scale """ depth_original = self.getDepth(framenumber) mask = numpy.mean(self.getUser(framenumber), axis=2) > 150 resize_final_out = numpy.zeros((IM_SZ,IM_SZ)) if mask.sum() < 1000: # Kinect detect nothing print "skip "+ str(framenumber) flag = False else: flag = True depth_user = depth_original * mask depth_user_normalized = depth_user * 1.0 / float(self.data['maxDepth']) depth_user_normalized = depth_user_normalized *255 /depth_user_normalized.max() rows,cols = depth_user_normalized.shape M = numpy.float32([[1,0, shift[1]],[0,1, shift[0]]]) affine_image = cv2.warpAffine(depth_user_normalized, M,(cols, rows)) resize_image = imresize(affine_image, scale) resize_image_median = cv2.medianBlur(resize_image,5) rows, cols = resize_image_median.shape image_crop = resize_image_median[rows/2-160:rows/2+160, cols/2-160:cols/2+160] resize_final_out = imresize(image_crop, (IM_SZ,IM_SZ)) if show_flag: # show the segmented images here cv2.imshow('image',image_crop) cv2.waitKey(10) return [resize_final_out, flag] #¶¯×÷Êý¾ÝÀà class ActionSample(object): """ Class that allows to access all the information for a certain action database sample """ #define class to access actions data samples def __init__ (self,fileName): """ Constructor. Read the sample file and unzip it if it is necessary. All the data is loaded. sample=ActionSample('Sec01.zip') """ # Check the given file if not os.path.exists(fileName) and not os.path.isfile(fileName): raise Exception("Sample path does not exist: " + fileName) # Prepare sample information self.fullFile = fileName self.dataPath = os.path.split(fileName)[0] self.file=os.path.split(fileName)[1] self.seqID=os.path.splitext(self.file)[0] self.samplePath=self.dataPath + os.path.sep + self.seqID; # Unzip sample if it is necessary if os.path.isdir(self.samplePath) : self.unzip = False else: self.unzip = True zipFile=zipfile.ZipFile(self.fullFile,"r") zipFile.extractall(self.samplePath) # Open video access for RGB information rgbVideoPath=self.samplePath + os.path.sep + self.seqID + '_color.mp4' if not os.path.exists(rgbVideoPath): raise Exception("Invalid sample file. RGB data is not available") self.rgb = cv2.VideoCapture(rgbVideoPath) while not self.rgb.isOpened(): self.rgb = cv2.VideoCapture(rgbVideoPath) cv2.waitKey(500) # Read sample data sampleDataPath=self.samplePath + os.path.sep + self.seqID + '_data.csv' if not os.path.exists(sampleDataPath): raise Exception("Invalid sample file. Sample data is not available") self.data=dict() with open(sampleDataPath, 'rb') as csvfile: filereader = csv.reader(csvfile, delimiter=',') for row in filereader: self.data['numFrames']=int(row[0]) del filereader # Read labels data labelsPath=self.samplePath + os.path.sep + self.seqID + '_labels.csv' self.labels=[] if not os.path.exists(labelsPath): warnings.warn("Labels are not available", Warning) else: with open(labelsPath, 'rb') as csvfile: filereader = csv.reader(csvfile, delimiter=',') for row in filereader: self.labels.append(map(int,row)) del filereader def __del__(self): """ Destructor. If the object unziped the sample, it remove the temporal data """ if self.unzip: self.clean() def clean(self): """ Clean temporal unziped data """ del self.rgb; shutil.rmtree(self.samplePath) def getFrame(self,video, frameNum): """ Get a single frame from given video object """ # Check frame number # Get total number of frames numFrames = video.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT) # Check the given file if frameNum<1 or frameNum>numFrames: raise Exception("Invalid frame number <" + str(frameNum) + ">. Valid frames are values between 1 and " + str(int(numFrames))) # Set the frame index video.set(cv2.cv.CV_CAP_PROP_POS_FRAMES,frameNum-1) ret,frame=video.read() if ret==False: raise Exception("Cannot read the frame") return frame def getNumFrames(self): """ Get the number of frames for this sample """ return self.data['numFrames'] def getRGB(self, frameNum): """ Get the RGB color image for the given frame """ #get RGB frame return self.getFrame(self.rgb,frameNum) def getActions(self): """ Get the list of gesture for this sample. Each row is an action, with the format (actionID,startFrame,endFrame) """ return self.labels def getActionsName(self,actionID): """ Get the action label from a given action ID """ names=('wave','point','clap','crouch','jump','walk','run','shake hands', \ 'hug','kiss','fight') # Check the given file if actionID<1 or actionID>11: raise Exception("Invalid action ID <" + str(actionID) + ">. Valid IDs are values between 1 and 11") return names[actionID-1] def exportPredictions(self, prediction,predPath): """ Export the given prediction to the correct file in the given predictions path """ if not os.path.exists(predPath): os.makedirs(predPath) output_filename = os.path.join(predPath, self.seqID + '_prediction.csv') output_file = open(output_filename, 'wb') for row in prediction: output_file.write(repr(int(row[0])) + "," + repr(int(row[1])) + "," + repr(int(row[2])) + "\n") output_file.close() def evaluate(self,csvpathpred): """ Evaluate this sample agains the ground truth file """ maxGestures=11 seqLength=self.getNumFrames() # Get the list of gestures from the ground truth and frame activation predGestures = [] binvec_pred = numpy.zeros((maxGestures, seqLength)) gtGestures = [] binvec_gt = numpy.zeros((maxGestures, seqLength)) with open(csvpathpred, 'rb') as csvfilegt: csvgt = csv.reader(csvfilegt) for row in csvgt: binvec_pred[int(row[0])-1, int(row[1])-1:int(row[2])-1] = 1 predGestures.append(int(row[0])) # Get the list of gestures from prediction and frame activation for row in self.getActions(): binvec_gt[int(row[0])-1, int(row[1])-1:int(row[2])-1] = 1 gtGestures.append(int(row[0])) # Get the list of gestures without repetitions for ground truth and predicton gtGestures = numpy.unique(gtGestures) predGestures = numpy.unique(predGestures) # Find false positives falsePos=numpy.setdiff1d(gtGestures, numpy.union1d(gtGestures,predGestures)) # Get overlaps for each gesture overlaps = [] for idx in gtGestures: intersec = sum(binvec_gt[idx-1] * binvec_pred[idx-1]) aux = binvec_gt[idx-1] + binvec_pred[idx-1] union = sum(aux > 0) overlaps.append(intersec/union) # Use real gestures and false positive gestures to calculate the final score return sum(overlaps)/(len(overlaps)+len(falsePos)) #×Ë̬Êý¾ÝÀà class PoseSample(object): """ Class that allows to access all the information for a certain pose database sample """ #define class to access gesture data samples def __init__ (self,fileName): """ Constructor. Read the sample file and unzip it if it is necessary. All the data is loaded. sample=PoseSample('Seq01.zip') """ # Check the given file if not os.path.exists(fileName) and not os.path.isfile(fileName): raise Exception("Sequence path does not exist: " + fileName) # Prepare sample information self.fullFile = fileName self.dataPath = os.path.split(fileName)[0] self.file=os.path.split(fileName)[1] self.seqID=os.path.splitext(self.file)[0] self.samplePath=self.dataPath + os.path.sep + self.seqID; # Unzip sample if it is necessary if os.path.isdir(self.samplePath): self.unzip = False else: self.unzip = True zipFile=zipfile.ZipFile(self.fullFile,"r") zipFile.extractall(self.samplePath) # Set path for rgb images rgbPath=self.samplePath + os.path.sep + 'imagesjpg'+ os.path.sep if not os.path.exists(rgbPath): raise Exception("Invalid sample file. RGB data is not available") self.rgbpath = rgbPath # Set path for gt images gtPath=self.samplePath + os.path.sep + 'maskspng'+ os.path.sep if not os.path.exists(gtPath): self.gtpath= "empty" else: self.gtpath = gtPath frames=os.listdir(self.rgbpath) self.numberFrames=len(frames) def __del__(self): """ Destructor. If the object unziped the sample, it remove the temporal data """ if self.unzip: self.clean() def clean(self): """ Clean temporal unziped data """ shutil.rmtree(self.samplePath) def getRGB(self, frameNum): """ Get the RGB color image for the given frame """ #get RGB frame if frameNum>self.numberFrames: raise Exception("Number of frame has to be less than: "+ self.numberFrames) framepath=self.rgbpath+self.seqID[3:5]+'_'+ '%04d' %frameNum+'.jpg' if not os.path.isfile(framepath): raise Exception("RGB file does not exist: " + framepath) return cv2.imread(framepath) def getNumFrames(self): return self.numberFrames def getLimb(self, frameNum, actorID,limbID): """ Get the BW limb image for a certain frame and a certain limbID """ if self.gtpath == "empty": raise Exception("Limb labels are not available for this sequence. This sequence belong to the validation set.") else: limbpath=self.gtpath+self.seqID[3:5]+'_'+ '%04d' %frameNum+'_'+str(actorID)+'_'+str(limbID)+'.png' if frameNum>self.numberFrames: raise Exception("Number of frame has to be less than: "+ self.numberFrames) if actorID<1 or actorID>2: raise Exception("Invalid actor ID <" + str(actorID) + ">. Valid frames are values between 1 and 2 ") if limbID<1 or limbID>14: raise Exception("Invalid limb ID <" + str(limbID) + ">. Valid frames are values between 1 and 14") return cv2.imread(limbpath,cv2.CV_LOAD_IMAGE_GRAYSCALE) def getLimbsName(self,limbID): """ Get the limb label from a given limb ID """ names=('head','torso','lhand','rhand','lforearm','rforearm','larm','rarm', \ 'lfoot','rfoot','lleg','rleg','lthigh','rthigh') # Check the given file if limbID<1 or limbID>14: raise Exception("Invalid limb ID <" + str(limbID) + ">. Valid IDs are values between 1 and 14") return names[limbID-1] def overlap_images(self, gtimage, predimage): """ this function computes the hit measure of overlap between two binary images im1 and im2 """ [ret, im1] = cv2.threshold(gtimage, 127, 255, cv2.THRESH_BINARY) [ret, im2] = cv2.threshold(predimage, 127, 255, cv2.THRESH_BINARY) intersec = cv2.bitwise_and(im1, im2) intersec_val = float(numpy.sum(intersec)) union = cv2.bitwise_or(im1, im2) union_val = float(numpy.sum(union)) if union_val == 0: return 0 else: if float(intersec_val / union_val)>0.5: return 1 else: return 0 def exportPredictions(self, prediction,frame,actor,limb,predPath): """ Export the given prediction to the correct file in the given predictions path """ if not os.path.exists(predPath): os.makedirs(predPath) prediction_filename = predPath+os.path.sep+ self.seqID[3:5] +'_'+ '%04d' %frame +'_'+str(actor)+'_'+str(limb)+'_prediction.png' cv2.imwrite(prediction_filename,prediction) def evaluate(self, predpath): """ Evaluate this sample agains the ground truth file """ # Get the list of videos from ground truth gt_list = os.listdir(self.gtpath) # For each sample on the GT, search the given prediction score = 0.0 nevals = 0 for gtlimbimage in gt_list: # Avoid double check, use only labels file if not gtlimbimage.lower().endswith(".png"): continue # Build paths for prediction and ground truth files aux = gtlimbimage.split('.') parts = aux[0].split('_') seqID = parts[0] gtlimbimagepath = os.path.join(self.gtpath,gtlimbimage) predlimbimagepath= os.path.join(predpath) + os.path.sep + seqID+'_'+parts[1]+'_'+parts[2]+'_'+parts[3]+"_prediction.png" #check predfile exists if not os.path.exists(predlimbimagepath) or not os.path.isfile(predlimbimagepath): raise Exception("Invalid video limb prediction file. Not all limb predictions are available") #Load images gtimage=cv2.imread(gtlimbimagepath, cv2.CV_LOAD_IMAGE_GRAYSCALE) predimage=cv2.imread(predlimbimagepath, cv2.CV_LOAD_IMAGE_GRAYSCALE) if cv2.cv.CountNonZero(cv2.cv.fromarray(gtimage)) >= 1: score += self.overlap_images(gtimage, predimage) nevals += 1 #release videos and return mean overlap return score/nevals

mit

icandigitbaby/openchange

script/bug-analysis/buganalysis/pkgshelper.py

1

24843

#!/usr/bin/python # -*- coding: utf-8 -*- # Copyright (C) Enrique J. Hernández 2014 # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """ Helper methods to set the Package and Dependencies fields, if missing, from Apport crashes. This is specific to Zentyal. """ from datetime import datetime def map_package(report): """ Given a report, it will return the package and the version depending on the DistroRelease and the ExecutableTimestamp fields specific from Zentyal repositories. :param apport.report.Report report: the crash report :returns: a tuple containing the package and the version of the package. :rtype tuple: """ if 'DistroRelease' not in report or 'ExecutableTimestamp' not in report: raise SystemError('No DistroRelease or ExecutableTimestamp to map the package') distro_release = report['DistroRelease'] crash_date = datetime.fromtimestamp(int(report['ExecutableTimestamp'])) if distro_release == 'Ubuntu 14.04': if crash_date >= datetime(2014, 5, 24, 1, 31): # Release date return ('samba', '3:4.1.7+dfsg-2~zentyal2~64') return ('samba', '3:4.1.7+dfsg-2~zentyal1~32') elif distro_release == 'Ubuntu 13.10': return ('samba', '2:4.1.6+dfsg-1~zentyal1~106') elif distro_release == 'Ubuntu 12.04': if crash_date < datetime(2013, 10, 2): return ('samba4', '4.1.0rc3-zentyal3') elif crash_date < datetime(2013, 12, 10, 13, 03): return ('samba4', '4.1.0rc4-zentyal1') elif crash_date < datetime(2013, 12, 17, 11, 34): return ('samba4', '4.1.2-zentyal2') elif crash_date < datetime(2014, 3, 5, 20, 16): return ('samba4', '4.1.3-zentyal2') elif crash_date < datetime(2014, 5, 30, 8, 41): return ('samba4', '4.1.5-zentyal1') else: return ('samba4', '4.1.7-zentyal1') else: raise SystemError('Invalid Distro Release %s' % distro_release) def map_dependencies(report): """ Given a report, it will return the dependencies from the package depending on the DistroRelease fields specific from Zentyal repositories. :param apport.report.Report report: the crash report :returns: a list of the current dependencies packages :rtype tuple: """ if 'DistroRelease' not in report: raise SystemError('No DistroRelease to get the dependencies packages') distro_release = report['DistroRelease'] if distro_release == 'Ubuntu 14.04': return ( 'adduser', 'apt-utils', 'attr', 'base-passwd', 'busybox-initramfs', 'ca-certificates', 'ckeditor', 'coreutils', 'cpio', 'cron', 'dbus', 'debconf', 'debconf-i18n', 'debianutils', 'dpkg', 'e2fslibs', 'e2fsprogs', 'file', 'findutils', 'gcc-4.8-base', 'gcc-4.9-base', 'gnustep-base-common', 'gnustep-base-runtime', 'gnustep-common', 'ifupdown', 'initramfs-tools', 'initramfs-tools-bin', 'initscripts', 'insserv', 'iproute2', 'isc-dhcp-client', 'isc-dhcp-common', 'javascript-common', 'klibc-utils', 'kmod', 'krb5-locales', 'libacl1', 'libaio1', 'libapache2-mod-wsgi', 'libapparmor1', 'libapt-inst1.5', 'libapt-pkg4.12', 'libarchive-extract-perl', 'libasn1-8-heimdal', 'libattr1', 'libaudit-common', 'libaudit1', 'libavahi-client3', 'libavahi-common-data', 'libavahi-common3', 'libblkid1', 'libbsd0', 'libbz2-1.0', 'libc6', 'libcap2', 'libcgmanager0', 'libcomerr2', 'libcups2', 'libcurl3-gnutls', 'libdb5.3', 'libdbus-1-3', 'libdebconfclient0', 'libdrm2', 'libevent-2.0-5', 'libexpat1', 'libffi6', 'libfile-copy-recursive-perl', 'libgcc1', 'libgcrypt11', 'libgdbm3', 'libglib2.0-0', 'libglib2.0-data', 'libgmp10', 'libgnustep-base1.24', 'libgnutls26', 'libgpg-error0', 'libgpm2', 'libgssapi-krb5-2', 'libgssapi3-heimdal', 'libhcrypto4-heimdal', 'libhdb9-heimdal', 'libheimbase1-heimdal', 'libheimntlm0-heimdal', 'libhx509-5-heimdal', 'libicu52', 'libidn11', 'libjs-jquery', 'libjs-jquery-ui', 'libjs-prototype', 'libjs-scriptaculous', 'libjs-sphinxdoc', 'libjs-swfobject', 'libjs-underscore', 'libjson-c2', 'libjson0', 'libk5crypto3', 'libkdc2-heimdal', 'libkeyutils1', 'libklibc', 'libkmod2', 'libkrb5-26-heimdal', 'libkrb5-3', 'libkrb5support0', 'liblasso3', 'libldap-2.4-2', 'libldb1', 'liblocale-gettext-perl', 'liblog-message-simple-perl', 'liblzma5', 'libmagic1', 'libmapi0', 'libmapiproxy0', 'libmapistore0', 'libmemcached10', 'libmodule-pluggable-perl', 'libmount1', 'libmysqlclient18', 'libncurses5', 'libncursesw5', 'libnih-dbus1', 'libnih1', 'libntdb1', 'libobjc4', 'libp11-kit0', 'libpam-modules', 'libpam-modules-bin', 'libpam-runtime', 'libpam-systemd', 'libpam0g', 'libpcre3', 'libplymouth2', 'libpng12-0', 'libpod-latex-perl', 'libpopt0', 'libpq5', 'libprocps3', 'libpython-stdlib', 'libpython2.7', 'libpython2.7-minimal', 'libpython2.7-stdlib', 'libreadline6', 'libroken18-heimdal', 'librtmp0', 'libsasl2-2', 'libsasl2-modules', 'libsasl2-modules-db', 'libsbjson2.3', 'libselinux1', 'libsemanage-common', 'libsemanage1', 'libsepol1', 'libslang2', 'libsope1', 'libsqlite3-0', 'libss2', 'libssl1.0.0', 'libstdc++6', 'libsystemd-daemon0', 'libsystemd-login0', 'libtalloc2', 'libtasn1-6', 'libtdb1', 'libterm-ui-perl', 'libtevent0', 'libtext-charwidth-perl', 'libtext-iconv-perl', 'libtext-soundex-perl', 'libtext-wrapi18n-perl', 'libtinfo5', 'libudev1', 'libustr-1.0-1', 'libuuid1', 'libwbclient0', 'libwind0-heimdal', 'libxml2', 'libxmlsec1', 'libxmlsec1-openssl', 'libxslt1.1', 'libxtables10', 'logrotate', 'lsb-base', 'makedev', 'memcached', 'mime-support', 'module-init-tools', 'mount', 'mountall', 'multiarch-support', 'mysql-common', 'netbase', 'openchange-ocsmanager', 'openchange-rpcproxy', 'openchangeproxy', 'openchangeserver', 'openssl', 'passwd', 'perl', 'perl-base', 'perl-modules', 'plymouth', 'plymouth-theme-ubuntu-text', 'procps', 'psmisc', 'python', 'python-beaker', 'python-bs4', 'python-chardet', 'python-crypto', 'python-decorator', 'python-dns', 'python-dnspython', 'python-formencode', 'python-ldb', 'python-lxml', 'python-mako', 'python-markupsafe', 'python-minimal', 'python-mysqldb', 'python-nose', 'python-ntdb', 'python-ocsmanager', 'python-openid', 'python-openssl', 'python-paste', 'python-pastedeploy', 'python-pastedeploy-tpl', 'python-pastescript', 'python-pkg-resources', 'python-pygments', 'python-pylons', 'python-repoze.lru', 'python-routes', 'python-rpclib', 'python-samba', 'python-scgi', 'python-setuptools', 'python-simplejson', 'python-six', 'python-spyne', 'python-sqlalchemy', 'python-sqlalchemy-ext', 'python-support', 'python-talloc', 'python-tdb', 'python-tempita', 'python-tz', 'python-waitress', 'python-weberror', 'python-webhelpers', 'python-webob', 'python-webtest', 'python2.7', 'python2.7-minimal', 'readline-common', 'samba', 'samba-common', 'samba-common-bin', 'samba-dsdb-modules', 'samba-libs', 'samba-vfs-modules', 'sed', 'sensible-utils', 'sgml-base', 'shared-mime-info', 'sogo', 'sogo-common', 'sogo-openchange', 'systemd-services', 'sysv-rc', 'sysvinit-utils', 'tar', 'tdb-tools', 'tmpreaper', 'tzdata', 'ucf', 'udev', 'unzip', 'update-inetd', 'upstart', 'util-linux', 'uuid-runtime', 'xml-core', 'zip', 'zlib1g' ) elif distro_release == 'Ubuntu 13.10': return ( 'adduser', 'apt-utils', 'base-passwd', 'busybox-initramfs', 'ca-certificates', 'ckeditor', 'coreutils', 'cpio', 'cron', 'dbus', 'debconf', 'debconf-i18n', 'debianutils', 'dpkg', 'e2fslibs', 'e2fsprogs', 'file', 'findutils', 'gcc-4.8-base', 'gnustep-base-common', 'gnustep-base-runtime', 'gnustep-common', 'ifupdown', 'initramfs-tools', 'initramfs-tools-bin', 'initscripts', 'insserv', 'iproute2', 'isc-dhcp-client', 'isc-dhcp-common', 'klibc-utils', 'kmod', 'libacl1', 'libaio1', 'libapache2-mod-wsgi', 'libapparmor1', 'libapt-inst1.5', 'libapt-pkg4.12', 'libasn1-8-heimdal', 'libattr1', 'libaudit-common', 'libaudit1', 'libavahi-client3', 'libavahi-common-data', 'libavahi-common3', 'libblkid1', 'libbsd0', 'libbz2-1.0', 'libc6', 'libcap2', 'libclass-isa-perl', 'libcomerr2', 'libcups2', 'libcurl3-gnutls', 'libdb5.1', 'libdbus-1-3', 'libdrm2', 'libevent-2.0-5', 'libexpat1', 'libffi6', 'libfile-copy-recursive-perl', 'libgcc1', 'libgcrypt11', 'libgdbm3', 'libglib2.0-0', 'libgmp10', 'libgnustep-base1.24', 'libgnutls26', 'libgpg-error0', 'libgssapi-krb5-2', 'libgssapi3-heimdal', 'libhcrypto4-heimdal', 'libhdb9-heimdal', 'libheimbase1-heimdal', 'libheimntlm0-heimdal', 'libhx509-5-heimdal', 'libicu48', 'libidn11', 'libjs-jquery', 'libjs-jquery-ui', 'libjs-prototype', 'libjs-scriptaculous', 'libjs-sphinxdoc', 'libjs-underscore', 'libjson-c2', 'libjson0', 'libk5crypto3', 'libkdc2-heimdal', 'libkeyutils1', 'libklibc', 'libkmod2', 'libkrb5-26-heimdal', 'libkrb5-3', 'libkrb5support0', 'liblasso3', 'libldap-2.4-2', 'libldb1', 'liblocale-gettext-perl', 'liblzma5', 'libmagic1', 'libmapi0', 'libmapiproxy0', 'libmapistore0', 'libmemcached10', 'libmount1', 'libmysqlclient18', 'libncurses5', 'libncursesw5', 'libnih-dbus1', 'libnih1', 'libntdb1', 'libobjc4', 'libp11-kit0', 'libpam-modules', 'libpam-modules-bin', 'libpam-runtime', 'libpam-systemd', 'libpam0g', 'libpci3', 'libpcre3', 'libplymouth2', 'libpng12-0', 'libpopt0', 'libpq5', 'libprocps0', 'libpython-stdlib', 'libpython2.7', 'libpython2.7-minimal', 'libpython2.7-stdlib', 'libreadline6', 'libroken18-heimdal', 'librtmp0', 'libsasl2-2', 'libsasl2-modules', 'libsasl2-modules-db', 'libsbjson2.3', 'libselinux1', 'libsemanage-common', 'libsemanage1', 'libsepol1', 'libslang2', 'libsope1', 'libsqlite3-0', 'libss2', 'libssl1.0.0', 'libstdc++6', 'libswitch-perl', 'libsystemd-daemon0', 'libsystemd-login0', 'libtalloc2', 'libtasn1-3', 'libtdb1', 'libtevent0', 'libtext-charwidth-perl', 'libtext-iconv-perl', 'libtext-wrapi18n-perl', 'libtinfo5', 'libudev1', 'libusb-1.0-0', 'libustr-1.0-1', 'libuuid1', 'libwbclient0', 'libwind0-heimdal', 'libxml2', 'libxmlsec1', 'libxmlsec1-openssl', 'libxslt1.1', 'libxtables10', 'logrotate', 'lsb-base', 'makedev', 'memcached', 'mime-support', 'module-init-tools', 'mount', 'mountall', 'multiarch-support', 'mysql-common', 'netbase', 'openchange-ocsmanager', 'openchange-rpcproxy', 'openchangeproxy', 'openchangeserver', 'openssl', 'passwd', 'pciutils', 'perl', 'perl-base', 'perl-modules', 'plymouth', 'plymouth-theme-ubuntu-text', 'procps', 'psmisc', 'python', 'python-beaker', 'python-chardet', 'python-crypto', 'python-decorator', 'python-dnspython', 'python-formencode', 'python-ldb', 'python-lxml', 'python-mako', 'python-mapistore', 'python-markupsafe', 'python-minimal', 'python-mysqldb', 'python-nose', 'python-ntdb', 'python-ocsmanager', 'python-openssl', 'python-paste', 'python-pastedeploy', 'python-pastescript', 'python-pkg-resources', 'python-pygments', 'python-pylons', 'python-repoze.lru', 'python-routes', 'python-rpclib', 'python-samba', 'python-setuptools', 'python-simplejson', 'python-spyne', 'python-support', 'python-talloc', 'python-tdb', 'python-tempita', 'python-tz', 'python-weberror', 'python-webhelpers', 'python-webob', 'python-webtest', 'python2.7', 'python2.7-minimal', 'readline-common', 'samba', 'samba-common', 'samba-common-bin', 'samba-dsdb-modules', 'samba-libs', 'samba-vfs-modules', 'sed', 'sensible-utils', 'sgml-base', 'shared-mime-info', 'sogo', 'sogo-common', 'sogo-openchange', 'systemd-services', 'sysv-rc', 'sysvinit-utils', 'tar', 'tdb-tools', 'tmpreaper', 'tzdata', 'ucf', 'udev', 'update-inetd', 'upstart', 'usbutils', 'util-linux', 'xml-core', 'zip', 'zlib1g' ) elif distro_release == 'Ubuntu 12.04': return ( 'adduser', 'apache2', 'apache2-utils', 'apache2.2-bin', 'apache2.2-common', 'autotools-dev', 'base-passwd', 'bind9-host', 'binutils', 'busybox-initramfs', 'ca-certificates', 'coreutils', 'cpio', 'cpp-4.6', 'debconf', 'debianutils', 'dnsutils', 'dpkg', 'findutils', 'gcc-4.6', 'gcc-4.6-base', 'gnustep-base-common', 'gnustep-base-runtime', 'gnustep-common', 'gnustep-make', 'gobjc-4.6', 'ifupdown', 'initramfs-tools', 'initramfs-tools-bin', 'initscripts', 'insserv', 'iproute', 'klibc-utils', 'libacl1', 'libapache2-mod-wsgi', 'libapr1', 'libaprutil1', 'libaprutil1-dbd-sqlite3', 'libaprutil1-ldap', 'libasn1-8-heimdal', 'libattr1', 'libavahi-client3', 'libavahi-common-data', 'libavahi-common3', 'libbind9-80', 'libblkid1', 'libbsd0', 'libbz2-1.0', 'libc-bin', 'libc-dev-bin', 'libc6', 'libc6-dev', 'libcap2', 'libclass-isa-perl', 'libcomerr2', 'libcups2', 'libcurl3', 'libdb5.1', 'libdbus-1-3', 'libdm0', 'libdns81', 'libdrm-intel1', 'libdrm-nouveau1a', 'libdrm-radeon1', 'libdrm2', 'libevent-2.0-5', 'libexpat1', 'libffi6', 'libgcc1', 'libgcrypt11', 'libgdbm3', 'libgeoip1', 'libglib2.0-0', 'libgmp10', 'libgnustep-base1.22', 'libgnutls26', 'libgomp1', 'libgpg-error0', 'libgssapi-krb5-2', 'libgssapi3-heimdal', 'libhcrypto4-heimdal', 'libheimbase1-heimdal', 'libheimntlm0-heimdal', 'libhx509-5-heimdal', 'libicu48', 'libidn11', 'libisc83', 'libisccc80', 'libisccfg82', 'libjs-prototype', 'libjs-scriptaculous', 'libk5crypto3', 'libkeyutils1', 'libklibc', 'libkrb5-26-heimdal', 'libkrb5-3', 'libkrb5support0', 'libldap-2.4-2', 'liblwres80', 'liblzma5', 'libmapi0', 'libmapiproxy0', 'libmapistore0', 'libmemcached6', 'libmount1', 'libmpc2', 'libmpfr4', 'libmysqlclient18', 'libncurses5', 'libncursesw5', 'libnih-dbus1', 'libnih1', 'libobjc3', 'libp11-kit0', 'libpam-modules', 'libpam-modules-bin', 'libpam0g', 'libpciaccess0', 'libpcre3', 'libplymouth2', 'libpng12-0', 'libpython2.7', 'libquadmath0', 'libreadline6', 'libroken18-heimdal', 'librtmp0', 'libsasl2-2', 'libsbjson2.3', 'libselinux1', 'libslang2', 'libsope-appserver4.9', 'libsope-core4.9', 'libsope-gdl1-4.9', 'libsope-ldap4.9', 'libsope-mime4.9', 'libsope-xml4.9', 'libsqlite3-0', 'libssl1.0.0', 'libstdc++6', 'libswitch-perl', 'libtasn1-3', 'libtinfo5', 'libudev0', 'libuuid1', 'libwind0-heimdal', 'libxml2', 'libxslt1.1', 'linux-libc-dev', 'lsb-base', 'makedev', 'memcached', 'mime-support', 'module-init-tools', 'mount', 'mountall', 'multiarch-support', 'mysql-common', 'ncurses-bin', 'openchange-ocsmanager', 'openchange-rpcproxy', 'openchangeproxy', 'openchangeserver', 'openssl', 'passwd', 'perl', 'perl-base', 'perl-modules', 'plymouth', 'procps', 'python', 'python-beaker', 'python-decorator', 'python-dnspython', 'python-formencode', 'python-lxml', 'python-mako', 'python-mapistore', 'python-markupsafe', 'python-minimal', 'python-mysqldb', 'python-nose', 'python-ocsmanager', 'python-paste', 'python-pastedeploy', 'python-pastescript', 'python-pkg-resources', 'python-pygments', 'python-pylons', 'python-routes', 'python-rpclib', 'python-setuptools', 'python-simplejson', 'python-spyne', 'python-support', 'python-tempita', 'python-tz', 'python-weberror', 'python-webhelpers', 'python-webob', 'python-webtest', 'python2.7', 'python2.7-minimal', 'readline-common', 'samba4', 'sed', 'sensible-utils', 'sgml-base', 'sogo', 'sogo-openchange', 'sope4.9-libxmlsaxdriver', 'sysv-rc', 'sysvinit-utils', 'tar', 'tmpreaper', 'tzdata', 'udev', 'upstart', 'util-linux', 'xml-core', 'xz-utils', 'zlib1g' ) else: raise SystemError('Invalid Distro Release %s' % distro_release)

gpl-3.0

RossMcKenzie/ACJ

ACJ.py

1

20954

from __future__ import division import random import os import numpy as np import pickle import datetime import json class Decision(object): def __init__(self, pair, result, reviewer, time): self.pair = pair self.result = result self.reviewer = reviewer self.time = time def dict(self): return {'Pair':[str(self.pair[0]),str(self.pair[1])], 'Result':str(self.result), 'reviewer':str(self.reviewer), 'time':str(self.time)} def ACJ(data, maxRounds, noOfChoices = 1, logPath = None, optionNames = ["Choice"]): if noOfChoices < 2: return UniACJ(data, maxRounds, logPath, optionNames) else: return MultiACJ(data, maxRounds, noOfChoices, logPath, optionNames) class MultiACJ(object): '''Holds multiple ACJ objects for running comparisons with multiple choices. The first element of the list of acj objects keeps track of the used pairs.''' def __init__(self, data, maxRounds, noOfChoices, logPath = None, optionNames = None): self.data = list(data) self.n = len(data) self.round = 0 self.step = 0 self.noOfChoices = noOfChoices self.acjs = [ACJ(data, maxRounds) for _ in range(noOfChoices)] self.logPath = logPath if optionNames == None: self.optionNames = [str(i) for i in range(noOfChoices)] else: self.optionNames = optionNames self.nextRound() def getScript(self, ID): '''Gets script with ID''' return self.acjs[0].getScript(ID) def getID(self, script): '''Gets ID of script''' return self.acjs[0].getID(script) def infoPairs(self): '''Returns pairs based on summed selection arrays from Progressive Adaptive Comparitive Judgement Politt(2012) + Barrada, Olea, Ponsoda, and Abad (2010)''' pairs = [] #Create sA = np.zeros((self.n, self.n)) for acj in self.acjs: sA = sA+acj.selectionArray() while(np.max(sA)>0): iA, iB = np.unravel_index(sA.argmax(), sA.shape) pairs.append([self.data[iA], self.data[iB]]) sA[iA,:] = 0 sA[iB,:] = 0 sA[:,iA] = 0 sA[:,iB] = 0 return pairs def nextRound(self): '''Returns next round of pairs''' roundList = self.infoPairs() for acj in self.acjs: acj.nextRound(roundList) acj.step = 0 self.round = self.acjs[0].round self.step = self.acjs[0].step return self.acjs[0].roundList def nextPair(self): '''gets next pair from main acj''' p = self.acjs[0].nextPair(startNext=False) if p == -1: if self.nextRound() != None: p = self.acjs[0].nextPair(startNext=False) else: return None self.step = self.acjs[0].step return p def nextIDPair(self): '''Gets ID of next pair''' pair = self.nextPair() if pair == None: return None idPair = [] for p in pair: idPair.append(self.getID(p)) return idPair def WMS(self): ret = [] for acj in self.acjs: ret.append(acj.WMS()) return ret def comp(self, pair, result = None, update = None, reviewer = 'Unknown', time = 0): '''Adds in a result between a and b where true is a wins and False is b wins''' if result == None: result = [True for _ in range(self.noOfChoices)] if self.noOfChoices != len(result): raise StandardError('Results list needs to be noOfChoices in length') for i in range(self.noOfChoices): self.acjs[i].comp(pair, result[i], update, reviewer, time) if self.logPath != None: self.log(self.logPath, pair, result, reviewer, time) def IDComp(self, idPair, result = None, update = None, reviewer = 'Unknown', time = 0): '''Adds in a result between a and b where true is a wins and False is b wins. Uses IDs''' pair = [] for p in idPair: pair.append(self.getScript(p)) self.comp(pair, result, update, reviewer, time) def rankings(self, value=True): '''Returns current rankings Default is by value but score can be used''' rank = [] for acj in self.acjs: rank.append(acj.rankings(value)) return rank def reliability(self): '''Calculates reliability''' rel = [] for acj in self.acjs: rel.append(acj.reliability()[0]) return rel def log(self, path, pair, result, reviewer = 'Unknown', time = 0): '''Writes out a log of a comparison''' timestamp = datetime.datetime.now().strftime('_%Y_%m_%d_%H_%M_%S_%f') with open(path+os.sep+str(reviewer)+timestamp+".log", 'w+') as file: file.write("Reviewer:%s\n" % str(reviewer)) file.write("A:%s\n" % str(pair[0])) file.write("B:%s\n" % str(pair[1])) for i in range(len(result)): file.write("Winner of %s:%s\n" %(self.optionNames[i], "A" if result[i] else "B")) file.write("Time:%s\n" % str(time)) def JSONLog(self): '''Write acjs states to JSON files''' for acj in self.acjs: acj.JSONLog() def percentReturned(self): return self.acjs[0].percentReturned() def results(self): '''Prints a list of scripts and thier value scaled between 0 and 100''' rank = [] for r in self.rankings(): rank.append(list(zip(r[0], (r[1]-r[1].min())*100/(r[1].max()-r[1].min())))) return rank def decisionCount(self, reviewer): return self.acjs[0].decisionCount(reviewer) class UniACJ(object): '''Base object to hold comparison data and run algorithm script is used to refer to anything that is being ranked with ACJ Dat is an array to hold the scripts with rows being [id, script, score, quality, trials] Track is an array with each value representing number of times a winner (dim 0) has beaten the loser (dim 1) Decisions keeps track of all the descisions madein descision objects ''' def __init__(self, data, maxRounds, logPath = None, optionNames = None): self.reviewers = [] self.optionNames = optionNames self.noOfChoices = 1 self.round = 0 self.maxRounds = maxRounds self.update = False self.data = list(data) self.dat = np.zeros((5, len(data))) self.dat[0] = np.asarray(range(len(data))) #self.dat[1] = np.asarray(data) #self.dat[2] = np.zeros(len(data), dtype=float) #self.dat[3] = np.zeros(len(data), dtype=float) #self.dat[4] = np.zeros(len(data), dtype=float) self.track = np.zeros((len(data), len(data))) self.n = len(data) self.swis = 5 self.roundList = [] self.step = -1 self.decay = 1 self.returned = [] self.logPath = logPath self.decisions = [] def nextRound(self, extRoundList = None): '''Returns next round of pairs''' print("Hello") self.round = self.round+1 self.step = 0 if self.round > self.maxRounds: self.maxRounds = self.round #print(self.round) if self.round > 1: self.updateAll() if extRoundList == None: self.roundList = self.infoPairs() else: self.roundList = extRoundList self.returned = [False for i in range(len(self.roundList))] return self.roundList def polittNextRound(self): self.round = self.round+1 if self.round > self.maxRounds: self.roundList = None elif self.round<2: self.roundList = self.randomPairs() elif self.round<2+self.swis: self.updateAll() self.roundList = self.scorePairs() else: #if self.round == 1+swis: #self.dat[3] = (1/self.dat[1].size)*self.dat[2][:] self.updateAll() self.roundList = self.valuePairs() return self.roundList #return self.scorePairs() def getID(self, script): '''Gets ID of script''' return self.data.index(script) def getScript(self, ID): '''Gets script with ID''' return self.data[ID] def nextPair(self, startNext = True): '''Returns next pair. Will start new rounds automatically if startNext is true''' self.step = self.step + 1 if self.step >= len(self.roundList): if all(self.returned): if (startNext): self.nextRound() #self.polittNextRound() if self.roundList == None or self.roundList == []: return None else: return -1 else: o = [p for p in self.roundList if not self.returned[self.roundList.index(p)]] return random.choice(o) return self.roundList[self.step] def nextIDPair(self, startNext = True): '''Returns ID of next pair''' pair = self.nextPair() if pair == None: return None idPair = [] for p in pair: idPair.append(self.getID(p)) return idPair def singleProb(self, iA, iB): prob = np.exp(self.dat[3][iA]-self.dat[3][iB])/(1+np.exp(self.dat[3][iA]-self.dat[3][iB])) return prob def prob(self, iA): '''Returns a numpy array of the probability of A beating other values Based on the Bradley-Terry-Luce model (Bradley and Terry 1952; Luce 1959)''' probs = np.exp(self.dat[3][iA]-self.dat[3])/(1+np.exp(self.dat[3][iA]-self.dat[3])) return probs def fullProb(self): '''Returns a 2D array of all probabilities of x beating y''' pr = np.zeros((self.n, self.n)) for i in range(self.n): pr[i] = self.dat[3][i] return np.exp(pr-self.dat[3])/(1+np.exp(pr-self.dat[3])) def fisher(self): '''returns fisher info array''' prob = self.fullProb() return ((prob**2)*(1-prob)**2)+((prob.T**2)*(1-prob.T)**2) def selectionArray(self): '''Returns a selection array based on Progressive Adaptive Comparitive Judgement Politt(2012) + Barrada, Olea, Ponsoda, and Abad (2010)''' F = self.fisher()*np.logical_not(np.identity(self.n)) ran = np.random.rand(self.n, self.n)*np.max(F) a = 0 b = 0 #Create array from fisher mixed with noise for i in range(1, self.round+1): a = a + (i-1)**self.decay for i in range(1, self.maxRounds+1): b = b + (i-1)**self.decay W = a/b S = ((1-W)*ran)+(W*F) #Remove i=j and already compared scripts return S*np.logical_not(np.identity(self.n))*np.logical_not(self.track+self.track.T) def updateValue(self, iA): '''Updates the value of script A using Newton's Method''' scoreA = self.dat[2][iA] valA = self.dat[3][iA] probA = self.prob(iA) x = np.sum(probA)-0.5#Subtract where i = a y = np.sum(probA*(1-probA))-0.25#Subtract where i = a if x == 0: exit() #print(self.dat[3]) return self.dat[3][iA]+((self.dat[2][iA]-x)/y) #print(self.dat[3][iA]) #print("--------") def updateAll(self): '''Updates the value of all scripts using Newton's Method''' newDat = np.zeros(self.dat[3].size) for i in self.dat[0]: newDat[i] = self.updateValue(i) self.dat[3] = newDat[:] def randomPairs(self, dat = None): '''Returns a list of random pairs from dat''' if dat == None: dat = self.data shufDat = np.array(dat, copy=True) ranPairs = [] while len(shufDat)>1: a = shufDat[0] b = shufDat[1] shufDat = shufDat[2:] ranPairs.append([a,b]) return ranPairs def scorePairs(self, dat = None, scores = None): '''Returns random pairs with matching scores or close if no match''' if dat == None: dat = self.dat shuf = np.array(dat[:3], copy=True) np.random.shuffle(shuf.T) shuf.T shuf = shuf[:, np.argsort(shuf[2])] pairs = [] i = 0 #Pairs matching scores while i<(shuf[0].size-1): aID = shuf[0][i] bID = shuf[0][i+1] if (self.track[aID][bID]+self.track[bID][aID])==0 and shuf[2][i]==shuf[2][i+1]: pairs.append([self.data[shuf[0][i]], self.data[shuf[0][i+1]]]) shuf = np.delete(shuf, [i, i+1], 1) else: i = i+1 #Add on closest score couplings of unmatched scores i = 0 while i<shuf[0].size-1: aID = shuf[0][i] j = i+1 while j<shuf[0].size: bID = shuf[0][j] if (self.track[aID][bID]+self.track[bID][aID])==0: pairs.append([self.data[shuf[0][i]], self.data[shuf[0][j]]]) shuf = np.delete(shuf, [i, j], 1) break else: j = j+1 if j == shuf[0].size: i = i+1 return pairs def valuePairs(self): '''Returns pairs matched by close values Politt(2012)''' shuf = np.array(self.dat, copy=True)#Transpose to shuffle columns rather than rows np.random.shuffle(shuf.T) shuf.T pairs = [] i = 0 while i<shuf[0].size-1: aID = shuf[0][i] newShuf = shuf[:, np.argsort(np.abs(shuf[3] - shuf[3][i]))] j = 0 while j<newShuf[0].size: bID = newShuf[0][j] if (self.track[aID][bID]+self.track[bID][aID])==0 and self.data[aID]!=self.data[bID]: pairs.append([self.data[shuf[0][i]], self.data[newShuf[0][j]]]) iJ = np.where(shuf[0]==newShuf[0][j])[0][0] shuf = np.delete(shuf, [i, iJ], 1) break else: j = j+1 if j == shuf[0].size: i = i+1 return pairs def infoPairs(self): '''Returns pairs based on selection array from Progressive Adaptive Comparitive Judgement Politt(2012) + Barrada, Olea, Ponsoda, and Abad (2010)''' pairs = [] #Create sA = self.selectionArray() while(np.max(sA)>0): iA, iB = np.unravel_index(sA.argmax(), sA.shape) pairs.append([self.data[iA], self.data[iB]]) sA[iA,:] = 0 sA[iB,:] = 0 sA[:,iA] = 0 sA[:,iB] = 0 return pairs def rmse(self): '''Calculate rmse''' prob = self.fullProb() y = 1/np.sqrt(np.sum(prob*(1-prob), axis=1)-0.25) return np.sqrt(np.mean(np.square(y))) def trueSD(self): '''Calculate true standard deviation''' sd = np.std(self.dat[3]) return ((sd**2)/(self.rmse()**2))**(0.5) def reliability(self): '''Calculates reliability''' G = self.trueSD()/self.rmse() return [(G**2)/(1+(G**2))] def SR(self, pair, result): '''Calculates the Squared Residual and weight of a decision''' p = [self.getID(a) for a in pair] if result: prob = self.singleProb(p[0], p[1]) else: prob = self.singleProb(p[1], p[0]) res = 1-prob weight = prob*(1-prob) SR = (res**2) return SR, weight def addDecision(self, pair, result, reviewer, time = 0): '''Adds an SSR to the SSR array''' self.decisions.append(Decision(pair, result,reviewer, time)) def revID(self, reviewer): return self.reviewers.index(reviewer) def WMS(self, decisions = None): '''Builds data lists: [reviewer] [sum of SR, sum of weights] and uses it to make dict reviewer: WMS WMS = Sum SR/Sum weights also returns mean and std div''' if decisions == None: decisions = self.decisions self.reviewers = [] SRs = [] weights = [] for dec in decisions: if dec.reviewer not in self.reviewers: self.reviewers.append(dec.reviewer) SRs.append(0) weights.append(0) SR, weight = self.SR(dec.pair, dec.result) revID = self.reviewers.index(dec.reviewer) SRs[revID] = SRs[revID] + SR weights[revID] = weights[revID] + weight WMSs = [] WMSDict = {} for i in range(len(self.reviewers)): WMS = SRs[i]/weights[i] WMSs.append(WMS) WMSDict[self.reviewers[i]]=WMS return WMSDict, np.mean(WMSs), np.std(WMSs) def comp(self, pair, result = True, update = None, reviewer = 'Unknown', time = 0): '''Adds in a result between a and b where true is a wins and False is b wins''' self.addDecision(pair, result, reviewer, time) if pair[::-1] in self.roundList: pair = pair[::-1] result = not result if pair in self.roundList: self.returned[self.roundList.index(pair)] = True a = pair[0] b = pair[1] if update == None: update = self.update iA = self.data.index(a) iB = self.data.index(b) if result: self.track[iA,iB] = 1 self.track[iB,iA] = 0 else: self.track[iA,iB] = 0 self.track[iB,iA] = 1 self.dat[2,iA] = np.sum(self.track[iA,:]) self.dat[2,iB] = np.sum(self.track[iB,:]) self.dat[4,iA] = self.dat[4][iA]+1 self.dat[4,iB] = self.dat[4][iB]+1 if self.logPath != None: self.log(self.logPath, pair, result, reviewer, time) def IDComp(self, idPair, result = True, update = None, reviewer = 'Unknown', time=0): '''Adds in a result between a and b where true is a wins and False is b wins, Uses IDs''' pair = [] for p in idPair: pair.append(self.getScript(p)) self.comp(pair, result, update, reviewer, time) def percentReturned(self): if len(self.returned) == 0: return 0 return (sum(self.returned)/len(self.returned))*100 def log(self, path, pair, result, reviewer = 'Unknown', time = 0): '''Writes out a log of a comparison''' timestamp = datetime.datetime.now().strftime('_%Y_%m_%d_%H_%M_%S_%f') with open(path+os.sep+str(reviewer)+timestamp+".log", 'w+') as file: file.write("Reviewer:%s\n" % str(reviewer)) file.write("A:%s\n" % str(pair[0])) file.write("B:%s\n" % str(pair[1])) file.write("Winner:%s\n" %("A" if result else "B")) file.write("Time:%s\n" % str(time)) def JSONLog(self, path = None): '''Writes out a JSON containing data from ACJ''' if path == None: path = self.logPath choice = self.optionNames[0].replace(" ", "_") ACJDict = {"Criteria":choice, "Scripts":self.scriptDict(), "Reviewers":self.reviewerDict(), "Decisions":self.decisionList()} with open(path+os.sep+"ACJ_"+choice+".json", 'w+') as file: json.dump(ACJDict, file, indent=4) def decisionCount(self, reviewer): c = 0 for dec in self.decisions: if (dec.reviewer == reviewer): c = c + 1 return c def reviewerDict(self): revs = {} WMSs, _, _ = self.WMS() for rev in self.reviewers: revDict = {'decisions':self.decisionCount(rev), 'WMS':WMSs[rev]} revs[str(rev)]= revDict print(len(revs)) return revs def scriptDict(self): scr = {} r = self.results()[0] for i in range(len(r)): scrDict = {"Score":r[i][1]} scr[str(r[i][0])] = scrDict return scr def decisionList(self): dec = [] for d in self.decisions: dec.append(d.dict()) return dec def rankings(self, value=True): '''Returns current rankings Default is by value but score can be used''' if value: return [np.asarray(self.data)[np.argsort(self.dat[3])], self.dat[3][np.argsort(self.dat[3])]] else: return self.data[np.argsort(self.dat[2])] def results(self): '''Prints a list of scripts and thier value scaled between 0 and 100''' r = self.rankings() rank = list(zip(r[0], (r[1]-r[1].min())*100/(r[1].max()-r[1].min()))) return [rank]

mit

kbussell/pydocusign

pydocusign/client.py

1

20977

"""DocuSign client.""" from collections import namedtuple import base64 import json import logging import os import warnings import requests from pydocusign import exceptions logger = logging.getLogger(__name__) Response = namedtuple('Response', ['status_code', 'text']) class DocuSignClient(object): """DocuSign client.""" def __init__(self, root_url='', username='', password='', integrator_key='', account_id='', account_url='', app_token=None, oauth2_token=None, timeout=None): """Configure DocuSign client.""" #: Root URL of DocuSign API. #: #: If not explicitely provided or empty, then ``DOCUSIGN_ROOT_URL`` #: environment variable, if available, is used. self.root_url = root_url if not self.root_url: self.root_url = os.environ.get('DOCUSIGN_ROOT_URL', '') #: API username. #: #: If not explicitely provided or empty, then ``DOCUSIGN_USERNAME`` #: environment variable, if available, is used. self.username = username if not self.username: self.username = os.environ.get('DOCUSIGN_USERNAME', '') #: API password. #: #: If not explicitely provided or empty, then ``DOCUSIGN_PASSWORD`` #: environment variable, if available, is used. self.password = password if not self.password: self.password = os.environ.get('DOCUSIGN_PASSWORD', '') #: API integrator key. #: #: If not explicitely provided or empty, then #: ``DOCUSIGN_INTEGRATOR_KEY`` environment variable, if available, is #: used. self.integrator_key = integrator_key if not self.integrator_key: self.integrator_key = os.environ.get('DOCUSIGN_INTEGRATOR_KEY', '') #: API account ID. #: This attribute can be guessed via :meth:`login_information`. #: #: If not explicitely provided or empty, then ``DOCUSIGN_ACCOUNT_ID`` #: environment variable, if available, is used. self.account_id = account_id if not self.account_id: self.account_id = os.environ.get('DOCUSIGN_ACCOUNT_ID', '') #: API AppToken. #: #: If not explicitely provided or empty, then ``DOCUSIGN_APP_TOKEN`` #: environment variable, if available, is used. self.app_token = app_token if not self.app_token: self.app_token = os.environ.get('DOCUSIGN_APP_TOKEN', '') #: OAuth2 Token. #: #: If not explicitely provided or empty, then ``DOCUSIGN_OAUTH2_TOKEN`` #: environment variable, if available, is used. self.oauth2_token = oauth2_token if not self.oauth2_token: self.oauth2_token = os.environ.get('DOCUSIGN_OAUTH2_TOKEN', '') #: User's URL, i.e. the one mentioning :attr:`account_id`. #: This attribute can be guessed via :meth:`login_information`. self.account_url = account_url if self.root_url and self.account_id and not self.account_url: self.account_url = '{root}/accounts/{account}'.format( root=self.root_url, account=self.account_id) # Connection timeout. if timeout is None: timeout = float(os.environ.get('DOCUSIGN_TIMEOUT', 30)) self.timeout = timeout def get_timeout(self): """Return connection timeout.""" return self._timeout def set_timeout(self, value): """Set connection timeout. Converts ``value`` to a float. Raises :class:`ValueError` in case the value is lower than 0.001. """ if value < 0.001: raise ValueError('Cannot set timeout lower than 0.001') self._timeout = int(value * 1000) / 1000. def del_timeout(self): """Remove timeout attribute.""" del self._timeout timeout = property( get_timeout, set_timeout, del_timeout, """Connection timeout, in seconds, for HTTP requests to DocuSign's API. This is not timeout for full request, only connection. Precision is limited to milliseconds: >>> client = DocuSignClient(timeout=1.2345) >>> client.timeout 1.234 Setting timeout lower than 0.001 is forbidden. >>> client.timeout = 0.0009 # Doctest: +ELLIPSIS Traceback (most recent call last): ... ValueError: Cannot set timeout lower than 0.001 """ ) def base_headers(self, sobo_email=None): """Return dictionary of base headers for all HTTP requests. :param sobo_email: if specified, will set the appropriate header to act on behalf of that user. The authenticated account must have the appropriate permissions. See: https://www.docusign.com/p/RESTAPIGuide/RESTAPIGuide.htm#SOBO/Send%20On%20Behalf%20Of%20Functionality%20in%20the%20DocuSign%20REST%20API.htm """ headers = { 'Accept': 'application/json', 'Content-Type': 'application/json', } if self.oauth2_token: headers['Authorization'] = 'Bearer ' + self.oauth2_token if sobo_email: headers['X-DocuSign-Act-As-User'] = sobo_email else: auth = { 'Username': self.username, 'Password': self.password, 'IntegratorKey': self.integrator_key, } if sobo_email: auth['SendOnBehalfOf'] = sobo_email headers['X-DocuSign-Authentication'] = json.dumps(auth) return headers def _request(self, url, method='GET', headers=None, data=None, json_data=None, expected_status_code=200, sobo_email=None): """Shortcut to perform HTTP requests.""" do_url = '{root}{path}'.format(root=self.root_url, path=url) do_request = getattr(requests, method.lower()) if headers is None: headers = {} do_headers = self.base_headers(sobo_email) do_headers.update(headers) if data is not None: do_data = json.dumps(data) else: do_data = None try: response = do_request(do_url, headers=do_headers, data=do_data, json=json_data, timeout=self.timeout) except requests.exceptions.RequestException as exception: msg = "DocuSign request error: " \ "{method} {url} failed ; " \ "Error: {exception}" \ .format(method=method, url=do_url, exception=exception) logger.error(msg) raise exceptions.DocuSignException(msg) if response.status_code != expected_status_code: msg = "DocuSign request failed: " \ "{method} {url} returned code {status} " \ "while expecting code {expected}; " \ "Message: {message} ; " \ .format( method=method, url=do_url, status=response.status_code, expected=expected_status_code, message=response.text, ) logger.error(msg) raise exceptions.DocuSignException(msg) if response.headers.get('Content-Type', '') \ .startswith('application/json'): return response.json() return response.text def get(self, *args, **kwargs): """Shortcut to perform GET operations on DocuSign API.""" return self._request(method='GET', *args, **kwargs) def post(self, *args, **kwargs): """Shortcut to perform POST operations on DocuSign API.""" return self._request(method='POST', *args, **kwargs) def put(self, *args, **kwargs): """Shortcut to perform PUT operations on DocuSign API.""" return self._request(method='PUT', *args, **kwargs) def delete(self, *args, **kwargs): """Shortcut to perform DELETE operations on DocuSign API.""" return self._request(method='DELETE', *args, **kwargs) def login_information(self): """Return dictionary of /login_information. Populate :attr:`account_id` and :attr:`account_url`. """ url = '/login_information' headers = { } data = self.get(url, headers=headers) self.account_id = data['loginAccounts'][0]['accountId'] self.account_url = '{root}/accounts/{account}'.format( root=self.root_url, account=self.account_id) return data @classmethod def oauth2_token_request(cls, root_url, username, password, integrator_key): url = root_url + '/oauth2/token' data = { 'grant_type': 'password', 'client_id': integrator_key, 'username': username, 'password': password, 'scope': 'api', } headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded', } response = requests.post(url, headers=headers, data=data) if response.status_code != 200: raise exceptions.DocuSignOAuth2Exception(response.json()) return response.json()['access_token'] @classmethod def oauth2_token_revoke(cls, root_url, token): url = root_url + '/oauth2/revoke' data = { 'token': token, } headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded', } response = requests.post(url, headers=headers, data=data) if response.status_code != 200: raise exceptions.DocuSignOAuth2Exception(response.json()) def get_account_information(self, account_id=None): """Return dictionary of /accounts/:accountId. Uses :attr:`account_id` (see :meth:`login_information`) if ``account_id`` is ``None``. """ if account_id is None: account_id = self.account_id url = self.account_url else: url = '/accounts/{accountId}/'.format(accountId=self.account_id) return self.get(url) def get_account_provisioning(self): """Return dictionary of /accounts/provisioning.""" url = '/accounts/provisioning' headers = { 'X-DocuSign-AppToken': self.app_token, } return self.get(url, headers=headers) def post_account(self, data): """Create account.""" url = '/accounts' return self.post(url, data=data, expected_status_code=201) def delete_account(self, accountId): """Create account.""" url = '/accounts/{accountId}'.format(accountId=accountId) data = self.delete(url) return data.strip() == '' def _create_envelope_from_documents_request(self, envelope): """Return parts of the POST request for /envelopes. .. warning:: Only one document is supported at the moment. This is a limitation of `pydocusign`, not of `DocuSign`. """ data = envelope.to_dict() documents = [] for document in envelope.documents: documents.append({ "documentId": document.documentId, "name": document.name, "fileExtension": "pdf", "documentBase64": base64.b64encode( document.data.read()).decode('utf-8') }) data['documents'] = documents return data def _create_envelope_from_template_request(self, envelope): """Return parts of the POST request for /envelopes, for creating an envelope from a template. """ return envelope.to_dict() def _create_envelope(self, envelope, data): """POST to /envelopes and return created envelope ID. Called by ``create_envelope_from_document`` and ``create_envelope_from_template`` methods. """ if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes'.format( accountId=self.account_id) response_data = self._request( url, method='POST', json_data=data, expected_status_code=201) if not envelope.client: envelope.client = self if not envelope.envelopeId: envelope.envelopeId = response_data['envelopeId'] return response_data['envelopeId'] def create_envelope_from_documents(self, envelope): """POST to /envelopes and return created envelope ID. If ``envelope`` has no (or empty) ``envelopeId`` attribute, this method sets the value. If ``envelope`` has no (or empty) ``client`` attribute, this method sets the value. """ data = self._create_envelope_from_documents_request(envelope) return self._create_envelope(envelope, data) def create_envelope_from_document(self, envelope): warnings.warn("This method will be deprecated, use " "create_envelope_from_documents instead.", DeprecationWarning) data = self._create_envelope_from_documents_request(envelope) return self._create_envelope(envelope, data) def create_envelope_from_template(self, envelope): """POST to /envelopes and return created envelope ID. If ``envelope`` has no (or empty) ``envelopeId`` attribute, this method sets the value. If ``envelope`` has no (or empty) ``client`` attribute, this method sets the value. """ data = self._create_envelope_from_template_request(envelope) return self._create_envelope(envelope, data) def void_envelope(self, envelopeId, voidedReason): """PUT to /{account}/envelopes/{envelopeId} with 'voided' status and voidedReason, and return JSON.""" if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes/{envelopeId}' \ .format(accountId=self.account_id, envelopeId=envelopeId) data = { 'status': 'voided', 'voidedReason': voidedReason } return self.put(url, data=data) def get_envelope(self, envelopeId): """GET {account}/envelopes/{envelopeId} and return JSON.""" if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes/{envelopeId}' \ .format(accountId=self.account_id, envelopeId=envelopeId) return self.get(url) def get_envelope_recipients(self, envelopeId): """GET {account}/envelopes/{envelopeId}/recipients and return JSON.""" if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes/{envelopeId}/recipients' \ .format(accountId=self.account_id, envelopeId=envelopeId) return self.get(url) def post_recipient_view(self, authenticationMethod=None, clientUserId='', email='', envelopeId='', returnUrl='', userId='', userName=''): """POST to {account}/envelopes/{envelopeId}/views/recipient. This is the method to start embedded signing for recipient. Return JSON from DocuSign response. """ if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes/{envelopeId}/views/recipient' \ .format(accountId=self.account_id, envelopeId=envelopeId) if authenticationMethod is None: authenticationMethod = 'none' data = { 'authenticationMethod': authenticationMethod, 'clientUserId': clientUserId, 'email': email, 'envelopeId': envelopeId, 'returnUrl': returnUrl, 'userId': userId, 'userName': userName, } return self.post(url, data=data, expected_status_code=201) def get_envelope_document_list(self, envelopeId): """GET the list of envelope's documents.""" if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes/{envelopeId}/documents' \ .format(accountId=self.account_id, envelopeId=envelopeId) data = self.get(url) return data['envelopeDocuments'] def get_envelope_document(self, envelopeId, documentId): """Download one document in envelope, return file-like object.""" if not self.account_url: self.login_information() url = '{root}/accounts/{accountId}/envelopes/{envelopeId}' \ '/documents/{documentId}' \ .format(root=self.root_url, accountId=self.account_id, envelopeId=envelopeId, documentId=documentId) headers = self.base_headers() response = requests.get(url, headers=headers, stream=True) return response.raw def get_template(self, templateId): """GET the definition of the template.""" if not self.account_url: self.login_information() url = '/accounts/{accountId}/templates/{templateId}' \ .format(accountId=self.account_id, templateId=templateId) return self.get(url) def get_connect_failures(self): """GET a list of DocuSign Connect failures.""" if not self.account_url: self.login_information() url = '/accounts/{accountId}/connect/failures' \ .format(accountId=self.account_id) return self.get(url)['failures'] def add_envelope_recipients(self, envelopeId, recipients, resend_envelope=False): """Add one or more recipients to an envelope DocuSign reference: https://docs.docusign.com/esign/restapi/Envelopes/EnvelopeRecipients/create/ """ if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes/{envelopeId}/recipients' \ .format(accountId=self.account_id, envelopeId=envelopeId) if resend_envelope: url += '?resend_envelope=true' data = {'signers': [recipient.to_dict() for recipient in recipients]} return self.post(url, data=data) def update_envelope_recipients(self, envelopeId, recipients, resend_envelope=False): """Modify recipients in a draft envelope or correct recipient information for an in process envelope DocuSign reference: https://docs.docusign.com/esign/restapi/Envelopes/EnvelopeRecipients/update/ """ if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes/{envelopeId}/recipients' \ .format(accountId=self.account_id, envelopeId=envelopeId) if resend_envelope: url += '?resend_envelope=true' data = {'signers': [recipient.to_dict() for recipient in recipients]} return self.put(url, data=data) def delete_envelope_recipient(self, envelopeId, recipientId): """Deletes one or more recipients from a draft or sent envelope. DocuSign reference: https://docs.docusign.com/esign/restapi/Envelopes/EnvelopeRecipients/delete/ """ if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes/{envelopeId}/recipients/' \ '{recipientId}'.format(accountId=self.account_id, envelopeId=envelopeId, recipientId=recipientId) return self.delete(url) def delete_envelope_recipients(self, envelopeId, recipientIds): """Deletes one or more recipients from a draft or sent envelope. DocuSign reference: https://docs.docusign.com/esign/restapi/Envelopes/EnvelopeRecipients/deleteList/ """ if not self.account_url: self.login_information() url = '/accounts/{accountId}/envelopes/{envelopeId}/recipients' \ .format(accountId=self.account_id, envelopeId=envelopeId) data = {'signers': [{'recipientId': id_} for id_ in recipientIds]} return self.delete(url, data=data)

bsd-3-clause

chfoo/cloaked-octo-nemesis

visibli/visibli_url_grab.py

1

14609

'''Grab Visibli hex shortcodes''' # Copyright 2013 Christopher Foo <chris.foo@gmail.com> # Licensed under GPLv3. See COPYING.txt for details. import argparse import base64 import collections import gzip import html.parser import http.client import logging import logging.handlers import math import os import queue import random import re import sqlite3 import threading import time import atexit _logger = logging.getLogger(__name__) class UnexpectedResult(ValueError): pass class UserAgent(object): def __init__(self, filename): self.strings = [] with open(filename, 'rt') as f: while True: line = f.readline().strip() if not line: break self.strings.append(line) self.strings = tuple(self.strings) _logger.info('Initialized with %d user agents', len(self.strings)) class AbsSineyRateFunc(object): def __init__(self, avg_rate=1.0): self._avg_rate = avg_rate self._amplitude = 1.0 / self._avg_rate * 5.6 self._x = 1.0 def get(self): y = abs(self._amplitude * math.sin(self._x) * math.sin(self._x ** 2) / self._x) self._x += 0.05 if self._x > 2 * math.pi: self._x = 1.0 return y class HTTPClientProcessor(threading.Thread): def __init__(self, request_queue, response_queue, host, port): threading.Thread.__init__(self) self.daemon = True self._request_queue = request_queue self._response_queue = response_queue self._http_client = http.client.HTTPConnection(host, port) self.start() def run(self): while True: path, headers, shortcode = self._request_queue.get() try: _logger.debug('Get %s %s', path, headers) self._http_client.request('GET', path, headers=headers) response = self._http_client.getresponse() except http.client.HTTPException: _logger.exception('Got an http error.') self._http_client.close() time.sleep(120) else: _logger.debug('Got response %s %s', response.status, response.reason) data = response.read() self._response_queue.put((response, data, shortcode)) class InsertQueue(threading.Thread): def __init__(self, db_path): threading.Thread.__init__(self) self.daemon = True self._queue = queue.Queue(maxsize=100) self._event = threading.Event() self._running = True self._db_path = db_path self.start() def run(self): self._db = sqlite3.connect(self._db_path) while self._running: self._process() self._event.wait(timeout=10) def _process(self): with self._db: while True: try: statement, values = self._queue.get_nowait() except queue.Empty: break _logger.debug('Executing statement') self._db.execute(statement, values) def stop(self): self._running = False self._event.set() def add(self, statement, values): self._queue.put((statement, values)) class VisibliHexURLGrab(object): def __init__(self, sequential=False, reverse_sequential=False, avg_items_per_sec=0.5, database_dir='', user_agent_filename=None, http_client_threads=2, save_reports=False): db_path = os.path.join(database_dir, 'visibli.db') self.database_dir = database_dir self.db = sqlite3.connect(db_path) self.db.execute('PRAGMA journal_mode=WAL') with self.db: self.db.execute('''CREATE TABLE IF NOT EXISTS visibli_hex (shortcode INTEGER PRIMARY KEY ASC, url TEXT, not_exist INTEGER) ''') self.host = 'localhost' self.port = 8123 self.save_reports = save_reports self.request_queue = queue.Queue(maxsize=1) self.response_queue = queue.Queue(maxsize=10) self.http_clients = self.new_clients(http_client_threads) self.throttle_time = 1 self.sequential = sequential self.reverse_sequential = reverse_sequential self.seq_num = 0xffffff if self.reverse_sequential else 0 self.session_count = 0 #self.total_count = self.get_count() or 0 self.total_count = 0 self.user_agent = UserAgent(user_agent_filename) self.headers = { 'Accept-Encoding': 'gzip', 'Host': 'links.sharedby.co', } self.average_deque = collections.deque(maxlen=100) self.rate_func = AbsSineyRateFunc(avg_items_per_sec) self.miss_count = 0 self.hit_count = 0 self.insert_queue = InsertQueue(db_path) atexit.register(self.insert_queue.stop) def new_clients(self, http_client_threads=2): return [HTTPClientProcessor(self.request_queue, self.response_queue, self.host, self.port) for dummy in range(http_client_threads)] def shortcode_to_int(self, shortcode): return int.from_bytes(shortcode, byteorder='big', signed=False) def new_shortcode(self): while True: if self.sequential or self.reverse_sequential: s = '{:06x}'.format(self.seq_num) shortcode = base64.b16decode(s.encode(), casefold=True) if self.reverse_sequential: self.seq_num -= 1 if self.seq_num < 0: return None else: self.seq_num += 1 if self.seq_num > 0xffffff: return None else: shortcode = os.urandom(3) rows = self.db.execute('SELECT 1 FROM visibli_hex WHERE ' 'shortcode = ? LIMIT 1', [self.shortcode_to_int(shortcode)]) if not len(list(rows)): return shortcode def run(self): self.check_proxy_tor() while True: if not self.insert_queue.is_alive(): raise Exception('Insert queue died!') shortcode = self.new_shortcode() if shortcode is None: break shortcode_str = base64.b16encode(shortcode).lower().decode() path = 'http://links.sharedby.co/links/{}'.format(shortcode_str) headers = self.get_headers() while True: try: self.request_queue.put_nowait((path, headers, shortcode)) except queue.Full: self.read_responses() else: break if self.session_count % 10 == 0: _logger.info('Session={}, hit={}, total={}, {:.3f} u/s'.format( self.session_count, self.hit_count, self.session_count + self.total_count, self.calc_avg())) t = self.rate_func.get() _logger.debug('Sleep {:.3f}'.format(t)) time.sleep(t) self.read_responses() _logger.info('Shutting down...') time.sleep(30) self.read_responses() self.insert_queue.stop() self.insert_queue.join() def get_headers(self): d = dict(self.headers) d['User-Agent'] = random.choice(self.user_agent.strings) return d def read_responses(self): while True: try: response, data, shortcode = self.response_queue.get(block=True, timeout=0.05) except queue.Empty: break self.session_count += 1 shortcode_str = base64.b16encode(shortcode).lower().decode() try: url = self.read_response(response, data) except UnexpectedResult as e: _logger.warn('Unexpected result %s', e) if self.save_reports: try: self.write_report(e, shortcode_str, response, data) except: _logger.exception('Error writing report') self.throttle(None, force=True) continue if not url: self.add_no_url(shortcode) self.miss_count += 1 else: self.add_url(shortcode, url) self.miss_count = 0 self.hit_count += 1 _logger.info('%s->%s...', shortcode_str, url[:30] if url else '(none)') self.throttle(response.status) def read_response(self, response, data): if response.getheader('Content-Encoding') == 'gzip': _logger.debug('Got gzip data') data = gzip.decompress(data) if response.status == 301: url = response.getheader('Location') return url elif response.status == 200: match = re.search(br'<iframe id="[^"]+" src="([^"]+)">', data) if not match: raise UnexpectedResult('No iframe found') url = match.group(1).decode() url = html.parser.HTMLParser().unescape(url) return url elif response.status == 302: location = response.getheader('Location') # if location and 'sharedby' not in location \ # and 'visibli' not in location: if location and location.startswith('http://yahoo.com'): raise UnexpectedResult( 'Weird 302 redirect to {}'.format(location)) elif not location: raise UnexpectedResult('No redirect location') return else: raise UnexpectedResult('Unexpected status {}'.format( response.status)) def throttle(self, status_code, force=False): if force or 400 <= status_code <= 499 or 500 <= status_code <= 999 \ or self.miss_count > 2: _logger.info('Throttle %d seconds', self.throttle_time) time.sleep(self.throttle_time) self.throttle_time *= 2 self.throttle_time = min(3600, self.throttle_time) else: self.throttle_time /= 2 self.throttle_time = min(600, self.throttle_time) self.throttle_time = max(1, self.throttle_time) def add_url(self, shortcode, url): _logger.debug('Insert %s %s', shortcode, url) self.insert_queue.add('INSERT OR IGNORE INTO visibli_hex VALUES (?, ?, ?)', [self.shortcode_to_int(shortcode), url, None]) def add_no_url(self, shortcode): _logger.debug('Mark no url %s', shortcode) self.insert_queue.add('INSERT OR IGNORE INTO visibli_hex VALUES (?, ?, ?)', [self.shortcode_to_int(shortcode), None, 1]) def get_count(self): for row in self.db.execute('SELECT COUNT(ROWID) FROM visibli_hex ' 'LIMIT 1'): return int(row[0]) def calc_avg(self): self.average_deque.append((self.session_count, time.time())) try: avg = ((self.session_count - self.average_deque[0][0]) / (time.time() - self.average_deque[0][1])) except ArithmeticError: avg = 0 return avg def check_proxy_tor(self): http_client = http.client.HTTPConnection(self.host, self.port) http_client.request('GET', 'http://check.torproject.org/', headers={'Host': 'check.torproject.org'}) response = http_client.getresponse() data = response.read() _logger.debug('Check proxy got data=%s', data.decode()) if response.status != 200: raise UnexpectedResult('Check tor page returned %d', response.status) if b'Congratulations. Your browser is configured to use Tor.' \ not in data: raise UnexpectedResult('Not configured to use tor') _logger.info('Using tor proxy') def write_report(self, error, shortcode_str, response, data): path = os.path.join(self.database_dir, 'report_{:.04f}'.format(time.time())) _logger.debug('Writing report to %s', path) with open(path, 'wt') as f: f.write('Error ') f.write(str(error)) f.write('\n') f.write('Code ') f.write(shortcode_str) f.write('\n') f.write(str(response.status)) f.write(response.reason) f.write('\n') f.write(str(response.getheaders())) f.write('\n\nData\n\n') f.write(str(data)) f.write('\n\nEnd Report\n') if __name__ == '__main__': arg_parser = argparse.ArgumentParser() arg_parser.add_argument('--sequential', action='store_true') arg_parser.add_argument('--reverse-sequential', action='store_true') arg_parser.add_argument('--save-reports', action='store_true') arg_parser.add_argument('--average-rate', type=float, default=1.0) arg_parser.add_argument('--quiet', action='store_true') arg_parser.add_argument('--database-dir', default=os.getcwd()) arg_parser.add_argument('--log-dir', default=os.getcwd()) arg_parser.add_argument('--user-agent-file', default=os.path.join(os.getcwd(), 'user-agents.txt')) arg_parser.add_argument('--threads', type=int, default=2) args = arg_parser.parse_args() root_logger = logging.getLogger() root_logger.setLevel(logging.DEBUG) if not args.quiet: console = logging.StreamHandler() console.setLevel(logging.INFO) console.setFormatter( logging.Formatter('%(levelname)s %(message)s')) root_logger.addHandler(console) log_filename = os.path.join(args.log_dir, 'visibli_url_grab.log') file_log = logging.handlers.RotatingFileHandler(log_filename, maxBytes=1048576, backupCount=9) file_log.setLevel(logging.DEBUG) file_log.setFormatter(logging.Formatter( '%(asctime)s %(name)s:%(lineno)d %(levelname)s %(message)s')) root_logger.addHandler(file_log) o = VisibliHexURLGrab(sequential=args.sequential, reverse_sequential=args.reverse_sequential, database_dir=args.database_dir, avg_items_per_sec=args.average_rate, user_agent_filename=args.user_agent_file, http_client_threads=args.threads, save_reports=args.save_reports,) o.run()

gpl-3.0

jsaponara/opentaxforms

opentaxforms/ut.py

1

14660

from __future__ import print_function import logging import os import pkg_resources import re import six import sys from collections import ( namedtuple as ntuple, defaultdict as ddict, OrderedDict as odict) from datetime import datetime from os.path import join as pathjoin, exists from pint import UnitRegistry from pprint import pprint as pp, pformat as pf from subprocess import Popen, PIPE from sys import stdout, exc_info try: from cPickle import dump, load except ImportError: from pickle import dump, load NL = '\n' TAB = '\t' quiet = False Bbox = ntuple('Bbox', 'x0 y0 x1 y1') def merge(bb1, bb2): return Bbox( min(bb1.x0, bb2.x0), min(bb1.y0, bb2.y0), max(bb1.x1, bb2.x1), max(bb1.y1, bb2.y1)) def numerify(s): try: return int(''.join(d for d in s if d.isdigit())) except ValueError: return s def compactify(multilineRegex): # to avoid having to replace spaces in multilineRegex's with less readable # '\s' etc no re.VERBOSE flag needed r""" line too long (folded): titlePttn1=re.compile(r'(?:(\d\d\d\d) )?Form ([\w-]+(?: \w\w?)?) (?: or ([\w-]+))?(?: ?\(?(?:Schedule ([\w-]+))\)?)? (?: ?\((?:Rev|Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) .+?\))?\s*$') re.VERBOSE with spaces removed (else theyll be ignored in VERBOSE mode): pttn=re.compile( r'''(?:(\d\d\d\d)\s)? # 2016 Form\s([\w-]+ # Form 1040 (?:\s\w\w?)?) # AS (?:\sor\s([\w-]+))? # or 1040A (?:\s\s?\(?(?:Schedule\s([\w-]+))\)?)? # (Schedule B) (?:\s\s?\((?:Rev|Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec).+?\))?\s*$''',re.VERBOSE) using compactify: >>> anyMonth = 'Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec' >>> compactify( ... '''(?:(\d\d\d\d) )? # 2016 ... Form ([\w-]+ # Form 1040 ... (?: \w\w?)?) # AS ... (?: or ([\w-]+))? # or 1040A ... (?: ?\(?(?:Schedule ([\w-]+))\)?)? # (Schedule B) ... (?: ?\((?:Rev|'''+anyMonth+''').+?\))?\s*$''') '(?:(\\d\\d\\d\\d) )?Form ([\\w-]+(?: \\w\\w?)?)(?: or ([\\w-]+))?' '(?: ?\\(?(?:Schedule ([\\w-]+))\\)?)?' '(?: ?\\(' '(?:Rev|Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec).+?\\))?' '\\s*$' # todo what should compactify return for these? # [but note this entire docstring is raw] #>>> compactify(r'\ # comment') #>>> compactify(r'\\ # comment') #>>> compactify( '\ # comment') #>>> compactify( '\\ # comment') #print len(multilineRegex), '[%s%s]'%(multilineRegex[0],multilineRegex[1]) """ def crunch(seg): return re.sub(' *#.*$', '', seg.lstrip()) segs = multilineRegex.split(NL) return ''.join(crunch(seg) for seg in segs) class NoSuchPickle(Exception): pass class PickleException(Exception): pass def pickle(data, pickleFilePrefix): picklname = '%s.pickl' % (pickleFilePrefix) with open(picklname, 'wb') as pickl: dump(data, pickl) def unpickle(pickleFilePrefix, default=None): picklname = '%s.pickl' % (pickleFilePrefix) try: with open(picklname, 'rb') as pickl: data = load(pickl) except IOError as e: clas, exc, tb = exc_info() if e.errno == 2: # no such file if default == 'raise': raise NoSuchPickle(NoSuchPickle(exc.args)).with_traceback(tb) else: data = default else: raise PickleException(PickleException(exc.args)).with_traceback(tb) return data def flattened(l): # only works for single level of sublists return [i for sublist in l for i in sublist] def hasdups(l, key=None): if key is None: ll = l else: ll = [key(it) for it in l] return any(it in ll[1 + i:] for i, it in enumerate(ll)) def uniqify(l): '''uniqify in place''' s = set() idxs = [] # indexes of duplicate items for i, item in enumerate(l): if item in s: idxs.append(i) else: s.add(item) for i in reversed(idxs): l.pop(i) return l def uniqify2(l): '''uniqify in place; probably faster for small lists''' for i, item in enumerate(reversed(l)): if item in l[:i - 1]: l.pop(i) return l log = logging.getLogger() defaultLoglevel = 'WARN' alreadySetupLogging = False def setupLogging(loggerId, args=None): global alreadySetupLogging if alreadySetupLogging: log.warn('ignoring extra call to setupLogging') fname = log.name else: if args: loglevel = args.loglevel.upper() else: loglevel = defaultLoglevel loglevel = getattr(logging, loglevel) if not isinstance(loglevel, int): allowedLogLevels = 'debug info warn warning error critical exception' raise ValueError('Invalid log level: %s, allowedLogLevels are %s' % ( args.loglevel, allowedLogLevels)) fname = loggerId + '.log' filehandler=logging.FileHandler(fname, mode='w', encoding='utf-8') filehandler.setLevel(loglevel) log.setLevel(loglevel) log.addHandler(filehandler) alreadySetupLogging = True return fname def unsetupLogging(): global alreadySetupLogging alreadySetupLogging=False log.handlers = [] defaultOutput = stdout def logg(msg, outputs=None): ''' log=setupLogging('test') logg('just testing',[stdout,log.warn]) ''' if outputs is None: outputs = [defaultOutput] for o in outputs: m = msg if o == stdout: o = stdout.write m = msg + '\n' if quiet and o == stdout.write: continue o(m) def jj(*args, **kw): ''' jj is a more flexible join(), handy for debug output >>> jj(330,'info',None) '330 info None' ''' delim = kw.get('delim', ' ') try: return delim.join(str(x) for x in args) except Exception: return delim.join(six.text_type(x) for x in args) def jdb(*args, **kw): logg(jj(*args, **kw), [log.debug]) def run0(cmd): try: # shell is handy for executable path, etc proc = Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE) out, err = proc.communicate() except OSError as exc: err = str(exc) out = None return out, err def run(cmd, logprefix='run', loglevel='INFO'): loglevel = getattr(logging, loglevel.upper(), None) out, err = run0(cmd) out, err = out.strip(), err.strip() msg = '%s: command [%s] returned error [%s] and output [%s]' % ( logprefix, cmd, err, out) if err: log.error(msg) raise Exception(msg) else: log.log(loglevel, msg) return out, err class Resource(object): def __init__(self, pkgname, fpath=None): self.pkgname = pkgname self.fpath = fpath def path(self): return pkg_resources.resource_filename(self.pkgname, self.fpath) def content(self): return pkg_resources.resource_string(self.pkgname, self.fpath) class CharEnum(object): # unlike a real enum, no order guarantee the simplest one from this url: # http://stackoverflow.com/questions/2676133/ @classmethod def keys(cls): return [k for k in cls.__dict__ if not k.startswith('_')] @classmethod def vals(cls): return [cls.__dict__[k] for k in cls.keys()] @classmethod def items(cls): return zip(cls.keys(), cls.vals()) class ChainablyUpdatableOrderedDict(odict): ''' handy for ordered initialization >>> d=ChainablyUpdatableOrderedDict()(a=0)(b=1)(c=2) >>> assert d.keys()==['a','b','c'] ''' def __init__(self): super(ChainablyUpdatableOrderedDict, self).__init__() def __call__(self, **kw): self.update(kw) return self class Bag(object): # after alexMartelli at http://stackoverflow.com/questions/2597278 def __init__(self, *maps, **kw): ''' >>> b=Bag(a=0) >>> b.a=1 >>> b.b=0 >>> c=Bag(b) ''' for mapp in maps: getdict = None if type(mapp) == dict: getdict = lambda x: x # def getdict(x): return x elif type(mapp) == Bag: getdict = lambda x: x.__dict__ # def getdict(x): return x.__dict__ elif type(mapp) == tuple: mapp, getdict = mapp if getdict is not None: self.__dict__.update(getdict(mapp)) else: mapp, getitems = self._getGetitems(mapp) for k, v in getitems(mapp): self.__dict__[k] = v self.__dict__.update(kw) def _getGetitems(self, mapp): if type(mapp) == tuple: mapp, getitems = mapp else: getitems = lambda m: m.items() # def getitems(m): return m.items() return mapp, getitems def __getitem__(self, key): return self.__dict__[key] def __setitem__(self, key, val): self.__dict__[key] = val def __len__(self): return len(self.__dict__) def __call__(self, *keys): '''slicing interface gimmicky but useful, and doesnt pollute key namespace >>> b=Bag(a=1,b=2) >>> assert b('a','b')==(1,2) ''' return tuple(self.__dict__[k] for k in keys) def clear(self): self.__dict__={} def update(self, *maps): ''' >>> b=Bag(a=1,b=2) >>> b.update(Bag(a=1,b=1,c=0)) Bag({'a': 1, 'b': 1, 'c': 0}) ''' for mapp in maps: mapp, getitems = self._getGetitems(mapp) for k, v in getitems(mapp): self.__dict__[k] = v return self def __add__(self, *maps): self.__iadd__(*maps) return self def __iadd__(self, *maps): ''' >>> b=Bag(a=1,b=2) >>> b+=Bag(a=1,b=1,c=0) >>> assert b('a','b','c')==(2,3,0) >>> b=Bag(a='1',b='2') >>> b+=Bag(a='1',b='1',c='0') >>> assert b('a','b','c')==('11','21','0') ''' # todo error for empty maps[0] zero = type(list(maps[0].values())[0])() for mapp in maps: mapp, getitems = self._getGetitems(mapp) for k, v in getitems(mapp): self.__dict__.setdefault(k, zero) self.__dict__[k] += v return self def __iter__(self): return self.iterkeys() def iterkeys(self): return iter(self.__dict__.keys()) def keys(self): return self.__dict__.keys() def values(self): return self.__dict__.values() def items(self): return self.__dict__.items() def iteritems(self): return self.__dict__.iteritems() def get(self, key, dflt=None): return self.__dict__.get(key, dflt) def __str__(self): return 'Bag(' + pf(self.__dict__) + ')' def __repr__(self): return self.__str__() ureg = UnitRegistry() # interactive use: from pint import UnitRegistry as ureg; ur=ureg(); # qq=ur.Quantity qq = ureg.Quantity def notequalpatch(self, o): return not self.__eq__(o) setattr(qq, '__ne__', notequalpatch) assert qq(1, 'mm') == qq(1, 'mm') assert not qq(1, 'mm') != qq(1, 'mm') class Qnty(qq): @classmethod def fromstring(cls, s): ''' >>> Qnty.fromstring('25.4mm') <Quantity(25.4, 'millimeter')> ''' if ' ' in s: qnty, unit = s.split() else: m = re.match(r'([\d\.\-]+)(\w+)', s) if m: qnty, unit = m.groups() else: raise Exception('unsupported Qnty format [%s]' % (s)) if '.' in qnty: qnty = float(qnty) else: qnty = int(qnty) unit = { 'pt': 'printers_point', 'in': 'inch', }.get(unit, unit) return Qnty(qnty, unit) def __hash__(self): return hash(repr(self)) def playQnty(): # pagewidth=Qnty(page.cropbox[2]-page.cropbox[0],'printers_point') a = Qnty.fromstring('2in') b = Qnty.fromstring('1in') print(Qnty(a - b, 'printers_point')) print(Qnty.fromstring('72pt')) # cumColWidths=[sum(columnWidths[0:i],Qnty(0,columnWidths[0].units)) for i # in range(len(columnWidths))] print(Qnty(0, a.units)) # maxh=max([Qnty.fromstring(c.attrib.get('h',c.attrib.get('minH'))) for c # in cells]) print(max(a, b)) s = set() s.update([a, b]) assert len(s) == 1 def nth(n): ''' >>> nth(2) '2nd' >>> nth(21) '21st' >>> nth('22') '22nd' >>> nth(23) '23rd' >>> nth(24) '24th' >>> nth(12) '12th' ''' n = str(n) suffix = 'th' if n[-1] == '1' and n[-2:] != '11': suffix = 'st' elif n[-1] == '2' and n[-2:] != '12': suffix = 'nd' elif n[-1] == '3' and n[-2:] != '13': suffix = 'rd' return n + suffix def skip(s, substr): ''' >>> skip('0123456789','45') '6789' ''' idx = s.index(substr) return s[idx + len(substr):] def until(s, substr): ''' >>> until('0123456789','45') '0123' ''' try: idx = s.index(substr) return s[:idx] except ValueError: return s def ensure_dir(folder): '''ensure that directory exists''' if not exists(folder): os.makedirs(folder) def now(format=None): dt = datetime.now() if format is None: return dt.isoformat() return dt.strftime(format) def readImgSize(fname, dirName): from PIL import Image with open(pathjoin(dirName,fname), 'rb') as fh: img = Image.open(fh) imgw, imgh = img.size return imgw, imgh def asciiOnly(s): if s: s=''.join(c for c in s if ord(c)<127) return s if __name__ == "__main__": args = sys.argv[1:] if any('T' in arg for arg in args): verbose = any('v' in arg for arg in args) import doctest doctest.testmod(verbose=verbose)

agpl-3.0

sbailey/redrock

py/redrock/fitz.py

1

7113

""" redrock.fitz ============ Functions for fitting minima of chi^2 results. """ from __future__ import absolute_import, division, print_function import numpy as np import scipy.constants import scipy.special from . import constants from .rebin import rebin_template from .zscan import calc_zchi2_one, spectral_data from .zwarning import ZWarningMask as ZW from .utils import transmission_Lyman def get_dv(z, zref): """Returns velocity difference in km/s for two redshifts Args: z (float): redshift for comparison. zref (float): reference redshift. Returns: (float): the velocity difference. """ c = (scipy.constants.speed_of_light/1000.) #- km/s dv = c * (z - zref) / (1.0 + zref) return dv def find_minima(x): """Return indices of local minima of x, including edges. The indices are sorted small to large. Note: this is somewhat conservative in the case of repeated values: find_minima([1,1,1,2,2,2]) -> [0,1,2,4,5] Args: x (array-like): The data array. Returns: (array): The indices. """ x = np.asarray(x) ii = np.where(np.r_[True, x[1:]<=x[:-1]] & np.r_[x[:-1]<=x[1:], True])[0] jj = np.argsort(x[ii]) return ii[jj] def minfit(x, y): """Fits y = y0 + ((x-x0)/xerr)**2 See redrock.zwarning.ZWarningMask.BAD_MINFIT for zwarn failure flags Args: x (array): x values. y (array): y values. Returns: (tuple): (x0, xerr, y0, zwarn) where zwarn=0 is good fit. """ if len(x) < 3: return (-1,-1,-1,ZW.BAD_MINFIT) try: #- y = a x^2 + b x + c a,b,c = np.polyfit(x,y,2) except np.linalg.LinAlgError: return (-1,-1,-1,ZW.BAD_MINFIT) if a == 0.0: return (-1,-1,-1,ZW.BAD_MINFIT) #- recast as y = y0 + ((x-x0)/xerr)^2 x0 = -b / (2*a) y0 = -(b**2) / (4*a) + c zwarn = 0 if (x0 <= np.min(x)) or (np.max(x) <= x0): zwarn |= ZW.BAD_MINFIT if (y0<=0.): zwarn |= ZW.BAD_MINFIT if a > 0.0: xerr = 1 / np.sqrt(a) else: xerr = 1 / np.sqrt(-a) zwarn |= ZW.BAD_MINFIT return (x0, xerr, y0, zwarn) def fitz(zchi2, redshifts, spectra, template, nminima=3, archetype=None): """Refines redshift measurement around up to nminima minima. TODO: if there are fewer than nminima minima, consider padding. Args: zchi2 (array): chi^2 values for each redshift. redshifts (array): the redshift values. spectra (list): list of Spectrum objects at different wavelengths grids. template (Template): the template for this fit. nminima (int): the number of minima to consider. Returns: Table: the fit parameters for the minima. """ assert len(zchi2) == len(redshifts) nbasis = template.nbasis # Build dictionary of wavelength grids dwave = { s.wavehash:s.wave for s in spectra } if not archetype is None: # TODO: set this as a parameter deg_legendre = 3 wave = np.concatenate([ w for w in dwave.values() ]) wave_min = wave.min() wave_max = wave.max() legendre = { hs:np.array([scipy.special.legendre(i)( (w-wave_min)/(wave_max-wave_min)*2.-1. ) for i in range(deg_legendre)]) for hs, w in dwave.items() } (weights, flux, wflux) = spectral_data(spectra) results = list() for imin in find_minima(zchi2): if len(results) == nminima: break #- Skip this minimum if it is within constants.max_velo_diff km/s of a # previous one dv is in km/s zprev = np.array([tmp['z'] for tmp in results]) dv = get_dv(z=redshifts[imin],zref=zprev) if np.any(np.abs(dv) < constants.max_velo_diff): continue #- Sample more finely around the minimum ilo = max(0, imin-1) ihi = min(imin+1, len(zchi2)-1) zz = np.linspace(redshifts[ilo], redshifts[ihi], 15) nz = len(zz) zzchi2 = np.zeros(nz, dtype=np.float64) zzcoeff = np.zeros((nz, nbasis), dtype=np.float64) for i, z in enumerate(zz): binned = rebin_template(template, z, dwave) for k in list(dwave.keys()): T = transmission_Lyman(z,dwave[k]) for vect in range(binned[k].shape[1]): binned[k][:,vect] *= T zzchi2[i], zzcoeff[i] = calc_zchi2_one(spectra, weights, flux, wflux, binned) #- fit parabola to 3 points around minimum i = min(max(np.argmin(zzchi2),1), len(zz)-2) zmin, sigma, chi2min, zwarn = minfit(zz[i-1:i+2], zzchi2[i-1:i+2]) try: binned = rebin_template(template, zmin, dwave) for k in list(dwave.keys()): T = transmission_Lyman(zmin,dwave[k]) for vect in range(binned[k].shape[1]): binned[k][:,vect] *= T coeff = calc_zchi2_one(spectra, weights, flux, wflux, binned)[1] except ValueError as err: if zmin<redshifts[0] or redshifts[-1]<zmin: #- beyond redshift range can be invalid for template coeff = np.zeros(template.nbasis) zwarn |= ZW.Z_FITLIMIT zwarn |= ZW.BAD_MINFIT else: #- Unknown problem; re-raise error raise err zbest = zmin zerr = sigma #- Initial minimum or best fit too close to edge of redshift range if zbest < redshifts[1] or zbest > redshifts[-2]: zwarn |= ZW.Z_FITLIMIT if zmin < redshifts[1] or zmin > redshifts[-2]: zwarn |= ZW.Z_FITLIMIT #- parabola minimum outside fit range; replace with min of scan if zbest < zz[0] or zbest > zz[-1]: zwarn |= ZW.BAD_MINFIT imin = np.where(zbest == np.min(zbest))[0][0] zbest = zz[imin] chi2min = zzchi2[imin] #- Skip this better defined minimum if it is within #- constants.max_velo_diff km/s of a previous one zprev = np.array([tmp['z'] for tmp in results]) dv = get_dv(z=zbest, zref=zprev) if np.any(np.abs(dv) < constants.max_velo_diff): continue if archetype is None: results.append(dict(z=zbest, zerr=zerr, zwarn=zwarn, chi2=chi2min, zz=zz, zzchi2=zzchi2, coeff=coeff)) else: chi2min, coeff, fulltype = archetype.get_best_archetype(spectra,weights,flux,wflux,dwave,zbest,legendre) results.append(dict(z=zbest, zerr=zerr, zwarn=zwarn, chi2=chi2min, zz=zz, zzchi2=zzchi2, coeff=coeff, fulltype=fulltype)) #- Sort results by chi2min; detailed fits may have changed order ii = np.argsort([tmp['chi2'] for tmp in results]) results = [results[i] for i in ii] #- Convert list of dicts -> Table from astropy.table import Table results = Table(results) assert len(results) > 0 return results

bsd-3-clause

potsmaster/cinder

cinder/volume/drivers/dothill/dothill_client.py

1

12318

# Copyright 2014 Objectif Libre # Copyright 2015 DotHill Systems # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. # from hashlib import md5 import math import time from lxml import etree from oslo_log import log as logging import requests import six from cinder import exception from cinder.i18n import _LE LOG = logging.getLogger(__name__) class DotHillClient(object): def __init__(self, host, login, password, protocol, ssl_verify): self._login = login self._password = password self._base_url = "%s://%s/api" % (protocol, host) self._session_key = None self.ssl_verify = ssl_verify def _get_auth_token(self, xml): """Parse an XML authentication reply to extract the session key.""" self._session_key = None tree = etree.XML(xml) if tree.findtext(".//PROPERTY[@name='response-type']") == "success": self._session_key = tree.findtext(".//PROPERTY[@name='response']") def login(self): """Authenticates the service on the device.""" hash_ = "%s_%s" % (self._login, self._password) if six.PY3: hash_ = hash_.encode('utf-8') hash_ = md5(hash_) digest = hash_.hexdigest() url = self._base_url + "/login/" + digest try: xml = requests.get(url, verify=self.ssl_verify) except requests.exceptions.RequestException: raise exception.DotHillConnectionError self._get_auth_token(xml.text.encode('utf8')) if self._session_key is None: raise exception.DotHillAuthenticationError def _assert_response_ok(self, tree): """Parses the XML returned by the device to check the return code. Raises a DotHillRequestError error if the return code is not 0. """ return_code = tree.findtext(".//PROPERTY[@name='return-code']") if return_code and return_code != '0': raise exception.DotHillRequestError( message=tree.findtext(".//PROPERTY[@name='response']")) elif not return_code: raise exception.DotHillRequestError(message="No status found") def _build_request_url(self, path, *args, **kargs): url = self._base_url + path if kargs: url += '/' + '/'.join(["%s/%s" % (k.replace('_', '-'), v) for (k, v) in kargs.items()]) if args: url += '/' + '/'.join(args) return url def _request(self, path, *args, **kargs): """Performs an HTTP request on the device. Raises a DotHillRequestError if the device returned but the status is not 0. The device error message will be used in the exception message. If the status is OK, returns the XML data for further processing. """ url = self._build_request_url(path, *args, **kargs) headers = {'dataType': 'api', 'sessionKey': self._session_key} try: xml = requests.get(url, headers=headers, verify=self.ssl_verify) tree = etree.XML(xml.text.encode('utf8')) except Exception: raise exception.DotHillConnectionError if path == "/show/volumecopy-status": return tree self._assert_response_ok(tree) return tree def logout(self): url = self._base_url + '/exit' try: requests.get(url, verify=self.ssl_verify) return True except Exception: return False def create_volume(self, name, size, backend_name, backend_type): # NOTE: size is in this format: [0-9]+GB path_dict = {'size': size} if backend_type == "linear": path_dict['vdisk'] = backend_name else: path_dict['pool'] = backend_name self._request("/create/volume", name, **path_dict) return None def delete_volume(self, name): self._request("/delete/volumes", name) def extend_volume(self, name, added_size): self._request("/expand/volume", name, size=added_size) def create_snapshot(self, volume_name, snap_name): self._request("/create/snapshots", snap_name, volumes=volume_name) def delete_snapshot(self, snap_name): self._request("/delete/snapshot", "cleanup", snap_name) def backend_exists(self, backend_name, backend_type): try: if backend_type == "linear": path = "/show/vdisks" else: path = "/show/pools" self._request(path, backend_name) return True except exception.DotHillRequestError: return False def _get_size(self, size): return int(math.ceil(float(size) * 512 / (10 ** 9))) def backend_stats(self, backend_name, backend_type): stats = {'free_capacity_gb': 0, 'total_capacity_gb': 0} prop_list = [] if backend_type == "linear": path = "/show/vdisks" prop_list = ["size-numeric", "freespace-numeric"] else: path = "/show/pools" prop_list = ["total-size-numeric", "total-avail-numeric"] tree = self._request(path, backend_name) size = tree.findtext(".//PROPERTY[@name='%s']" % prop_list[0]) if size: stats['total_capacity_gb'] = self._get_size(size) size = tree.findtext(".//PROPERTY[@name='%s']" % prop_list[1]) if size: stats['free_capacity_gb'] = self._get_size(size) return stats def list_luns_for_host(self, host): tree = self._request("/show/host-maps", host) return [int(prop.text) for prop in tree.xpath( "//PROPERTY[@name='lun']")] def _get_first_available_lun_for_host(self, host): luns = self.list_luns_for_host(host) lun = 1 while True: if lun not in luns: return lun lun += 1 def map_volume(self, volume_name, connector, connector_element): if connector_element == 'wwpns': lun = self._get_first_available_lun_for_host(connector['wwpns'][0]) host = ",".join(connector['wwpns']) else: host = connector['initiator'] host_status = self._check_host(host) if host_status != 0: hostname = self._safe_hostname(connector['host']) self._request("/create/host", hostname, id=host) lun = self._get_first_available_lun_for_host(host) self._request("/map/volume", volume_name, lun=str(lun), host=host, access="rw") return lun def unmap_volume(self, volume_name, connector, connector_element): if connector_element == 'wwpns': host = ",".join(connector['wwpns']) else: host = connector['initiator'] self._request("/unmap/volume", volume_name, host=host) def get_active_target_ports(self): ports = [] tree = self._request("/show/ports") for obj in tree.xpath("//OBJECT[@basetype='port']"): port = {prop.get('name'): prop.text for prop in obj.iter("PROPERTY") if prop.get('name') in ["port-type", "target-id", "status"]} if port['status'] == 'Up': ports.append(port) return ports def get_active_fc_target_ports(self): return [port['target-id'] for port in self.get_active_target_ports() if port['port-type'] == "FC"] def get_active_iscsi_target_iqns(self): return [port['target-id'] for port in self.get_active_target_ports() if port['port-type'] == "iSCSI"] def copy_volume(self, src_name, dest_name, same_bknd, dest_bknd_name): self._request("/volumecopy", dest_name, dest_vdisk=dest_bknd_name, source_volume=src_name, prompt='yes') if same_bknd == 0: return count = 0 while True: tree = self._request("/show/volumecopy-status") return_code = tree.findtext(".//PROPERTY[@name='return-code']") if return_code == '0': status = tree.findtext(".//PROPERTY[@name='progress']") progress = False if status: progress = True LOG.debug("Volume copy is in progress: %s", status) if not progress: LOG.debug("Volume copy completed: %s", status) break else: if count >= 5: LOG.error(_LE('Error in copying volume: %s'), src_name) raise exception.DotHillRequestError break time.sleep(1) count += 1 time.sleep(5) def _check_host(self, host): host_status = -1 tree = self._request("/show/hosts") for prop in tree.xpath("//PROPERTY[@name='host-id' and text()='%s']" % host): host_status = 0 return host_status def _safe_hostname(self, hostname): """Modify an initiator name to match firmware requirements. Initiator name cannot include certain characters and cannot exceed 15 bytes in 'T' firmware (32 bytes in 'G' firmware). """ for ch in [',', '"', '\\', '<', '>']: if ch in hostname: hostname = hostname.replace(ch, '') index = len(hostname) if index > 15: index = 15 return hostname[:index] def get_active_iscsi_target_portals(self): # This function returns {'ip': status,} portals = {} prop = 'ip-address' tree = self._request("/show/ports") for el in tree.xpath("//PROPERTY[@name='primary-ip-address']"): prop = 'primary-ip-address' break iscsi_ips = [ip.text for ip in tree.xpath( "//PROPERTY[@name='%s']" % prop)] if not iscsi_ips: return portals for index, port_type in enumerate(tree.xpath( "//PROPERTY[@name='port-type' and text()='iSCSI']")): status = port_type.getparent().findtext("PROPERTY[@name='status']") if status == 'Up': portals[iscsi_ips[index]] = status return portals def get_chap_record(self, initiator_name): tree = self._request("/show/chap-records") for prop in tree.xpath("//PROPERTY[@name='initiator-name' and " "text()='%s']" % initiator_name): chap_secret = prop.getparent().findtext("PROPERTY[@name='initiator" "-secret']") return chap_secret def create_chap_record(self, initiator_name, chap_secret): self._request("/create/chap-record", name=initiator_name, secret=chap_secret) def get_serial_number(self): tree = self._request("/show/system") return tree.findtext(".//PROPERTY[@name='midplane-serial-number']") def get_owner_info(self, backend_name): tree = self._request("/show/vdisks", backend_name) return tree.findtext(".//PROPERTY[@name='owner']") def modify_volume_name(self, old_name, new_name): self._request("/set/volume", old_name, name=new_name) def get_volume_size(self, volume_name): tree = self._request("/show/volumes", volume_name) size = tree.findtext(".//PROPERTY[@name='size-numeric']") return self._get_size(size)

apache-2.0

cbitstech/Purple-Robot-Django

management/commands/extractors/builtin_rawlocationprobeeventlog.py

1

2943

# pylint: disable=line-too-long import datetime import psycopg2 import pytz CREATE_PROBE_TABLE_SQL = 'CREATE TABLE builtin_rawlocationprobeeventlog(id SERIAL PRIMARY KEY, user_id TEXT, guid TEXT, timestamp BIGINT, utc_logged TIMESTAMP, provider_status TEXT, log_event TEXT, satellites BIGINT);' CREATE_PROBE_USER_ID_INDEX = 'CREATE INDEX ON builtin_rawlocationprobeeventlog(user_id);' CREATE_PROBE_GUID_INDEX = 'CREATE INDEX ON builtin_rawlocationprobeeventlog(guid);' CREATE_PROBE_UTC_LOGGED_INDEX = 'CREATE INDEX ON builtin_rawlocationprobeeventlog(utc_logged);' def exists(connection_str, user_id, reading): conn = psycopg2.connect(connection_str) if probe_table_exists(conn) is False: conn.close() return False cursor = conn.cursor() cursor.execute('SELECT id FROM builtin_rawlocationprobeeventlog WHERE (user_id = %s AND guid = %s);', (user_id, reading['GUID'])) row_exists = (cursor.rowcount > 0) cursor.close() conn.close() return row_exists def probe_table_exists(conn): cursor = conn.cursor() cursor.execute('SELECT table_name FROM information_schema.tables WHERE (table_schema = \'public\' AND table_name = \'builtin_rawlocationprobeeventlog\')') table_exists = (cursor.rowcount > 0) cursor.close() return table_exists def insert(connection_str, user_id, reading, check_exists=True): conn = psycopg2.connect(connection_str) cursor = conn.cursor() if check_exists and probe_table_exists(conn) is False: cursor.execute(CREATE_PROBE_TABLE_SQL) cursor.execute(CREATE_PROBE_USER_ID_INDEX) cursor.execute(CREATE_PROBE_GUID_INDEX) cursor.execute(CREATE_PROBE_UTC_LOGGED_INDEX) conn.commit() reading_cmd = 'INSERT INTO builtin_rawlocationprobeeventlog(user_id, ' + \ 'guid, ' + \ 'timestamp, ' + \ 'utc_logged, ' + \ 'provider_status, ' + \ 'log_event, ' + \ 'satellites) VALUES (%s, %s, %s, %s, %s, %s, %s) RETURNING id;' provider_status = None satellites = None if 'PROVIDER_STATUS' in reading: provider_status = reading['PROVIDER_STATUS'] if 'satellites' in reading: satellites = reading['satellites'] cursor.execute(reading_cmd, (user_id, reading['GUID'], reading['TIMESTAMP'], datetime.datetime.fromtimestamp(reading['TIMESTAMP'], tz=pytz.utc), provider_status, reading['LOG_EVENT'], satellites)) conn.commit() cursor.close() conn.close()

gpl-3.0

cloudnull/eventlet_wsgi

example_app/app.py

1

3150

# ============================================================================= # Copyright [2014] [Kevin Carter] # License Information : # This software has no warranty, it is provided 'as is'. It is your # responsibility to validate the behavior of the routines and its accuracy # using the code provided. Consult the GNU General Public license for further # details (see GNU General Public License). # http://www.gnu.org/licenses/gpl.html # ============================================================================= # This is an example application # ============================================================================= import datetime import os import flask import ewsgi from cloudlib import parse_ini from cloudlib import logger CONFIG = parse_ini.ConfigurationSetup() try: CONFIG.load_config(name='example', path=os.getcwd()) # Load Default Configuration default_config = CONFIG.config_args(section='default') # Set the application name APPNAME = default_config.get('appname', 'example') # Store network Configuration network_config = CONFIG.config_args(section='network') # Store SSL configuration ssl_config = CONFIG.config_args(section='ssl') # Enable or disable DEBUG mode DEBUG = default_config.get('debug', False) except IOError: # If the configuration file is not present, set the two bits we need DEBUG = True APPNAME = 'example' # Load Logging LOG = logger.getLogger(APPNAME) # Load the flask APP APP = flask.Flask(APPNAME) # Enable general debugging if DEBUG is True: APP.debug = True LOG.debug(APP.logger) # Enable Application Threading APP.threaded = True # Enforce strict slashes in URI's APP.url_map.strict_slashes = False # Add Default Handling for File not found. APP.errorhandler(ewsgi.not_found) # Load the BLUEPRINT handler BLUEPRINT = flask.Blueprint blueprints = [] # Each Blueprint is essentially route. this has a name and needs to be # stored as an object which will be used as a decorator. hello_world = BLUEPRINT('hello', APPNAME) test_path = BLUEPRINT('test_path', __name__) # The decorator object is appended to the "blueprints" list and will be # used later to register ALL blueprints. blueprints.append(hello_world) blueprints.append(test_path) # This decorator loads the route and provides the allowed methods # available from within the decorator @hello_world.route('/hello', methods=['GET']) def _hello_world(): """Return 200 response on GET '/hello'.""" LOG.debug('hello world') return 'hello world. The time is [ %s ]' % datetime.datetime.utcnow(), 200 @test_path.route('/test', methods=['GET']) def _test_path(): """Return 200 response on GET '/test'.""" state = { 'Application': APPNAME, 'time': datetime.datetime.utcnow(), 'request': { 'method': flask.request.method, 'path': flask.request.path } } LOG.debug(state) return flask.jsonify({'response': state}, indent=2), 200 # Register all blueprints as found in are `list` of blueprints for blueprint in blueprints: APP.register_blueprint(blueprint=blueprint)

gpl-3.0

Codepoints/unidump

unidump/__init__.py

1

1861

#!/usr/bin/env python3 """ hexdump(1) for Unicode data """ from typing import IO from unidump.output import sanitize_char, print_line, fill_and_print from unidump.env import Env VERSION = '1.1.3' def unidump(inbytes: IO[bytes], env: Env) -> None: """take a list of bytes and print their Unicode codepoints >>> import io >>> import sys >>> from unidump.env import Env >>> _env = Env(linelength=4, output=sys.stdout) >>> unidump(io.BytesIO(b'\\x01\\xF0\\x9F\\x99\\xB8ABC'), _env) 0 0001 1F678 0041 0042 .\U0001F678AB 7 0043 C >>> unidump(io.BytesIO(b'\\xD7'), _env) 0 ?D7? X >>> _env.encoding = 'latin1' >>> unidump(io.BytesIO(b'\\xD7'), _env) 0 00D7 \u00D7 """ byteoffset = 0 bytebuffer = b'' current_line = [0, [], ''] byte = inbytes.read(1) while byte: byteoffset += 1 bytebuffer += byte try: char = bytebuffer.decode(env.encoding) except UnicodeDecodeError: next_byte = inbytes.read(1) if not next_byte or len(bytebuffer) >= 4: for i, data in enumerate(bytebuffer): current_line = ( fill_and_print(current_line, byteoffset - 4 + i, '?{:02X}?'.format(data), 'X', env) ) bytebuffer = b'' byte = next_byte continue else: current_line = ( fill_and_print(current_line, byteoffset - len(bytebuffer), '{:04X}'.format(ord(char)), sanitize_char(char), env) ) bytebuffer = b'' byte = inbytes.read(1) print_line(current_line, env)

mit

burjorjee/evolve-parities

evolveparities.py

1

5098

from contextlib import closing from matplotlib.pyplot import plot, figure, hold, axis, ylabel, xlabel, savefig, title from numpy import sort, logical_xor, transpose, logical_not from numpy.numarray.functions import cumsum, zeros from numpy.random import rand, shuffle from numpy import mod, floor import time import cloud from durus.file_storage import FileStorage from durus.connection import Connection def bitFreqVisualizer(effectiveAttrIndices, bitFreqs, gen): f = figure(1) n = len(bitFreqs) hold(False) plot(range(n), bitFreqs,'b.', markersize=10) hold(True) plot(effectiveAttrIndices, bitFreqs[effectiveAttrIndices],'r.', markersize=10) axis([0, n-1, 0, 1]) title("Generation = %s" % (gen,)) ylabel('Frequency of the Bit 1') xlabel('Locus') f.canvas.draw() f.show() def showExperimentTimeStamps(): with closing(FileStorage("results.durus")) as durus: conn = Connection(durus) return conn.get_root().keys() def neap_uga(m, n, gens, probMutation, effectiveAttrIndices, probMisclassification, bitFreqVisualizer=None): """ neap = "noisy effective attribute parity" """ pop = rand(m,n)<0.5 bitFreqHist= zeros((n,gens+1)) for t in range(gens+1): print "Generation %s" % t bitFreqs = pop.astype('float').sum(axis=0)/m bitFreqHist[:,t] = transpose(bitFreqs) if bitFreqVisualizer: bitFreqVisualizer(bitFreqs,t) fitnessVals = mod(pop[:, effectiveAttrIndices].astype('byte').sum(axis=1) + (rand(m) < probMisclassification).astype('byte'),2) totalFitness = sum (fitnessVals) cumNormFitnessVals = cumsum(fitnessVals).astype('float')/totalFitness parentIndices = zeros(2*m, dtype='int16') markers = sort(rand(2*m)) ctr = 0 for idx in xrange(2*m): while markers[idx]>cumNormFitnessVals[ctr]: ctr += 1 parentIndices[idx] = ctr shuffle(parentIndices) crossoverMasks = rand(m, n) < 0.5 newPop = zeros((m, n), dtype='bool') newPop[crossoverMasks] = pop[parentIndices[:m], :][crossoverMasks] newPop[logical_not(crossoverMasks)] = pop[parentIndices[m:], :][logical_not(crossoverMasks)] mutationMasks = rand(m, n)<probMutation pop = logical_xor(newPop,mutationMasks) return bitFreqHist[0, :], bitFreqHist[-1, :] def f(gens): k = 7 n= k + 1 effectiveAttrIndices = range(k) probMutation = 0.004 probMisclassification = 0.20 popSize = 1500 jid = cloud.call(neap_uga, **dict(m=popSize, n=n, gens=gens, probMutation=probMutation, effectiveAttrIndices=effectiveAttrIndices, probMisclassification=probMisclassification)) print "Kicked off trial %s" % jid return jid def cloud_result(jid): result = cloud.result(jid) print "Retrieved results for trial %s" % jid return result def run_trials(): numTrials = 3000 gens = 1000 from multiprocessing.pool import ThreadPool as Pool pool = Pool(50) jids = pool.map(f,[gens]*numTrials) print "Done spawning trials. Retrieving results..." results = pool.map(cloud_result, jids) firstLocusFreqsHists = zeros((numTrials,gens+1), dtype='float') lastLocusFreqsHists = zeros((numTrials,gens+1), dtype='float') print "Done retrieving results. Press Enter to serialize..." raw_input() for i, result in enumerate(results): firstLocusFreqsHists[i, :], lastLocusFreqsHists[i, :] = result with closing(FileStorage("results.durus")) as durus: conn = Connection(durus) conn.get_root()[str(int(floor(time.time())))] = (firstLocusFreqsHists, lastLocusFreqsHists) conn.commit() pool.close() pool.join() def render_results(timestamp=None): with closing(FileStorage("results.durus")) as durus: conn = Connection(durus) db = conn.get_root() if not timestamp: timestamp = sorted(db.keys())[-1] firstLocusFreqsHists, lastLocusFreqsHists = db[timestamp] print "Done deserializing results. Plotting..." x = [(2, 'First', firstLocusFreqsHists, "effective"), (3, 'Last', lastLocusFreqsHists, "non-effective")] for i, pos, freqsHists, filename in x : freqsHists = freqsHists[:,:801] f = figure(i) hold(False) plot(transpose(freqsHists), color='grey') hold(True) maxGens = freqsHists.shape[1]-1 plot([0, maxGens], [.05,.05], 'k--') plot([0, maxGens], [.95,.95], 'k--') axis([0, maxGens, 0, 1]) xlabel('Generation') ylabel('1-Frequency of the '+pos+' Locus') f.canvas.draw() f.show() savefig(filename+'.png', format='png', dpi=200) if __name__ == "__main__": cloud.start_simulator() run_trials() render_results() print "Done plotting results. Press Enter to end..." raw_input()

gpl-3.0

Royal-Society-of-New-Zealand/NZ-ORCID-Hub

orcid_api_v3/models/funding_v30.py

1

16706

# coding: utf-8 """ ORCID Member No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 OpenAPI spec version: Latest Generated by: https://github.com/swagger-api/swagger-codegen.git """ import pprint import re # noqa: F401 import six from orcid_api_v3.models.amount_v30 import AmountV30 # noqa: F401,E501 from orcid_api_v3.models.created_date_v30 import CreatedDateV30 # noqa: F401,E501 from orcid_api_v3.models.external_i_ds_v30 import ExternalIDsV30 # noqa: F401,E501 from orcid_api_v3.models.funding_contributors_v30 import FundingContributorsV30 # noqa: F401,E501 from orcid_api_v3.models.funding_title_v30 import FundingTitleV30 # noqa: F401,E501 from orcid_api_v3.models.fuzzy_date_v30 import FuzzyDateV30 # noqa: F401,E501 from orcid_api_v3.models.last_modified_date_v30 import LastModifiedDateV30 # noqa: F401,E501 from orcid_api_v3.models.organization_defined_funding_sub_type_v30 import OrganizationDefinedFundingSubTypeV30 # noqa: F401,E501 from orcid_api_v3.models.organization_v30 import OrganizationV30 # noqa: F401,E501 from orcid_api_v3.models.source_v30 import SourceV30 # noqa: F401,E501 from orcid_api_v3.models.url_v30 import UrlV30 # noqa: F401,E501 class FundingV30(object): """NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. """ """ Attributes: swagger_types (dict): The key is attribute name and the value is attribute type. attribute_map (dict): The key is attribute name and the value is json key in definition. """ swagger_types = { 'created_date': 'CreatedDateV30', 'last_modified_date': 'LastModifiedDateV30', 'source': 'SourceV30', 'put_code': 'int', 'path': 'str', 'type': 'str', 'organization_defined_type': 'OrganizationDefinedFundingSubTypeV30', 'title': 'FundingTitleV30', 'short_description': 'str', 'amount': 'AmountV30', 'url': 'UrlV30', 'start_date': 'FuzzyDateV30', 'end_date': 'FuzzyDateV30', 'external_ids': 'ExternalIDsV30', 'contributors': 'FundingContributorsV30', 'organization': 'OrganizationV30', 'visibility': 'str' } attribute_map = { 'created_date': 'created-date', 'last_modified_date': 'last-modified-date', 'source': 'source', 'put_code': 'put-code', 'path': 'path', 'type': 'type', 'organization_defined_type': 'organization-defined-type', 'title': 'title', 'short_description': 'short-description', 'amount': 'amount', 'url': 'url', 'start_date': 'start-date', 'end_date': 'end-date', 'external_ids': 'external-ids', 'contributors': 'contributors', 'organization': 'organization', 'visibility': 'visibility' } def __init__(self, created_date=None, last_modified_date=None, source=None, put_code=None, path=None, type=None, organization_defined_type=None, title=None, short_description=None, amount=None, url=None, start_date=None, end_date=None, external_ids=None, contributors=None, organization=None, visibility=None): # noqa: E501 """FundingV30 - a model defined in Swagger""" # noqa: E501 self._created_date = None self._last_modified_date = None self._source = None self._put_code = None self._path = None self._type = None self._organization_defined_type = None self._title = None self._short_description = None self._amount = None self._url = None self._start_date = None self._end_date = None self._external_ids = None self._contributors = None self._organization = None self._visibility = None self.discriminator = None if created_date is not None: self.created_date = created_date if last_modified_date is not None: self.last_modified_date = last_modified_date if source is not None: self.source = source if put_code is not None: self.put_code = put_code if path is not None: self.path = path if type is not None: self.type = type if organization_defined_type is not None: self.organization_defined_type = organization_defined_type if title is not None: self.title = title if short_description is not None: self.short_description = short_description if amount is not None: self.amount = amount if url is not None: self.url = url if start_date is not None: self.start_date = start_date if end_date is not None: self.end_date = end_date if external_ids is not None: self.external_ids = external_ids if contributors is not None: self.contributors = contributors if organization is not None: self.organization = organization if visibility is not None: self.visibility = visibility @property def created_date(self): """Gets the created_date of this FundingV30. # noqa: E501 :return: The created_date of this FundingV30. # noqa: E501 :rtype: CreatedDateV30 """ return self._created_date @created_date.setter def created_date(self, created_date): """Sets the created_date of this FundingV30. :param created_date: The created_date of this FundingV30. # noqa: E501 :type: CreatedDateV30 """ self._created_date = created_date @property def last_modified_date(self): """Gets the last_modified_date of this FundingV30. # noqa: E501 :return: The last_modified_date of this FundingV30. # noqa: E501 :rtype: LastModifiedDateV30 """ return self._last_modified_date @last_modified_date.setter def last_modified_date(self, last_modified_date): """Sets the last_modified_date of this FundingV30. :param last_modified_date: The last_modified_date of this FundingV30. # noqa: E501 :type: LastModifiedDateV30 """ self._last_modified_date = last_modified_date @property def source(self): """Gets the source of this FundingV30. # noqa: E501 :return: The source of this FundingV30. # noqa: E501 :rtype: SourceV30 """ return self._source @source.setter def source(self, source): """Sets the source of this FundingV30. :param source: The source of this FundingV30. # noqa: E501 :type: SourceV30 """ self._source = source @property def put_code(self): """Gets the put_code of this FundingV30. # noqa: E501 :return: The put_code of this FundingV30. # noqa: E501 :rtype: int """ return self._put_code @put_code.setter def put_code(self, put_code): """Sets the put_code of this FundingV30. :param put_code: The put_code of this FundingV30. # noqa: E501 :type: int """ self._put_code = put_code @property def path(self): """Gets the path of this FundingV30. # noqa: E501 :return: The path of this FundingV30. # noqa: E501 :rtype: str """ return self._path @path.setter def path(self, path): """Sets the path of this FundingV30. :param path: The path of this FundingV30. # noqa: E501 :type: str """ self._path = path @property def type(self): """Gets the type of this FundingV30. # noqa: E501 :return: The type of this FundingV30. # noqa: E501 :rtype: str """ return self._type @type.setter def type(self, type): """Sets the type of this FundingV30. :param type: The type of this FundingV30. # noqa: E501 :type: str """ if type is None: raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 allowed_values = ["GRANT", "CONTRACT", "AWARD", "SALARY_AWARD", "grant", "contract", "award", "salary-award"] # noqa: E501 if type not in allowed_values: raise ValueError( "Invalid value for `type` ({0}), must be one of {1}" # noqa: E501 .format(type, allowed_values) ) self._type = type @property def organization_defined_type(self): """Gets the organization_defined_type of this FundingV30. # noqa: E501 :return: The organization_defined_type of this FundingV30. # noqa: E501 :rtype: OrganizationDefinedFundingSubTypeV30 """ return self._organization_defined_type @organization_defined_type.setter def organization_defined_type(self, organization_defined_type): """Sets the organization_defined_type of this FundingV30. :param organization_defined_type: The organization_defined_type of this FundingV30. # noqa: E501 :type: OrganizationDefinedFundingSubTypeV30 """ self._organization_defined_type = organization_defined_type @property def title(self): """Gets the title of this FundingV30. # noqa: E501 :return: The title of this FundingV30. # noqa: E501 :rtype: FundingTitleV30 """ return self._title @title.setter def title(self, title): """Sets the title of this FundingV30. :param title: The title of this FundingV30. # noqa: E501 :type: FundingTitleV30 """ if title is None: raise ValueError("Invalid value for `title`, must not be `None`") # noqa: E501 self._title = title @property def short_description(self): """Gets the short_description of this FundingV30. # noqa: E501 :return: The short_description of this FundingV30. # noqa: E501 :rtype: str """ return self._short_description @short_description.setter def short_description(self, short_description): """Sets the short_description of this FundingV30. :param short_description: The short_description of this FundingV30. # noqa: E501 :type: str """ self._short_description = short_description @property def amount(self): """Gets the amount of this FundingV30. # noqa: E501 :return: The amount of this FundingV30. # noqa: E501 :rtype: AmountV30 """ return self._amount @amount.setter def amount(self, amount): """Sets the amount of this FundingV30. :param amount: The amount of this FundingV30. # noqa: E501 :type: AmountV30 """ self._amount = amount @property def url(self): """Gets the url of this FundingV30. # noqa: E501 :return: The url of this FundingV30. # noqa: E501 :rtype: UrlV30 """ return self._url @url.setter def url(self, url): """Sets the url of this FundingV30. :param url: The url of this FundingV30. # noqa: E501 :type: UrlV30 """ self._url = url @property def start_date(self): """Gets the start_date of this FundingV30. # noqa: E501 :return: The start_date of this FundingV30. # noqa: E501 :rtype: FuzzyDateV30 """ return self._start_date @start_date.setter def start_date(self, start_date): """Sets the start_date of this FundingV30. :param start_date: The start_date of this FundingV30. # noqa: E501 :type: FuzzyDateV30 """ self._start_date = start_date @property def end_date(self): """Gets the end_date of this FundingV30. # noqa: E501 :return: The end_date of this FundingV30. # noqa: E501 :rtype: FuzzyDateV30 """ return self._end_date @end_date.setter def end_date(self, end_date): """Sets the end_date of this FundingV30. :param end_date: The end_date of this FundingV30. # noqa: E501 :type: FuzzyDateV30 """ self._end_date = end_date @property def external_ids(self): """Gets the external_ids of this FundingV30. # noqa: E501 :return: The external_ids of this FundingV30. # noqa: E501 :rtype: ExternalIDsV30 """ return self._external_ids @external_ids.setter def external_ids(self, external_ids): """Sets the external_ids of this FundingV30. :param external_ids: The external_ids of this FundingV30. # noqa: E501 :type: ExternalIDsV30 """ self._external_ids = external_ids @property def contributors(self): """Gets the contributors of this FundingV30. # noqa: E501 :return: The contributors of this FundingV30. # noqa: E501 :rtype: FundingContributorsV30 """ return self._contributors @contributors.setter def contributors(self, contributors): """Sets the contributors of this FundingV30. :param contributors: The contributors of this FundingV30. # noqa: E501 :type: FundingContributorsV30 """ self._contributors = contributors @property def organization(self): """Gets the organization of this FundingV30. # noqa: E501 :return: The organization of this FundingV30. # noqa: E501 :rtype: OrganizationV30 """ return self._organization @organization.setter def organization(self, organization): """Sets the organization of this FundingV30. :param organization: The organization of this FundingV30. # noqa: E501 :type: OrganizationV30 """ if organization is None: raise ValueError("Invalid value for `organization`, must not be `None`") # noqa: E501 self._organization = organization @property def visibility(self): """Gets the visibility of this FundingV30. # noqa: E501 :return: The visibility of this FundingV30. # noqa: E501 :rtype: str """ return self._visibility @visibility.setter def visibility(self, visibility): """Sets the visibility of this FundingV30. :param visibility: The visibility of this FundingV30. # noqa: E501 :type: str """ allowed_values = ["LIMITED", "REGISTERED_ONLY", "PUBLIC", "PRIVATE", "public", "private", "limited", "registered-only"] # noqa: E501 if visibility not in allowed_values: raise ValueError( "Invalid value for `visibility` ({0}), must be one of {1}" # noqa: E501 .format(visibility, allowed_values) ) self._visibility = visibility def to_dict(self): """Returns the model properties as a dict""" result = {} for attr, _ in six.iteritems(self.swagger_types): value = getattr(self, attr) if isinstance(value, list): result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) elif hasattr(value, "to_dict"): result[attr] = value.to_dict() elif isinstance(value, dict): result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) else: result[attr] = value if issubclass(FundingV30, dict): for key, value in self.items(): result[key] = value return result def to_str(self): """Returns the string representation of the model""" return pprint.pformat(self.to_dict()) def __repr__(self): """For `print` and `pprint`""" return self.to_str() def __eq__(self, other): """Returns true if both objects are equal""" if not isinstance(other, FundingV30): return False return self.__dict__ == other.__dict__ def __ne__(self, other): """Returns true if both objects are not equal""" return not self == other

mit

jelly/calibre

src/calibre/utils/resources.py

1

3853

#!/usr/bin/env python2 # vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai from __future__ import with_statement __license__ = 'GPL v3' __copyright__ = '2009, Kovid Goyal <kovid@kovidgoyal.net>' __docformat__ = 'restructuredtext en' import __builtin__, sys, os from calibre import config_dir class PathResolver(object): def __init__(self): self.locations = [sys.resources_location] self.cache = {} def suitable(path): try: return os.path.exists(path) and os.path.isdir(path) and \ os.listdir(path) except: pass return False self.default_path = sys.resources_location dev_path = os.environ.get('CALIBRE_DEVELOP_FROM', None) self.using_develop_from = False if dev_path is not None: dev_path = os.path.join(os.path.abspath( os.path.dirname(dev_path)), 'resources') if suitable(dev_path): self.locations.insert(0, dev_path) self.default_path = dev_path self.using_develop_from = True user_path = os.path.join(config_dir, 'resources') self.user_path = None if suitable(user_path): self.locations.insert(0, user_path) self.user_path = user_path def __call__(self, path, allow_user_override=True): path = path.replace(os.sep, '/') key = (path, allow_user_override) ans = self.cache.get(key, None) if ans is None: for base in self.locations: if not allow_user_override and base == self.user_path: continue fpath = os.path.join(base, *path.split('/')) if os.path.exists(fpath): ans = fpath break if ans is None: ans = os.path.join(self.default_path, *path.split('/')) self.cache[key] = ans return ans _resolver = PathResolver() def get_path(path, data=False, allow_user_override=True): fpath = _resolver(path, allow_user_override=allow_user_override) if data: with open(fpath, 'rb') as f: return f.read() return fpath def get_image_path(path, data=False, allow_user_override=True): if not path: return get_path('images', allow_user_override=allow_user_override) return get_path('images/'+path, data=data, allow_user_override=allow_user_override) def js_name_to_path(name, ext='.coffee'): path = (u'/'.join(name.split('.'))) + ext d = os.path.dirname base = d(d(os.path.abspath(__file__))) return os.path.join(base, path) def _compile_coffeescript(name): from calibre.utils.serve_coffee import compile_coffeescript src = js_name_to_path(name) with open(src, 'rb') as f: cs, errors = compile_coffeescript(f.read(), src) if errors: for line in errors: print (line) raise Exception('Failed to compile coffeescript' ': %s'%src) return cs def compiled_coffeescript(name, dynamic=False): import zipfile zipf = get_path('compiled_coffeescript.zip', allow_user_override=False) with zipfile.ZipFile(zipf, 'r') as zf: if dynamic: import json existing_hash = json.loads(zf.comment or '{}').get(name + '.js') if existing_hash is not None: import hashlib with open(js_name_to_path(name), 'rb') as f: if existing_hash == hashlib.sha1(f.read()).hexdigest(): return zf.read(name + '.js') return _compile_coffeescript(name) else: return zf.read(name+'.js') __builtin__.__dict__['P'] = get_path __builtin__.__dict__['I'] = get_image_path

gpl-3.0

thaines/rfam

bin/prman_AlfParser.py

1

9166

import pyparsing as pp import re import copy class prman_AlfParser: def __init__(self): self.keywords = ['Job', 'Task', 'RemoteCmd'] def parseFile(self, fileText): commands = self.__parseCommandStructure(fileText, 0, isStart = True) #print(commands) textureCmds, Cmds, frames = self.extractCommandHierarchy(commands) return [textureCmds, Cmds, frames] def printCommands(self, cmds, currentIndent = 0): if isinstance(cmds, list): for e in cmds: self.printCommands(e, currentIndent + 1) print('---------------------') else: tabs = '' for i in range(currentIndent): tabs += '\t' print(tabs + repr(cmds)) def __matchBracket(self, str): if str[0] != '{': return None num_open = 0 for i, c in enumerate(str): if c == '{': num_open += 1 elif c == '}': num_open -= 1 if num_open == 0: return str[1:i] return None def leadingSpace(self, text): return len(text) - len(text.lstrip()) def removingLeadingNewLines(self, text): return text.lstrip('\n') def determineCommandLength(self, text): if text[0] == '\n': raise ValueError('Determine command length should never take newline as first char!') text = copy.deepcopy(text) lines = text.split('\n') lengths = [len(l) for l in lines] currentIndent = self.leadingSpace(lines[0]) extent = len(lines[0]) for i, l in enumerate(lines[1:]): if self.leadingSpace(l) != currentIndent: extent += lengths[i + 1] + 1 else: extent += lengths[i + 1] + 1 return extent return extent def extractAllArgs(self, text): currentIndent = 0 parsingBracket = False parsingSimple = False args = [] argNames = [] resultText = '' currentBracketText = '' i = 0 while i < len(text): if parsingBracket: #process indents if text[i] == '}': currentIndent -= 1 currentBracketText += text[i] if currentIndent == 0: args.append(currentBracketText[1:-1]) currentBracketText = '' parsingBracket = False currentIndent = 0 elif text[i] == '{': currentBracketText += text[i] currentIndent += 1 else: currentBracketText += text[i] elif parsingSimple: if text[i] == ' ': args.append(currentBracketText ) currentBracketText = '' parsingSimple = False else: currentBracketText += text[i] else: if text[i] == '-': counter = 1 argName = '' while True: if text[i + counter] == ' ': argNames.append(argName) if text[i + counter + 1] == '{': currentIndent = 0 parsingBracket = True i = i + counter else: parsingSimple = True i = i + counter break else: argName += text[i + counter] counter += 1 i += 1 return argNames, args, resultText def parseOptions(self, text): optsNames, opts, textWithoutOpts = self.extractAllArgs(text) result = {} for i in range(len(optsNames)): result[optsNames[i]] = opts[i] return result def parseJob(self, text): newJob = self.parseOptions(text) newJob['type'] = 'job' return newJob def parseRemoteCmd(self, text): #grab the actual command i = len(text) - 1 actualCommand = '' while i > 0: if text[i] == '}': break else: i -= 1 while i > 0: if text[i] == '{': actualCommand = text[i] + actualCommand break else: actualCommand = text[i] + actualCommand i -=1 newCmd = self.parseOptions(text[:i]) newCmd['type'] = 'remoteCommand' newCmd['command'] = actualCommand[1:-1] return newCmd def parseTask(self, text): #parse Task Name taskName = '' start = text.find('{') + 1 for i in range(start, len(text)): if text[i] == '}': break else: taskName += text[i] text = text[i+1:] newTask = self.parseOptions(text) newTask['type'] = 'task' newTask['taskName'] = taskName return newTask def __parseCommandStructure(self, text, indentLevel, isStart = False): structure = [] text = copy.deepcopy(text) if isStart: text = text[17:] starts = [text.find(k) for k in self.keywords] for i in range(len(starts)): if starts[i] < 0: starts[i] = 111111111111111111 lowestStartIdx = starts.index(min(starts)) #move back until new line startIdx = starts[lowestStartIdx] if startIdx == 111111111111111111: return None while startIdx > 0: if text[startIdx - 1] == '\t': startIdx -= 1 else: break if lowestStartIdx == 0: #Job length = self.determineCommandLength(text[startIdx:]) newItem = self.parseJob(text[startIdx+3:startIdx+length]) elif lowestStartIdx == 1: #Task length = self.determineCommandLength(text[startIdx:]) newItem = self.parseTask(text[startIdx+4:startIdx+length]) elif lowestStartIdx == 2: #RemoteCmd length = self.determineCommandLength(text[startIdx:]) newItem = self.parseRemoteCmd(text[startIdx+9:startIdx+length]) try: #why does hasattr not work here? #print('Attempting to parse subtasks') newItem['subtasks'] = self.__parseCommandStructure(self.removingLeadingNewLines(newItem['subtasks']), indentLevel+1) except: pass try: newItem['cmds'] = self.__parseCommandStructure(self.removingLeadingNewLines(newItem['cmds']), indentLevel+1) except: pass structure.append(newItem) nextCommands = self.__parseCommandStructure(text[startIdx+length:], indentLevel) if nextCommands: for c in nextCommands: structure.append(c) return structure def extractCommandsForFrame(self, task): frames = [] cmds = {} for t in task['subtasks']: subcmds = [] #extract frame index frameLinearIdx = int(t['taskName'].replace('Frame', '')) frames.append(frameLinearIdx) for t_sub in t['subtasks']: try: for c in t_sub['cmds']: subcmds.append(c) except: pass if subcmds: cmds[str(frameLinearIdx)] = subcmds return cmds, frames def extractCommandsForTexture(self, task): cmds = [] for t in task['subtasks']: try: for c in t['cmds']: cmds.append(c) except: pass return cmds def extractCommandHierarchy(self, jobs): textureCommands = [] commands = {} for j in jobs: for t in j['subtasks']: #get all texture conversion tasks if t['taskName'] == 'Job Textures': try: newCommands = self.extractCommandsForTexture(t) #textureCommands.append(newCommands) for c in newCommands: textureCommands.append(c) except: pass #get commands for all frames else: newCommands, frames = self.extractCommandsForFrame(t) commands.update(newCommands) return textureCommands, commands, frames def main(): with open('data/blue/shots/spool.alf', 'r') as myfile: data = myfile.read() parser = prman_AlfParser() textureCmds, Cmds, frames = parser.parseFile(data) print('Frames: ', frames) if __name__ == "__main__": main()

gpl-3.0

rainysia/dotfiles

doc/python/test/selenium_localchromeff_remoteIE.py

1

1961

#!/usr/bin/env python # coding=utf-8 #chrome localhost ''' import os from selenium import webdriver chromedriver = "/home/softs/selenium/chromedriver" os.environ["webdriver.chrome.driver"] = chromedriver driver = webdriver.Chrome(chromedriver) driver.get("http://baidu.com") driver.quit() ''' #firefox(iceweasel) localhost ''' import os from selenium import webdriver browser = webdriver.Firefox() browser.get('http://www.baidu.com') browser.save_screenshot('screen.png') browser.quit() ''' #remote chrome #remote IE import os # For Chinese import sys reload(sys) sys.setdefaultencoding('utf-8') from time import sleep from selenium import webdriver from selenium.webdriver.common.keys import Keys from selenium.webdriver.common.desired_capabilities import DesiredCapabilities ie_desired_cap = {'os': 'Windows', 'os_version': '2008', 'browser': 'IE', 'browser_version': '9.0', 'resolution' : '1024x768'} tommy_remote_url = 'http://192.168.85.123:4444/wd/hub' derek_remote_url = 'http://192.168.87.72:18181/wd/hub' # command_executor = 'http://USERNAME:ACCESS_KEY@hub.xxx:80/wd/hub' driver = webdriver.Remote( command_executor=derek_remote_url, desired_capabilities=ie_desired_cap) #google, name=q driver.get("http://www.baidu.com") eg_title = "百度" #有中文,需要import sys reload(sys) sys.setdefaultencoding('utf-8') print driver.title #print help(driver) try: if not eg_title in driver.title: raise Exception("Unable to load ",eg_title," page!") elem = driver.find_element_by_name("wd") elem.send_keys("domain") elem.submit() #two ways to wait, explict & implicit #WebDriverWait.until(condition-that-finds-the-element) #explict #driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS) #implicit print driver.title sleep(10) print '12345\n' except Exception, e: raise e finally: #driver.implicitly_wait(10) #driver.set_script_timeout(10) driver.quit()

mit

CanalTP/navitia

source/jormungandr/jormungandr/scenarios/tests/journey_compare_tests.py

1

43791

# Copyright (c) 2001-2014, Canal TP and/or its affiliates. All rights reserved. # # This file is part of Navitia, # the software to build cool stuff with public transport. # # Hope you'll enjoy and contribute to this project, # powered by Canal TP (www.canaltp.fr). # Help us simplify mobility and open public transport: # a non ending quest to the responsive locomotion way of traveling! # # LICENCE: This program is free software; you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # Stay tuned using # twitter @navitia # channel `#navitia` on riot https://riot.im/app/#/room/#navitia:matrix.org # https://groups.google.com/d/forum/navitia # www.navitia.io from __future__ import absolute_import, print_function, unicode_literals, division from copy import deepcopy from jormungandr.scenarios import journey_filter as jf from jormungandr.scenarios.utils import DepartureJourneySorter, ArrivalJourneySorter import navitiacommon.response_pb2 as response_pb2 from jormungandr.scenarios.new_default import sort_journeys from jormungandr.utils import str_to_time_stamp import random import itertools import functools def empty_journeys_test(): response = response_pb2.Response() sort_journeys(response, 'arrival_time', True) assert not response.journeys def different_arrival_times_test(): response = response_pb2.Response() journey1 = response.journeys.add() journey1.arrival_date_time = str_to_time_stamp("20140422T0800") journey1.duration = 5 * 60 journey1.nb_transfers = 0 journey1.sections.add() journey1.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey1.sections[0].duration = 5 * 60 journey2 = response.journeys.add() journey2.arrival_date_time = str_to_time_stamp("20140422T0758") journey2.duration = 2 * 60 journey2.nb_transfers = 0 journey2.sections.add() journey2.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey2.sections[0].duration = 2 * 60 sort_journeys(response, 'arrival_time', True) assert response.journeys[0].arrival_date_time == str_to_time_stamp("20140422T0758") assert response.journeys[1].arrival_date_time == str_to_time_stamp("20140422T0800") def different_departure_times_test(): response = response_pb2.Response() journey1 = response.journeys.add() journey1.departure_date_time = str_to_time_stamp("20140422T0800") journey1.duration = 5 * 60 journey1.nb_transfers = 0 journey1.sections.add() journey1.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey1.sections[0].duration = 5 * 60 journey2 = response.journeys.add() journey2.departure_date_time = str_to_time_stamp("20140422T0758") journey2.duration = 2 * 60 journey2.nb_transfers = 0 journey2.sections.add() journey2.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey2.sections[0].duration = 2 * 60 sort_journeys(response, 'departure_time', True) assert response.journeys[0].departure_date_time == str_to_time_stamp("20140422T0758") assert response.journeys[1].departure_date_time == str_to_time_stamp("20140422T0800") def different_duration_test(): response = response_pb2.Response() journey1 = response.journeys.add() journey1.arrival_date_time = str_to_time_stamp("20140422T0800") journey1.duration = 5 * 60 journey1.nb_transfers = 0 journey1.sections.add() journey1.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey1.sections[0].duration = 5 * 60 journey2 = response.journeys.add() journey2.arrival_date_time = str_to_time_stamp("20140422T0800") journey2.duration = 3 * 60 journey2.nb_transfers = 0 journey2.sections.add() journey2.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey2.sections[0].duration = 3 * 60 sort_journeys(response, 'arrival_time', True) assert response.journeys[0].arrival_date_time == str_to_time_stamp("20140422T0800") assert response.journeys[1].arrival_date_time == str_to_time_stamp("20140422T0800") assert response.journeys[0].duration == 3 * 60 assert response.journeys[1].duration == 5 * 60 def different_nb_transfers_test(): response = response_pb2.Response() journey1 = response.journeys.add() journey1.arrival_date_time = str_to_time_stamp("20140422T0800") journey1.duration = 25 * 60 journey1.nb_transfers = 1 journey1.sections.add() journey1.sections.add() journey1.sections.add() journey1.sections.add() journey1.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey1.sections[0].duration = 5 * 60 journey1.sections[1].type = response_pb2.TRANSFER journey1.sections[1].duration = 3 * 60 journey1.sections[2].type = response_pb2.WAITING journey1.sections[2].duration = 2 * 60 journey1.sections[3].type = response_pb2.PUBLIC_TRANSPORT journey1.sections[3].duration = 15 * 60 journey2 = response.journeys.add() journey2.arrival_date_time = str_to_time_stamp("20140422T0800") journey2.duration = 25 * 60 journey2.nb_transfers = 0 journey2.sections.add() journey2.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey2.sections[0].duration = 25 * 60 sort_journeys(response, 'arrival_time', True) assert response.journeys[0].arrival_date_time == str_to_time_stamp("20140422T0800") assert response.journeys[1].arrival_date_time == str_to_time_stamp("20140422T0800") assert response.journeys[0].duration == 25 * 60 assert response.journeys[1].duration == 25 * 60 assert response.journeys[0].nb_transfers == 0 assert response.journeys[1].nb_transfers == 1 def different_duration_non_pt_test(): response = response_pb2.Response() journey1 = response.journeys.add() journey1.arrival_date_time = str_to_time_stamp("20140422T0800") journey1.duration = 25 * 60 journey1.nb_transfers = 1 journey1.sections.add() journey1.sections.add() journey1.sections.add() journey1.sections.add() journey1.sections.add() journey1.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey1.sections[0].duration = 5 * 60 journey1.sections[1].type = response_pb2.TRANSFER journey1.sections[1].duration = 3 * 60 journey1.sections[2].type = response_pb2.WAITING journey1.sections[2].duration = 2 * 60 journey1.sections[3].type = response_pb2.PUBLIC_TRANSPORT journey1.sections[3].duration = 15 * 60 journey1.sections[4].type = response_pb2.STREET_NETWORK journey1.sections[4].duration = 10 * 60 journey2 = response.journeys.add() journey2.arrival_date_time = str_to_time_stamp("20140422T0800") journey2.duration = 25 * 60 journey2.nb_transfers = 1 journey2.sections.add() journey2.sections.add() journey2.sections.add() journey2.sections.add() journey2.sections[0].type = response_pb2.PUBLIC_TRANSPORT journey2.sections[0].duration = 5 * 60 journey2.sections[1].type = response_pb2.TRANSFER journey2.sections[1].duration = 3 * 60 journey2.sections[2].type = response_pb2.WAITING journey2.sections[2].duration = 2 * 60 journey2.sections[3].type = response_pb2.PUBLIC_TRANSPORT journey2.sections[3].duration = 15 * 60 sort_journeys(response, 'arrival_time', True) assert response.journeys[0].arrival_date_time == str_to_time_stamp("20140422T0800") assert response.journeys[1].arrival_date_time == str_to_time_stamp("20140422T0800") assert response.journeys[0].duration == 25 * 60 assert response.journeys[1].duration == 25 * 60 assert response.journeys[0].nb_transfers == 1 assert response.journeys[1].nb_transfers == 1 # We want to have journey2 in first, this is the one with 4 sections assert len(response.journeys[0].sections) == 4 assert len(response.journeys[1].sections) == 5 def create_dummy_journey(): journey = response_pb2.Journey() journey.arrival_date_time = str_to_time_stamp("20140422T0800") journey.duration = 25 * 60 journey.nb_transfers = 1 s = journey.sections.add() s.type = response_pb2.PUBLIC_TRANSPORT s.origin.uri = "stop_point_1" s.destination.uri = "stop_point_2" s.vehicle_journey.uri = "vj_toto" s.duration = 5 * 60 s = journey.sections.add() s.type = response_pb2.TRANSFER s.duration = 3 * 60 s = journey.sections.add() s.type = response_pb2.WAITING s.duration = 2 * 60 s = journey.sections.add() s.type = response_pb2.PUBLIC_TRANSPORT s.origin.uri = "stop_point_3" s.destination.uri = "stop_point_4" s.duration = 15 * 60 s = journey.sections.add() s.type = response_pb2.STREET_NETWORK s.duration = 10 * 60 return journey def journey_pairs_gen(list_responses): return itertools.combinations(jf.get_qualified_journeys(list_responses), 2) def test_get_qualified_journeys(): responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.tags.append("a_tag") journey2 = responses[0].journeys.add() journey2.tags.append("to_delete") journey3 = responses[0].journeys.add() journey3.tags.append("another_tag") journey3.tags.append("to_delete") for qualified in jf.get_qualified_journeys(responses): assert qualified.tags[0] == 'a_tag' def test_num_qualifed_journeys(): responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.tags.append("a_tag") journey2 = responses[0].journeys.add() journey2.tags.append("to_delete") journey3 = responses[0].journeys.add() journey3.tags.append("another_tag") assert jf.nb_qualifed_journeys(responses) == 2 def test_similar_journeys(): responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.sections.add() journey1.duration = 42 journey1.sections[0].uris.vehicle_journey = 'bob' journey2 = responses[0].journeys.add() journey2.sections.add() journey2.duration = 43 journey2.sections[0].uris.vehicle_journey = 'bob' jf.filter_similar_vj_journeys(list(journey_pairs_gen(responses)), {}) assert len(list(jf.get_qualified_journeys(responses))) == 1 def test_similar_journeys_test2(): responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.sections.add() journey1.duration = 42 journey1.sections[0].uris.vehicle_journey = 'bob' responses.append(response_pb2.Response()) journey2 = responses[-1].journeys.add() journey2.sections.add() journey2.duration = 43 journey2.sections[-1].uris.vehicle_journey = 'bob' jf.filter_similar_vj_journeys(list(journey_pairs_gen(responses)), {}) assert len(list(jf.get_qualified_journeys(responses))) == 1 def test_similar_journeys_test3(): responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.sections.add() journey1.duration = 42 journey1.sections[0].uris.vehicle_journey = 'bob' responses.append(response_pb2.Response()) journey2 = responses[-1].journeys.add() journey2.sections.add() journey2.duration = 43 journey2.sections[-1].uris.vehicle_journey = 'bobette' jf.filter_similar_vj_journeys(list(journey_pairs_gen(responses)), {}) assert 'to_delete' not in journey1.tags assert 'to_delete' in journey2.tags def test_similar_journeys_different_transfer(): """ If 2 journeys take the same vjs but with a different number of sections, one should be filtered """ responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.sections.add() journey1.duration = 42 journey1.sections[-1].uris.vehicle_journey = 'bob' journey1.sections.add() journey1.duration = 42 journey1.sections[-1].uris.vehicle_journey = 'bobette' responses.append(response_pb2.Response()) journey2 = responses[-1].journeys.add() journey2.sections.add() journey2.duration = 43 journey2.sections[-1].uris.vehicle_journey = 'bob' journey2.sections.add() journey2.duration = 43 journey2.sections[-1].type = response_pb2.TRANSFER journey2.sections.add() journey2.duration = 43 journey2.sections[-1].uris.vehicle_journey = 'bobette' jf.filter_similar_vj_journeys(journey_pairs_gen(responses), {}) assert 'to_delete' not in journey1.tags assert 'to_delete' in journey2.tags def test_similar_journeys_different_waiting_durations(): """ If 2 journeys take the same vj, same number of sections but with different waiting durations, filter one with smaller waiting duration """ responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.duration = 600 journey1.sections.add() journey1.sections[-1].uris.vehicle_journey = 'bob' journey1.sections[-1].duration = 200 journey1.sections.add() journey1.sections[-1].type = response_pb2.TRANSFER journey1.sections[-1].duration = 50 journey1.sections.add() journey1.sections[-1].type = response_pb2.WAITING journey1.sections[-1].duration = 150 journey1.sections.add() journey1.sections[-1].uris.vehicle_journey = 'bobette' journey1.sections[-1].duration = 200 responses.append(response_pb2.Response()) journey2 = responses[-1].journeys.add() journey2.duration = 600 journey2.sections.add() journey2.sections[-1].uris.vehicle_journey = 'bob' journey2.sections[-1].duration = 200 journey2.sections.add() journey2.sections[-1].type = response_pb2.TRANSFER journey2.sections[-1].duration = 25 journey2.sections.add() journey2.sections[-1].type = response_pb2.WAITING journey2.sections[-1].duration = 175 journey2.sections.add() journey2.sections[-1].uris.vehicle_journey = 'bobette' journey2.sections[-1].duration = 200 jf.filter_similar_vj_journeys(journey_pairs_gen(responses), {}) assert 'to_delete' not in journey2.tags assert 'to_delete' in journey1.tags def test_similar_journeys_multi_trasfer_and_different_waiting_durations(): """ If 2 journeys take the same vj, same number of sections and several waitings with different waiting durations, for each journey find "min waiting duration" keep the journey which has larger "min waiting duration" """ responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.duration = 1000 journey1.sections.add() journey1.sections[-1].uris.vehicle_journey = 'bob' journey1.sections[-1].duration = 200 journey1.sections.add() journey1.sections[-1].type = response_pb2.TRANSFER journey1.sections[-1].duration = 50 journey1.sections.add() journey1.sections[-1].type = response_pb2.WAITING journey1.sections[-1].duration = 150 journey1.sections.add() journey1.sections[-1].uris.vehicle_journey = 'bobette' journey1.sections[-1].duration = 200 journey1.sections.add() journey1.sections[-1].type = response_pb2.TRANSFER journey1.sections[-1].duration = 10 journey1.sections.add() journey1.sections[-1].type = response_pb2.WAITING journey1.sections[-1].duration = 190 journey1.sections.add() journey1.sections[-1].uris.vehicle_journey = 'boby' journey1.sections[-1].duration = 200 responses.append(response_pb2.Response()) journey2 = responses[-1].journeys.add() journey2.duration = 1000 journey2.sections.add() journey2.sections[-1].uris.vehicle_journey = 'bob' journey2.sections[-1].duration = 200 journey2.sections.add() journey2.sections[-1].type = response_pb2.TRANSFER journey2.sections[-1].duration = 20 journey2.sections.add() journey2.sections[-1].type = response_pb2.WAITING journey2.sections[-1].duration = 180 journey2.sections.add() journey2.sections[-1].uris.vehicle_journey = 'bobette' journey2.sections[-1].duration = 200 journey2.sections.add() journey2.sections[-1].type = response_pb2.TRANSFER journey2.sections[-1].duration = 100 journey2.sections.add() journey2.sections[-1].type = response_pb2.WAITING journey2.sections[-1].duration = 100 journey2.sections.add() journey2.sections[-1].uris.vehicle_journey = 'boby' journey2.sections[-1].duration = 200 jf.filter_similar_vj_journeys(list(journey_pairs_gen(responses)), {}) assert 'to_delete' not in journey1.tags assert 'to_delete' in journey2.tags def test_similar_journeys_with_and_without_waiting_section(): """ If 2 journeys take the same vj, one with a waiting section and another without, filtere one with transfer but without waiting section """ responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.duration = 600 journey1.sections.add() journey1.sections[-1].uris.vehicle_journey = 'bob' journey1.sections[-1].duration = 200 journey1.sections.add() journey1.sections[-1].type = response_pb2.TRANSFER journey1.sections[-1].duration = 50 journey1.sections.add() journey1.sections[-1].type = response_pb2.WAITING journey1.sections[-1].duration = 150 journey1.sections.add() journey1.sections[-1].uris.vehicle_journey = 'bobette' journey1.sections[-1].duration = 200 responses.append(response_pb2.Response()) journey2 = responses[-1].journeys.add() journey2.duration = 600 journey2.sections.add() journey2.sections[-1].uris.vehicle_journey = 'bob' journey2.sections[-1].duration = 200 journey2.sections.add() journey2.sections[-1].type = response_pb2.TRANSFER journey2.sections[-1].duration = 200 journey2.sections.add() journey2.sections[-1].uris.vehicle_journey = 'bobette' journey2.sections[-1].duration = 200 jf.filter_similar_vj_journeys(list(journey_pairs_gen(responses)), {}) assert 'to_delete' not in journey1.tags assert 'to_delete' in journey2.tags def test_similar_journeys_walking_bike(): """ If we have 2 direct path, one walking and one by bike, we should not filter any journey """ responses = [response_pb2.Response()] journey1 = responses[0].journeys.add() journey1.duration = 42 journey1.sections.add() journey1.sections[-1].type = response_pb2.STREET_NETWORK journey1.sections[-1].street_network.mode = response_pb2.Walking responses.append(response_pb2.Response()) journey2 = responses[-1].journeys.add() journey2.duration = 42 journey2.sections.add() journey2.sections[-1].type = response_pb2.STREET_NETWORK journey2.sections[-1].street_network.mode = response_pb2.Bike jf.filter_similar_vj_journeys(list(journey_pairs_gen(responses)), {}) assert 'to_delete' not in journey1.tags assert 'to_delete' not in journey2.tags def test_similar_journeys_car_park(): """ We have to consider a journey with CAR / PARK / WALK to be equal to CAR / PARK """ responses = [response_pb2.Response()] journey1 = response_pb2.Journey() journey1.sections.add() journey1.sections[-1].type = response_pb2.STREET_NETWORK journey1.sections[-1].street_network.mode = response_pb2.Car journey1.sections.add() journey1.sections[-1].type = response_pb2.PARK journey1.sections.add() journey1.sections[-1].type = response_pb2.STREET_NETWORK journey1.sections[-1].street_network.mode = response_pb2.Walking journey2 = response_pb2.Journey() journey2.sections.add() journey2.sections[-1].type = response_pb2.STREET_NETWORK journey2.sections[-1].street_network.mode = response_pb2.Car journey2.sections.add() journey2.sections[-1].type = response_pb2.PARK assert jf.compare(journey1, journey2, jf.similar_journeys_vj_generator) def test_similar_journeys_bss_park(): """ We have to consider a journey with WALK / GET A BIKE / BSS to be equals to GET A BIKE / BSS """ responses = [response_pb2.Response()] journey1 = response_pb2.Journey() journey1.sections.add() journey1.sections[-1].type = response_pb2.STREET_NETWORK journey1.sections[-1].street_network.mode = response_pb2.Walking journey1.sections.add() journey1.sections[-1].type = response_pb2.BSS_RENT journey1.sections.add() journey1.sections[-1].type = response_pb2.STREET_NETWORK journey1.sections[-1].street_network.mode = response_pb2.Bss journey2 = response_pb2.Journey() journey2.sections.add() journey2.sections[-1].type = response_pb2.BSS_RENT journey2.sections.add() journey2.sections[-1].type = response_pb2.STREET_NETWORK journey2.sections[-1].street_network.mode = response_pb2.Bss assert jf.compare(journey1, journey2, jf.similar_journeys_vj_generator) def test_similar_journeys_crowfly_rs(): """ We have to consider a journey with CROWFLY WALK to be different than CROWFLY Ridesharing """ journey1 = response_pb2.Journey() journey1.sections.add() journey1.sections[-1].type = response_pb2.CROW_FLY journey1.sections[-1].street_network.mode = response_pb2.Walking journey2 = response_pb2.Journey() journey2.sections.add() journey2.sections[-1].type = response_pb2.CROW_FLY journey2.sections[-1].street_network.mode = response_pb2.Ridesharing assert not jf.compare(journey1, journey2, jf.similar_journeys_vj_generator) def test_departure_sort(): """ we want to sort by departure hour, then by duration """ j1 = response_pb2.Journey() j1.departure_date_time = str_to_time_stamp('20151005T071000') j1.arrival_date_time = str_to_time_stamp('20151005T081900') j1.duration = j1.arrival_date_time - j1.departure_date_time j1.nb_transfers = 0 j2 = response_pb2.Journey() j2.departure_date_time = str_to_time_stamp('20151005T072200') j2.arrival_date_time = str_to_time_stamp('20151005T083500') j2.duration = j2.arrival_date_time - j2.departure_date_time j2.nb_transfers = 0 j3 = response_pb2.Journey() j3.departure_date_time = str_to_time_stamp('20151005T074500') j3.arrival_date_time = str_to_time_stamp('20151005T091200') j3.duration = j3.arrival_date_time - j3.departure_date_time j3.nb_transfers = 0 j4 = response_pb2.Journey() j4.departure_date_time = str_to_time_stamp('20151005T074500') j4.arrival_date_time = str_to_time_stamp('20151005T091100') j4.duration = j4.arrival_date_time - j4.departure_date_time j4.nb_transfers = 0 j5 = response_pb2.Journey() j5.departure_date_time = str_to_time_stamp('20151005T074500') j5.arrival_date_time = str_to_time_stamp('20151005T090800') j5.duration = j5.arrival_date_time - j5.departure_date_time j5.nb_transfers = 0 result = [j1, j2, j3, j4, j5] random.shuffle(result) comparator = DepartureJourneySorter(True) result.sort(key=functools.cmp_to_key(comparator)) assert result[0] == j1 assert result[1] == j2 assert result[2] == j5 assert result[3] == j4 assert result[4] == j3 def test_arrival_sort(): """ we want to sort by arrival hour, then by duration """ j1 = response_pb2.Journey() j1.departure_date_time = str_to_time_stamp('20151005T071000') j1.arrival_date_time = str_to_time_stamp('20151005T081900') j1.duration = j1.arrival_date_time - j1.departure_date_time j1.nb_transfers = 0 j2 = response_pb2.Journey() j2.departure_date_time = str_to_time_stamp('20151005T072200') j2.arrival_date_time = str_to_time_stamp('20151005T083500') j2.duration = j2.arrival_date_time - j2.departure_date_time j2.nb_transfers = 0 j3 = response_pb2.Journey() j3.departure_date_time = str_to_time_stamp('20151005T074500') j3.arrival_date_time = str_to_time_stamp('20151005T091200') j3.duration = j3.arrival_date_time - j3.departure_date_time j3.nb_transfers = 0 j4 = response_pb2.Journey() j4.departure_date_time = str_to_time_stamp('20151005T075000') j4.arrival_date_time = str_to_time_stamp('20151005T091200') j4.duration = j4.arrival_date_time - j4.departure_date_time j4.nb_transfers = 0 j5 = response_pb2.Journey() j5.departure_date_time = str_to_time_stamp('20151005T075500') j5.arrival_date_time = str_to_time_stamp('20151005T091200') j5.duration = j5.arrival_date_time - j5.departure_date_time j5.nb_transfers = 0 result = [j1, j2, j3, j4, j5] random.shuffle(result) comparator = ArrivalJourneySorter(True) result.sort(key=functools.cmp_to_key(comparator)) assert result[0] == j1 assert result[1] == j2 assert result[2] == j5 assert result[3] == j4 assert result[4] == j3 def test_heavy_journey_walking(): """ we don't filter any journey with walking """ journey = response_pb2.Journey() journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Walking journey.sections[-1].duration = 5 f = jf.FilterTooShortHeavyJourneys(min_bike=10, min_car=20) assert f.filter_func(journey) def test_heavy_journey_bike(): """ the first time the duration of the biking section is superior to the min value, so we keep the journey on the second test the duration is inferior to the min, so we delete the journey """ journey = response_pb2.Journey() journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Bike journey.durations.bike = journey.sections[-1].duration = 15 f = jf.FilterTooShortHeavyJourneys(min_bike=10, min_car=20) assert f.filter_func(journey) journey.durations.bike = journey.sections[-1].duration = 5 f = jf.FilterTooShortHeavyJourneys(min_bike=10, min_car=20, orig_modes=['bike', 'walking']) assert not f.filter_func(journey) def test_filter_wrapper(): """ Testing that filter_wrapper is fine (see filter_wrapper doc) """ class LoveHateFilter(jf.SingleJourneyFilter): message = 'i_dont_like_you' def __init__(self, love=True): self.love = love def filter_func(self, journey): return self.love ref_journey = response_pb2.Journey() # first we test when debug-mode deactivated (each time both OK-filter and KO-filter) j = deepcopy(ref_journey) wrapped_f = jf.filter_wrapper(is_debug=False, filter_obj=LoveHateFilter(love=True)) assert wrapped_f(j) assert 'to_delete' not in j.tags assert 'deleted_because_i_dont_like_you' not in j.tags j = deepcopy(ref_journey) wrapped_f = jf.filter_wrapper(is_debug=False, filter_obj=LoveHateFilter(love=False)) assert not wrapped_f(j) assert 'to_delete' in j.tags assert 'deleted_because_i_dont_like_you' not in j.tags # test using without debug mode (should be deactivated) j = deepcopy(ref_journey) wrapped_f = jf.filter_wrapper(filter_obj=LoveHateFilter(love=True)) assert wrapped_f(j) assert 'to_delete' not in j.tags assert 'deleted_because_i_dont_like_you' not in j.tags j = deepcopy(ref_journey) wrapped_f = jf.filter_wrapper(filter_obj=LoveHateFilter(love=False)) assert not wrapped_f(j) assert 'to_delete' in j.tags assert 'deleted_because_i_dont_like_you' not in j.tags # test when debug-mode is activated j = deepcopy(ref_journey) wrapped_f = jf.filter_wrapper(is_debug=True, filter_obj=LoveHateFilter(love=True)) assert wrapped_f(j) assert 'to_delete' not in j.tags assert 'deleted_because_i_dont_like_you' not in j.tags j = deepcopy(ref_journey) wrapped_f = jf.filter_wrapper(is_debug=True, filter_obj=LoveHateFilter(love=False)) assert wrapped_f(j) assert 'to_delete' in j.tags assert 'deleted_because_i_dont_like_you' in j.tags def test_heavy_journey_car(): """ the first time the duration of the car section is superior to the min value, so we keep the journey on the second test the duration is inferior to the min, so we delete the journey """ journey = response_pb2.Journey() journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Car journey.durations.car = journey.sections[-1].duration = 25 f = jf.FilterTooShortHeavyJourneys(min_bike=10, min_car=20) assert f.filter_func(journey) journey.durations.car = journey.sections[-1].duration = 15 f = jf.FilterTooShortHeavyJourneys(min_bike=10, min_car=20, orig_modes=['bike', 'walking']) assert not f.filter_func(journey) def test_heavy_journey_taxi(): """ the first time the duration of the taxi section is superior to the min value, so we keep the journey on the second test the duration is inferior to the min, so we delete the journey """ journey = response_pb2.Journey() journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Taxi journey.durations.taxi = journey.sections[-1].duration = 25 f = jf.FilterTooShortHeavyJourneys(min_bike=10, min_taxi=20) assert f.filter_func(journey) journey.durations.taxi = journey.sections[-1].duration = 15 f = jf.FilterTooShortHeavyJourneys(min_bike=10, min_taxi=20, orig_modes=['bike', 'walking']) assert not f.filter_func(journey) def test_heavy_journey_bss(): """ we should not remove any bss journey since it is already in concurrence with the walking """ journey = response_pb2.Journey() journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Walking journey.sections[-1].duration = 5 journey.sections.add() journey.sections[-1].type = response_pb2.BSS_RENT journey.sections[-1].duration = 5 journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Bike journey.sections[-1].duration = 5 journey.sections.add() journey.sections[-1].type = response_pb2.BSS_PUT_BACK journey.sections[-1].duration = 5 journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Walking journey.sections[-1].duration = 5 journey.durations.bike = 5 journey.durations.walking = 10 f = jf.FilterTooShortHeavyJourneys(min_bike=10, min_car=20) assert f.filter_func(journey) def test_activate_deactivate_min_bike(): """ A B C D *................*============================*.............* A: origin D: Destination A->B : Bike B->C : public transport C->D : Bike """ # case 1: request without origin_mode and destination_mode journey = response_pb2.Journey() journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Bike journey.sections[-1].duration = 5 journey.sections.add() journey.sections[-1].type = response_pb2.PUBLIC_TRANSPORT journey.sections[-1].street_network.mode = response_pb2.PUBLIC_TRANSPORT journey.sections[-1].duration = 35 journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Bike journey.sections[-1].duration = 7 journey.durations.bike = 12 f = jf.FilterTooShortHeavyJourneys(min_bike=10) assert f.filter_func(journey) # case 2: request without origin_mode journey.sections[-1].duration = 15 journey.durations.bike = 20 f = jf.FilterTooShortHeavyJourneys(min_bike=8, dest_modes=['bike', 'walking']) assert f.filter_func(journey) # case 3: request without destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 5 journey.durations.bike = 20 f = jf.FilterTooShortHeavyJourneys(min_bike=8, orig_modes=['bike', 'walking']) assert f.filter_func(journey) # case 4: request without walking in origin_mode journey.sections[0].duration = 5 journey.sections[-1].duration = 15 journey.durations.bike = 20 f = jf.FilterTooShortHeavyJourneys(min_bike=8, orig_modes=['bike']) assert f.filter_func(journey) # case 5: request without walking in destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 5 journey.durations.bike = 20 f = jf.FilterTooShortHeavyJourneys(min_bike=8, dest_modes=['bike']) assert f.filter_func(journey) # case 6: request with bike only in origin_mode destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 14 journey.durations.bike = 29 f = jf.FilterTooShortHeavyJourneys(min_bike=17, orig_modes=['bike'], dest_modes=['bike']) assert f.filter_func(journey) # case 7: request with walking in destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 5 journey.durations.bike = 20 f = jf.FilterTooShortHeavyJourneys(min_bike=8, dest_modes=['bike', 'walking']) assert not f.filter_func(journey) # case 8: request with walking in origin_mode journey.sections[0].duration = 5 journey.sections[-1].duration = 15 journey.durations.bike = 20 f = jf.FilterTooShortHeavyJourneys(min_bike=8, orig_modes=['bike', 'walking']) assert not f.filter_func(journey) # case 9: request with bike in origin_mode and bike, walking in destination_mode journey.sections[0].duration = 5 journey.sections[-1].duration = 7 journey.durations.bike = 12 f = jf.FilterTooShortHeavyJourneys(min_bike=8, orig_modes=['bike'], dest_modes=['bike', 'walking']) assert not f.filter_func(journey) def test_activate_deactivate_min_car(): """ A B C D *................*============================*.............* A: origin D: Destination A->B : car B->C : public transport C->D : car """ # case 1: request without origin_mode and destination_mode journey = response_pb2.Journey() journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Car journey.sections[-1].duration = 5 journey.sections.add() journey.sections[-1].type = response_pb2.PUBLIC_TRANSPORT journey.sections[-1].street_network.mode = response_pb2.PUBLIC_TRANSPORT journey.sections[-1].duration = 35 journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Car journey.sections[-1].duration = 7 journey.durations.car = 12 f = jf.FilterTooShortHeavyJourneys(min_car=10) assert f.filter_func(journey) # case 2: request without origin_mode journey.sections[-1].duration = 15 journey.durations.car = 20 f = jf.FilterTooShortHeavyJourneys(min_car=8, dest_modes=['car', 'walking']) assert f.filter_func(journey) # case 3: request without destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 5 journey.durations.car = 20 f = jf.FilterTooShortHeavyJourneys(min_car=8, orig_modes=['car', 'walking']) assert f.filter_func(journey) # case 4: request without walking in origin_mode journey.sections[0].duration = 5 journey.sections[-1].duration = 15 journey.durations.car = 20 f = jf.FilterTooShortHeavyJourneys(min_car=8, orig_modes=['car']) assert f.filter_func(journey) # case 5: request without walking in destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 5 journey.durations.car = 20 f = jf.FilterTooShortHeavyJourneys(min_car=8, dest_modes=['car']) assert f.filter_func(journey) # case 6: request with car only in origin_mode destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 14 journey.durations.car = 29 f = jf.FilterTooShortHeavyJourneys(min_car=17, orig_modes=['car'], dest_modes=['car']) assert f.filter_func(journey) # case 7: request with walking in destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 5 journey.durations.car = 20 f = jf.FilterTooShortHeavyJourneys(min_car=8, dest_modes=['car', 'walking']) assert not f.filter_func(journey) # case 8: request with walking in origin_mode journey.sections[0].duration = 5 journey.sections[-1].duration = 15 journey.durations.car = 20 f = jf.FilterTooShortHeavyJourneys(min_car=8, orig_modes=['car', 'walking']) assert not f.filter_func(journey) # case 9: request with bike in origin_mode and bike, walking in destination_mode journey.sections[0].duration = 5 journey.sections[-1].duration = 7 journey.durations.car = 12 f = jf.FilterTooShortHeavyJourneys(min_car=8, orig_modes=['car'], dest_modes=['car', 'walking']) assert not f.filter_func(journey) def test_activate_deactivate_min_taxi(): """ A B C D *................*============================*.............* A: origin D: Destination A->B : taxi B->C : public transport C->D : taxi """ # case 1: request without origin_mode and destination_mode journey = response_pb2.Journey() journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Taxi journey.sections[-1].duration = 5 journey.sections.add() journey.sections[-1].type = response_pb2.PUBLIC_TRANSPORT journey.sections[-1].street_network.mode = response_pb2.PUBLIC_TRANSPORT journey.sections[-1].duration = 35 journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Taxi journey.sections[-1].duration = 7 journey.durations.taxi = 12 f = jf.FilterTooShortHeavyJourneys(min_taxi=10) assert f.filter_func(journey) # case 2: request without origin_mode journey.sections[-1].duration = 15 journey.durations.taxi = 20 f = jf.FilterTooShortHeavyJourneys(min_taxi=8, dest_modes=['taxi', 'walking']) assert f.filter_func(journey) # case 3: request without destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 5 journey.durations.taxi = 20 f = jf.FilterTooShortHeavyJourneys(min_taxi=8, orig_modes=['taxi', 'walking']) assert f.filter_func(journey) # case 4: request without walking in origin_mode journey.sections[0].duration = 5 journey.sections[-1].duration = 15 journey.durations.taxi = 20 f = jf.FilterTooShortHeavyJourneys(min_taxi=8, orig_modes=['taxi']) assert f.filter_func(journey) # case 5: request without walking in destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 5 journey.durations.taxi = 20 f = jf.FilterTooShortHeavyJourneys(min_taxi=8, dest_modes=['taxi']) assert f.filter_func(journey) # case 6: request with taxi only in origin_mode destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 14 journey.durations.taxi = 29 f = jf.FilterTooShortHeavyJourneys(min_taxi=17, orig_modes=['taxi'], dest_modes=['taxi']) assert f.filter_func(journey) # case 7: request with walking in destination_mode journey.sections[0].duration = 15 journey.sections[-1].duration = 5 journey.durations.taxi = 20 f = jf.FilterTooShortHeavyJourneys(min_taxi=8, dest_modes=['taxi', 'walking']) assert not f.filter_func(journey) # case 8: request with walking in origin_mode journey.sections[0].duration = 5 journey.sections[-1].duration = 15 journey.durations.taxi = 20 f = jf.FilterTooShortHeavyJourneys(min_taxi=8, orig_modes=['taxi', 'walking']) assert not f.filter_func(journey) # case 9: request with bike in origin_mode and bike, walking in destination_mode journey.sections[0].duration = 5 journey.sections[-1].duration = 7 journey.durations.taxi = 12 f = jf.FilterTooShortHeavyJourneys(min_taxi=8, orig_modes=['taxi'], dest_modes=['taxi', 'walking']) assert not f.filter_func(journey) def test_filter_direct_path_mode_car(): # is_dp and not is_in_direct_path_mode_list journey = response_pb2.Journey() journey.tags.append("car") journey.tags.append("non_pt") f = jf.FilterDirectPathMode(["bike"]) assert not f.filter_func(journey) # is_dp and is_in_direct_path_mode_list journey = response_pb2.Journey() journey.tags.append("car") journey.tags.append("non_pt") f = jf.FilterDirectPathMode(["car"]) assert f.filter_func(journey) # is_dp and is_in_direct_path_mode_list journey = response_pb2.Journey() journey.tags.append("car") journey.tags.append("non_pt") f = jf.FilterDirectPathMode(["taxi", "surf", "car", "bike"]) assert f.filter_func(journey) # not is_dp and not is_in_direct_path_mode_list journey = response_pb2.Journey() journey.tags.append("car") f = jf.FilterDirectPathMode(["bike"]) assert f.filter_func(journey) # not is_dp and not is_in_direct_path_mode_list journey = response_pb2.Journey() journey.tags.append("car") f = jf.FilterDirectPathMode(["car"]) assert f.filter_func(journey) def test_heavy_journey_ridesharing(): """ the first time the duration of the ridesharing section is superior to the min value, so we keep the journey on the second test the duration is inferior to the min, so we delete the journey """ journey = response_pb2.Journey() journey.sections.add() journey.sections[-1].type = response_pb2.STREET_NETWORK journey.sections[-1].street_network.mode = response_pb2.Ridesharing journey.durations.ridesharing = journey.sections[-1].duration = 25 # Ridesharing duration is superior to min_ridesharing value so we have ridesharing section f = jf.FilterTooShortHeavyJourneys(min_ridesharing=20, orig_modes=['ridesharing', 'walking']) assert f.filter_func(journey) # Ridesharing duration is inferior to min_ridesharing value but there is no walking option # In this case we have ridesharing section journey.durations.ridesharing = journey.sections[-1].duration = 15 f = jf.FilterTooShortHeavyJourneys(min_ridesharing=20, orig_modes=['ridesharing']) assert f.filter_func(journey) # Ridesharing duration is inferior to min_ridesharing value and there is also walking option # In this case we have reject ridesharing section journey.durations.ridesharing = journey.sections[-1].duration = 15 f = jf.FilterTooShortHeavyJourneys(min_ridesharing=20, orig_modes=['ridesharing', 'walking']) assert not f.filter_func(journey)

agpl-3.0

ami/lob-python

lob/api_requestor.py

1

2714

import requests import lob import json import resource from lob import error from version import VERSION def _is_file_like(obj): """ Checks if an object is file-like enough to be sent to requests. In particular, file, StringIO and cStringIO objects are file-like. Refs http://stackoverflow.com/questions/3450857/python-determining-if-an-object-is-file-like """ return hasattr(obj, 'read') and hasattr(obj, 'seek') class APIRequestor(object): def __init__(self, key=None): self.api_key = key or lob.api_key def parse_response(self, resp): payload = json.loads(resp.content) if resp.status_code == 200: return payload elif resp.status_code == 401: raise error.AuthenticationError(payload['errors'][0]['message'], resp.content, resp.status_code, resp) elif resp.status_code in [404, 422]: raise error.InvalidRequestError(payload['errors'][0]['message'], resp.content, resp.status_code, resp) else: #pragma: no cover raise error.APIError(payload['errors'][0]['message'], resp.content, resp.status_code, resp) # pragma: no cover def request(self, method, url, params=None): headers = { 'User-Agent': 'Lob/v1 PythonBindings/%s' % VERSION } if hasattr(lob, 'api_version'): headers['Lob-Version'] = lob.api_version if method == 'get': return self.parse_response( requests.get(lob.api_base + url, auth=(self.api_key, ''), params=params, headers=headers) ) elif method == 'delete': return self.parse_response( requests.delete(lob.api_base + url, auth=(self.api_key, ''), headers=headers) ) elif method == 'post': data = {} files = params.pop('files', {}) explodedParams = {} for k,v in params.iteritems(): if isinstance(v, dict) and not isinstance(v, resource.LobObject): for k2,v2 in v.iteritems(): explodedParams[k + '[' + k2 + ']'] = v2 else: explodedParams[k] = v for k,v in explodedParams.iteritems(): if _is_file_like(v): files[k] = v else: if isinstance(v, resource.LobObject): data[k] = v.id else: data[k] = v return self.parse_response( requests.post(lob.api_base + url, auth=(self.api_key, ''), data=data, files=files, headers=headers) )

mit

castedo/celauth

celauth/providers.py

1

4151

import urlparse from openid.consumer import consumer from openid.extensions import sreg, ax from celauth import OpenIDCase from celauth.dj.celauth.openid_store import DjangoOpenIDStore class OpenIDChoices(object): def __init__(self, data): self.data = data def ids(self, id_prefix=''): return [id_prefix + x[0] for x in self.data] def texts(self): return [x[1] for x in self.data] def urls_by_id(self, id_prefix=''): return dict( (id_prefix + x[0], x[2]) for x in self.data ) OPENID_PROVIDERS = OpenIDChoices([ ('google', 'Google', 'https://www.google.com/accounts/o8/id'), ('yahoo', 'Yahoo!', 'https://me.yahoo.com/'), ('aol', 'AOL', 'https://openid.aol.com/'), ('stackexchange', 'StackExchange', 'https://openid.stackexchange.com/'), ('launchpad', 'Launchpad', 'https://login.launchpad.net/'), ('intuit', 'Intuit', 'https://openid.intuit.com/openid/xrds'), ]) class TestOpenIDHelper: def __init__(self, real): self.case = None self.real = real def initial_response(self, request, user_url, return_url): urlp = urlparse.urlparse(user_url) if urlp.netloc not in ('example.com', 'example.org', 'example.net'): return self.real.initial_response(request, user_url, return_url) if urlp.fragment: email = urlp.fragment + '@' + urlp.netloc urlp = list(urlp) urlp[5] = '' # remove fragment user_url = urlparse.ParseResult(*urlp).geturl() else: email = None self.case = OpenIDCase(user_url, user_url, email) return return_url def make_case(self, request): if not self.case: return self.real.make_case(request) ret = self.case self.case = None return ret EMAIL_AX_TYPE_URI = 'http://axschema.org/contact/email' class LiveOpenIDHelper: def _openid_consumer(self, request): openid_store = DjangoOpenIDStore() return consumer.Consumer(request.session, openid_store) def initial_response(self, request, user_url, return_url): oc = self._openid_consumer(request) openid_request = oc.begin(user_url) if openid_request.endpoint.supportsType(ax.AXMessage.ns_uri): ax_request = ax.FetchRequest() ax_request.add(ax.AttrInfo(EMAIL_AX_TYPE_URI, alias='email', required=True, )) openid_request.addExtension(ax_request) else: sreg_request = sreg.SRegRequest(required=['email'], optional=[], ) openid_request.addExtension(sreg_request) realm = request.build_absolute_uri('/') if openid_request.shouldSendRedirect(): return openid_request.redirectURL(realm, return_url) else: return openid_request.htmlMarkup(realm, return_url) def make_case(self, request): oc = self._openid_consumer(request) current_url = request.build_absolute_uri() query_params = dict(request.REQUEST.items()) response = oc.complete(query_params, current_url) if response.status == consumer.CANCEL: return "OpenID sign in cancelled" if response.status == consumer.SUCCESS: email = None sreg_response = sreg.SRegResponse.fromSuccessResponse(response) if sreg_response: email = sreg_response.get('email', None) ax_response = ax.FetchResponse.fromSuccessResponse(response) if ax_response: email = ax_response.getSingle(EMAIL_AX_TYPE_URI, email) return OpenIDCase(response.identity_url, response.getDisplayIdentifier(), email) return response.message or "Internal openid library error" #should throw exception facade = LiveOpenIDHelper() def enable_test_openids(): global facade facade = TestOpenIDHelper(facade)

mit

mjames-upc/python-awips

dynamicserialize/dstypes/com/raytheon/uf/common/site/notify/SiteActivationNotification.py

1

1716

## ## # # SOFTWARE HISTORY # # Date Ticket# Engineer Description # ------------ ---------- ----------- -------------------------- # 09/10/14 #3623 randerso Manually created, do not regenerate # ## class SiteActivationNotification(object): def __init__(self): self.type = None self.status = None self.primarySite = None self.modifiedSite = None self.runMode = None self.serverName = None self.pluginName = None def getType(self): return self.type def setType(self, type): self.type = type def getStatus(self): return self.status def setStatus(self, status): self.status = status def getPrimarySite(self): return self.primarysite def setPrimarySite(self, primarysite): self.primarysite = primarysite def getModifiedSite(self): return self.modifiedSite def setModifiedSite(self, modifiedSite): self.modifiedSite = modifiedSite def getRunMode(self): return self.runMode def setRunMode(self, runMode): self.runMode = runMode def getServerName(self): return self.serverName def setServerName(self, serverName): self.serverName = serverName def getPluginName(self): return self.pluginName def setPluginName(self, pluginName): self.pluginName = pluginName def __str__(self): return self.pluginName.upper() + ":" \ + self.status + ":" \ + self.type + " " \ + self.modifiedSite.upper() + " on " \ + self.serverName + ":" \ + self.runMode

bsd-3-clause

reybalgs/PyRecipe-4-U

models/recipemodel.py

1

3188

############################################################################### # # recipemodel.py # # Provides the class model for a recipe. The class model is passed around in # the application proper. # ############################################################################### import simplejson as json class RecipeModel(): def export_recipe(self): """ This function exports the current recipe object as a JSON-encoded recipe (.rcpe) file. Actually just returns a JSON-encoded string """ # Dump the object into a JSON-formatted string json_recipe = json.dumps({"name":self.name,"course":self.course, "serving_size":self.servingSize,"ingredients":self.ingredients, "instructions":self.instructions,"images":self.images}, separators=(',',':')) # Return the string return json_recipe def import_recipe(self, raw_json): """ Parses a JSON-encoded .rcpe file and then sets it to itself. The string containing the [contents] of the JSON file is passed into this function. """ # Put the decoded JSON string into a "raw" recipe object raw_recipe = json.loads(raw_json) print raw_recipe # print it for now self.name = raw_recipe['name'] self.course = raw_recipe['course'] self.servingSize = raw_recipe['serving_size'] self.ingredients = raw_recipe['ingredients'] self.instructions = raw_recipe['instructions'] self.images = raw_recipe['images'] def print_recipe_information(self): """ A useful debugging function that prints the entirety of the recipe """ # Print basic information print '\nName: ' + self.name print 'Course: ' + self.course print 'Serving Size: ' + str(self.servingSize) # Print the ingredients print '\nIngredients:' if len(self.ingredients) == 0: print 'No ingredients.' else: for ingredient in self.ingredients: print(ingredient['name'] + str(ingredient['quantity']) + ingredient['unit']) # Print the instructions print '\nInstructions:' if len(self.instructions) == 0: print 'No instructions.' else: for instruction in self.instructions: print instruction # Print the filepaths of the images print '\nImage paths:' if len(self.images) == 0: print 'No images.' else: for filePath in self.images: print filePath def get_recipe(self, recipe): """ Assigns a given recipe to this recipe. """ self.name = recipe.name self.course = recipe.course self.servingSize = recipe.servingSize self.ingredients = recipe.ingredients self.instructions = recipe.instructions def __init__(self): self.name = 'noname' self.course = 'none' self.servingSize = 0 self.ingredients = [] self.instructions = [] self.images = []

gpl-3.0

rbuffat/pyidf

tests/test_controllerwatercoil.py

1

2641

import os import tempfile import unittest import logging from pyidf import ValidationLevel import pyidf from pyidf.idf import IDF from pyidf.controllers import ControllerWaterCoil log = logging.getLogger(__name__) class TestControllerWaterCoil(unittest.TestCase): def setUp(self): self.fd, self.path = tempfile.mkstemp() def tearDown(self): os.remove(self.path) def test_create_controllerwatercoil(self): pyidf.validation_level = ValidationLevel.error obj = ControllerWaterCoil() # alpha var_name = "Name" obj.name = var_name # alpha var_control_variable = "Temperature" obj.control_variable = var_control_variable # alpha var_action = "Normal" obj.action = var_action # alpha var_actuator_variable = "Flow" obj.actuator_variable = var_actuator_variable # node var_sensor_node_name = "node|Sensor Node Name" obj.sensor_node_name = var_sensor_node_name # node var_actuator_node_name = "node|Actuator Node Name" obj.actuator_node_name = var_actuator_node_name # real var_controller_convergence_tolerance = 7.7 obj.controller_convergence_tolerance = var_controller_convergence_tolerance # real var_maximum_actuated_flow = 8.8 obj.maximum_actuated_flow = var_maximum_actuated_flow # real var_minimum_actuated_flow = 9.9 obj.minimum_actuated_flow = var_minimum_actuated_flow idf = IDF() idf.add(obj) idf.save(self.path, check=False) with open(self.path, mode='r') as f: for line in f: log.debug(line.strip()) idf2 = IDF(self.path) self.assertEqual(idf2.controllerwatercoils[0].name, var_name) self.assertEqual(idf2.controllerwatercoils[0].control_variable, var_control_variable) self.assertEqual(idf2.controllerwatercoils[0].action, var_action) self.assertEqual(idf2.controllerwatercoils[0].actuator_variable, var_actuator_variable) self.assertEqual(idf2.controllerwatercoils[0].sensor_node_name, var_sensor_node_name) self.assertEqual(idf2.controllerwatercoils[0].actuator_node_name, var_actuator_node_name) self.assertAlmostEqual(idf2.controllerwatercoils[0].controller_convergence_tolerance, var_controller_convergence_tolerance) self.assertAlmostEqual(idf2.controllerwatercoils[0].maximum_actuated_flow, var_maximum_actuated_flow) self.assertAlmostEqual(idf2.controllerwatercoils[0].minimum_actuated_flow, var_minimum_actuated_flow)

apache-2.0

macosforge/ccs-calendarserver

txdav/caldav/datastore/scheduling/ischedule/remoteservers.py

1

6936

## # Copyright (c) 2006-2017 Apple Inc. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ## from twext.python.filepath import CachingFilePath as FilePath from twext.python.log import Logger from twistedcaldav.config import config, fullServerPath from twistedcaldav import xmlutil """ XML based iSchedule configuration file handling. This is for handling of remote servers. The localservers.py module handles servers that are local (podded). """ __all__ = [ "IScheduleServers", ] log = Logger() class IScheduleServers(object): _fileInfo = None _xmlFile = None _servers = None _domainMap = None def __init__(self): if IScheduleServers._servers is None: self._loadConfig() def _loadConfig(self): if config.Scheduling.iSchedule.RemoteServers: if IScheduleServers._servers is None: IScheduleServers._xmlFile = FilePath( fullServerPath( config.ConfigRoot, config.Scheduling.iSchedule.RemoteServers, ) ) if IScheduleServers._xmlFile.exists(): IScheduleServers._xmlFile.restat() fileInfo = (IScheduleServers._xmlFile.getmtime(), IScheduleServers._xmlFile.getsize()) if fileInfo != IScheduleServers._fileInfo: parser = IScheduleServersParser(IScheduleServers._xmlFile) IScheduleServers._servers = parser.servers self._mapDomains() IScheduleServers._fileInfo = fileInfo else: IScheduleServers._servers = () IScheduleServers._domainMap = {} else: IScheduleServers._servers = () IScheduleServers._domainMap = {} def _mapDomains(self): IScheduleServers._domainMap = {} for server in IScheduleServers._servers: for domain in server.domains: IScheduleServers._domainMap[domain] = server def mapDomain(self, domain): """ Map a calendar user address domain to a suitable server that can handle server-to-server requests for that user. """ return IScheduleServers._domainMap.get(domain) ELEMENT_SERVERS = "servers" ELEMENT_SERVER = "server" ELEMENT_URI = "uri" ELEMENT_AUTHENTICATION = "authentication" ATTRIBUTE_TYPE = "type" ATTRIBUTE_BASICAUTH = "basic" ELEMENT_USER = "user" ELEMENT_PASSWORD = "password" ELEMENT_ALLOW_REQUESTS_FROM = "allow-requests-from" ELEMENT_ALLOW_REQUESTS_TO = "allow-requests-to" ELEMENT_DOMAINS = "domains" ELEMENT_DOMAIN = "domain" ELEMENT_CLIENT_HOSTS = "hosts" ELEMENT_HOST = "host" class IScheduleServersParser(object): """ Server-to-server configuration file parser. """ def __repr__(self): return "<{} {}>".format(self.__class__.__name__, self.xmlFile) def __init__(self, xmlFile): self.servers = [] # Read in XML _ignore_etree, servers_node = xmlutil.readXML(xmlFile.path, ELEMENT_SERVERS) self._parseXML(servers_node) def _parseXML(self, node): """ Parse the XML root node from the server-to-server configuration document. @param node: the L{Node} to parse. """ for child in node: if child.tag == ELEMENT_SERVER: self.servers.append(IScheduleServerRecord()) self.servers[-1].parseXML(child) class IScheduleServerRecord (object): """ Contains server-to-server details. """ def __init__(self, uri=None, rewriteCUAddresses=True, moreHeaders=[], podding=False): """ @param recordType: record type for directory entry. """ self.uri = "" self.authentication = None self.allow_from = False self.allow_to = True self.domains = [] self.client_hosts = [] self.rewriteCUAddresses = rewriteCUAddresses self.moreHeaders = moreHeaders self._podding = podding if uri: self.uri = uri self._parseDetails() def details(self): return (self.ssl, self.host, self.port, self.path,) def podding(self): return self._podding def redirect(self, location): """ Permanent redirect for the lifetime of this record. """ self.uri = location self._parseDetails() def parseXML(self, node): for child in node: if child.tag == ELEMENT_URI: self.uri = child.text elif child.tag == ELEMENT_AUTHENTICATION: self._parseAuthentication(child) elif child.tag == ELEMENT_ALLOW_REQUESTS_FROM: self.allow_from = True elif child.tag == ELEMENT_ALLOW_REQUESTS_TO: self.allow_to = True elif child.tag == ELEMENT_DOMAINS: self._parseList(child, ELEMENT_DOMAIN, self.domains) elif child.tag == ELEMENT_CLIENT_HOSTS: self._parseList(child, ELEMENT_HOST, self.client_hosts) else: raise RuntimeError("[{}] Unknown attribute: {}".format(self.__class__, child.tag,)) self._parseDetails() def _parseList(self, node, element_name, appendto): for child in node: if child.tag == element_name: appendto.append(child.text) def _parseAuthentication(self, node): if node.get(ATTRIBUTE_TYPE) != ATTRIBUTE_BASICAUTH: return for child in node: if child.tag == ELEMENT_USER: user = child.text elif child.tag == ELEMENT_PASSWORD: password = child.text self.authentication = ("basic", user, password,) def _parseDetails(self): # Extract scheme, host, port and path if self.uri.startswith("http://"): self.ssl = False rest = self.uri[7:] elif self.uri.startswith("https://"): self.ssl = True rest = self.uri[8:] splits = rest.split("/", 1) hostport = splits[0].split(":") self.host = hostport[0] if len(hostport) > 1: self.port = int(hostport[1]) else: self.port = {False: 80, True: 443}[self.ssl] self.path = "/" if len(splits) > 1: self.path += splits[1]

apache-2.0

spencerlyon2/pygments

pygments/lexers/data.py

2

17895

# -*- coding: utf-8 -*- """ pygments.lexers.data ~~~~~~~~~~~~~~~~~~~~ Lexers for data file format. :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """ import re from pygments.lexer import RegexLexer, ExtendedRegexLexer, LexerContext, \ include, bygroups from pygments.token import Text, Comment, Keyword, Name, String, Number, \ Punctuation, Literal __all__ = ['YamlLexer', 'JsonLexer'] class YamlLexerContext(LexerContext): """Indentation context for the YAML lexer.""" def __init__(self, *args, **kwds): super(YamlLexerContext, self).__init__(*args, **kwds) self.indent_stack = [] self.indent = -1 self.next_indent = 0 self.block_scalar_indent = None class YamlLexer(ExtendedRegexLexer): """ Lexer for `YAML <http://yaml.org/>`_, a human-friendly data serialization language. .. versionadded:: 0.11 """ name = 'YAML' aliases = ['yaml'] filenames = ['*.yaml', '*.yml'] mimetypes = ['text/x-yaml'] def something(token_class): """Do not produce empty tokens.""" def callback(lexer, match, context): text = match.group() if not text: return yield match.start(), token_class, text context.pos = match.end() return callback def reset_indent(token_class): """Reset the indentation levels.""" def callback(lexer, match, context): text = match.group() context.indent_stack = [] context.indent = -1 context.next_indent = 0 context.block_scalar_indent = None yield match.start(), token_class, text context.pos = match.end() return callback def save_indent(token_class, start=False): """Save a possible indentation level.""" def callback(lexer, match, context): text = match.group() extra = '' if start: context.next_indent = len(text) if context.next_indent < context.indent: while context.next_indent < context.indent: context.indent = context.indent_stack.pop() if context.next_indent > context.indent: extra = text[context.indent:] text = text[:context.indent] else: context.next_indent += len(text) if text: yield match.start(), token_class, text if extra: yield match.start()+len(text), token_class.Error, extra context.pos = match.end() return callback def set_indent(token_class, implicit=False): """Set the previously saved indentation level.""" def callback(lexer, match, context): text = match.group() if context.indent < context.next_indent: context.indent_stack.append(context.indent) context.indent = context.next_indent if not implicit: context.next_indent += len(text) yield match.start(), token_class, text context.pos = match.end() return callback def set_block_scalar_indent(token_class): """Set an explicit indentation level for a block scalar.""" def callback(lexer, match, context): text = match.group() context.block_scalar_indent = None if not text: return increment = match.group(1) if increment: current_indent = max(context.indent, 0) increment = int(increment) context.block_scalar_indent = current_indent + increment if text: yield match.start(), token_class, text context.pos = match.end() return callback def parse_block_scalar_empty_line(indent_token_class, content_token_class): """Process an empty line in a block scalar.""" def callback(lexer, match, context): text = match.group() if (context.block_scalar_indent is None or len(text) <= context.block_scalar_indent): if text: yield match.start(), indent_token_class, text else: indentation = text[:context.block_scalar_indent] content = text[context.block_scalar_indent:] yield match.start(), indent_token_class, indentation yield (match.start()+context.block_scalar_indent, content_token_class, content) context.pos = match.end() return callback def parse_block_scalar_indent(token_class): """Process indentation spaces in a block scalar.""" def callback(lexer, match, context): text = match.group() if context.block_scalar_indent is None: if len(text) <= max(context.indent, 0): context.stack.pop() context.stack.pop() return context.block_scalar_indent = len(text) else: if len(text) < context.block_scalar_indent: context.stack.pop() context.stack.pop() return if text: yield match.start(), token_class, text context.pos = match.end() return callback def parse_plain_scalar_indent(token_class): """Process indentation spaces in a plain scalar.""" def callback(lexer, match, context): text = match.group() if len(text) <= context.indent: context.stack.pop() context.stack.pop() return if text: yield match.start(), token_class, text context.pos = match.end() return callback tokens = { # the root rules 'root': [ # ignored whitespaces (r'[ ]+(?=#|$)', Text), # line breaks (r'\n+', Text), # a comment (r'#[^\n]*', Comment.Single), # the '%YAML' directive (r'^%YAML(?=[ ]|$)', reset_indent(Name.Tag), 'yaml-directive'), # the %TAG directive (r'^%TAG(?=[ ]|$)', reset_indent(Name.Tag), 'tag-directive'), # document start and document end indicators (r'^(?:---|\.\.\.)(?=[ ]|$)', reset_indent(Name.Namespace), 'block-line'), # indentation spaces (r'[ ]*(?![ \t\n\r\f\v]|$)', save_indent(Text, start=True), ('block-line', 'indentation')), ], # trailing whitespaces after directives or a block scalar indicator 'ignored-line': [ # ignored whitespaces (r'[ ]+(?=#|$)', Text), # a comment (r'#[^\n]*', Comment.Single), # line break (r'\n', Text, '#pop:2'), ], # the %YAML directive 'yaml-directive': [ # the version number (r'([ ]+)([0-9]+\.[0-9]+)', bygroups(Text, Number), 'ignored-line'), ], # the %YAG directive 'tag-directive': [ # a tag handle and the corresponding prefix (r'([ ]+)(!|![0-9A-Za-z_-]*!)' r'([ ]+)(!|!?[0-9A-Za-z;/?:@&=+$,_.!~*\'()\[\]%-]+)', bygroups(Text, Keyword.Type, Text, Keyword.Type), 'ignored-line'), ], # block scalar indicators and indentation spaces 'indentation': [ # trailing whitespaces are ignored (r'[ ]*$', something(Text), '#pop:2'), # whitespaces preceeding block collection indicators (r'[ ]+(?=[?:-](?:[ ]|$))', save_indent(Text)), # block collection indicators (r'[?:-](?=[ ]|$)', set_indent(Punctuation.Indicator)), # the beginning a block line (r'[ ]*', save_indent(Text), '#pop'), ], # an indented line in the block context 'block-line': [ # the line end (r'[ ]*(?=#|$)', something(Text), '#pop'), # whitespaces separating tokens (r'[ ]+', Text), # tags, anchors and aliases, include('descriptors'), # block collections and scalars include('block-nodes'), # flow collections and quoted scalars include('flow-nodes'), # a plain scalar (r'(?=[^ \t\n\r\f\v?:,\[\]{}#&*!|>\'"%@`-]|[?:-][^ \t\n\r\f\v])', something(Name.Variable), 'plain-scalar-in-block-context'), ], # tags, anchors, aliases 'descriptors': [ # a full-form tag (r'!<[0-9A-Za-z;/?:@&=+$,_.!~*\'()\[\]%-]+>', Keyword.Type), # a tag in the form '!', '!suffix' or '!handle!suffix' (r'!(?:[0-9A-Za-z_-]+)?' r'(?:![0-9A-Za-z;/?:@&=+$,_.!~*\'()\[\]%-]+)?', Keyword.Type), # an anchor (r'&[0-9A-Za-z_-]+', Name.Label), # an alias (r'\*[0-9A-Za-z_-]+', Name.Variable), ], # block collections and scalars 'block-nodes': [ # implicit key (r':(?=[ ]|$)', set_indent(Punctuation.Indicator, implicit=True)), # literal and folded scalars (r'[|>]', Punctuation.Indicator, ('block-scalar-content', 'block-scalar-header')), ], # flow collections and quoted scalars 'flow-nodes': [ # a flow sequence (r'\[', Punctuation.Indicator, 'flow-sequence'), # a flow mapping (r'\{', Punctuation.Indicator, 'flow-mapping'), # a single-quoted scalar (r'\'', String, 'single-quoted-scalar'), # a double-quoted scalar (r'\"', String, 'double-quoted-scalar'), ], # the content of a flow collection 'flow-collection': [ # whitespaces (r'[ ]+', Text), # line breaks (r'\n+', Text), # a comment (r'#[^\n]*', Comment.Single), # simple indicators (r'[?:,]', Punctuation.Indicator), # tags, anchors and aliases include('descriptors'), # nested collections and quoted scalars include('flow-nodes'), # a plain scalar (r'(?=[^ \t\n\r\f\v?:,\[\]{}#&*!|>\'"%@`])', something(Name.Variable), 'plain-scalar-in-flow-context'), ], # a flow sequence indicated by '[' and ']' 'flow-sequence': [ # include flow collection rules include('flow-collection'), # the closing indicator (r'\]', Punctuation.Indicator, '#pop'), ], # a flow mapping indicated by '{' and '}' 'flow-mapping': [ # include flow collection rules include('flow-collection'), # the closing indicator (r'\}', Punctuation.Indicator, '#pop'), ], # block scalar lines 'block-scalar-content': [ # line break (r'\n', Text), # empty line (r'^[ ]+$', parse_block_scalar_empty_line(Text, Name.Constant)), # indentation spaces (we may leave the state here) (r'^[ ]*', parse_block_scalar_indent(Text)), # line content (r'[^\n\r\f\v]+', Name.Constant), ], # the content of a literal or folded scalar 'block-scalar-header': [ # indentation indicator followed by chomping flag (r'([1-9])?[+-]?(?=[ ]|$)', set_block_scalar_indent(Punctuation.Indicator), 'ignored-line'), # chomping flag followed by indentation indicator (r'[+-]?([1-9])?(?=[ ]|$)', set_block_scalar_indent(Punctuation.Indicator), 'ignored-line'), ], # ignored and regular whitespaces in quoted scalars 'quoted-scalar-whitespaces': [ # leading and trailing whitespaces are ignored (r'^[ ]+', Text), (r'[ ]+$', Text), # line breaks are ignored (r'\n+', Text), # other whitespaces are a part of the value (r'[ ]+', Name.Variable), ], # single-quoted scalars 'single-quoted-scalar': [ # include whitespace and line break rules include('quoted-scalar-whitespaces'), # escaping of the quote character (r'\'\'', String.Escape), # regular non-whitespace characters (r'[^ \t\n\r\f\v\']+', String), # the closing quote (r'\'', String, '#pop'), ], # double-quoted scalars 'double-quoted-scalar': [ # include whitespace and line break rules include('quoted-scalar-whitespaces'), # escaping of special characters (r'\\[0abt\tn\nvfre "\\N_LP]', String), # escape codes (r'\\(?:x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})', String.Escape), # regular non-whitespace characters (r'[^ \t\n\r\f\v\"\\]+', String), # the closing quote (r'"', String, '#pop'), ], # the beginning of a new line while scanning a plain scalar 'plain-scalar-in-block-context-new-line': [ # empty lines (r'^[ ]+$', Text), # line breaks (r'\n+', Text), # document start and document end indicators (r'^(?=---|\.\.\.)', something(Name.Namespace), '#pop:3'), # indentation spaces (we may leave the block line state here) (r'^[ ]*', parse_plain_scalar_indent(Text), '#pop'), ], # a plain scalar in the block context 'plain-scalar-in-block-context': [ # the scalar ends with the ':' indicator (r'[ ]*(?=:[ ]|:$)', something(Text), '#pop'), # the scalar ends with whitespaces followed by a comment (r'[ ]+(?=#)', Text, '#pop'), # trailing whitespaces are ignored (r'[ ]+$', Text), # line breaks are ignored (r'\n+', Text, 'plain-scalar-in-block-context-new-line'), # other whitespaces are a part of the value (r'[ ]+', Literal.Scalar.Plain), # regular non-whitespace characters (r'(?::(?![ \t\n\r\f\v])|[^ \t\n\r\f\v:])+', Literal.Scalar.Plain), ], # a plain scalar is the flow context 'plain-scalar-in-flow-context': [ # the scalar ends with an indicator character (r'[ ]*(?=[,:?\[\]{}])', something(Text), '#pop'), # the scalar ends with a comment (r'[ ]+(?=#)', Text, '#pop'), # leading and trailing whitespaces are ignored (r'^[ ]+', Text), (r'[ ]+$', Text), # line breaks are ignored (r'\n+', Text), # other whitespaces are a part of the value (r'[ ]+', Name.Variable), # regular non-whitespace characters (r'[^ \t\n\r\f\v,:?\[\]{}]+', Name.Variable), ], } def get_tokens_unprocessed(self, text=None, context=None): if context is None: context = YamlLexerContext(text, 0) return super(YamlLexer, self).get_tokens_unprocessed(text, context) class JsonLexer(RegexLexer): """ For JSON data structures. .. versionadded:: 1.5 """ name = 'JSON' aliases = ['json'] filenames = ['*.json'] mimetypes = ['application/json'] flags = re.DOTALL # integer part of a number int_part = r'-?(0|[1-9]\d*)' # fractional part of a number frac_part = r'\.\d+' # exponential part of a number exp_part = r'[eE](\+|-)?\d+' tokens = { 'whitespace': [ (r'\s+', Text), ], # represents a simple terminal value 'simplevalue': [ (r'(true|false|null)\b', Keyword.Constant), (('%(int_part)s(%(frac_part)s%(exp_part)s|' '%(exp_part)s|%(frac_part)s)') % vars(), Number.Float), (int_part, Number.Integer), (r'"(\\\\|\\"|[^"])*"', String.Double), ], # the right hand side of an object, after the attribute name 'objectattribute': [ include('value'), (r':', Punctuation), # comma terminates the attribute but expects more (r',', Punctuation, '#pop'), # a closing bracket terminates the entire object, so pop twice (r'}', Punctuation, ('#pop', '#pop')), ], # a json object - { attr, attr, ... } 'objectvalue': [ include('whitespace'), (r'"(\\\\|\\"|[^"])*"', Name.Tag, 'objectattribute'), (r'}', Punctuation, '#pop'), ], # json array - [ value, value, ... } 'arrayvalue': [ include('whitespace'), include('value'), (r',', Punctuation), (r']', Punctuation, '#pop'), ], # a json value - either a simple value or a complex value (object or array) 'value': [ include('whitespace'), include('simplevalue'), (r'{', Punctuation, 'objectvalue'), (r'\[', Punctuation, 'arrayvalue'), ], # the root of a json document whould be a value 'root': [ include('value'), ], }

bsd-2-clause

Xeralux/tensorflow

tensorflow/python/keras/_impl/keras/engine/training.py

1

72917

# Copyright 2015 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Training-related part of the Keras engine. """ from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np from tensorflow.python.eager import context from tensorflow.python.framework import ops from tensorflow.python.framework import tensor_util from tensorflow.python.keras._impl.keras import backend as K from tensorflow.python.keras._impl.keras import losses from tensorflow.python.keras._impl.keras import metrics as metrics_module from tensorflow.python.keras._impl.keras import optimizers from tensorflow.python.keras._impl.keras.engine import training_arrays from tensorflow.python.keras._impl.keras.engine import training_eager from tensorflow.python.keras._impl.keras.engine import training_generator from tensorflow.python.keras._impl.keras.engine import training_utils from tensorflow.python.keras._impl.keras.engine.base_layer import Layer from tensorflow.python.keras._impl.keras.engine.network import Network from tensorflow.python.keras._impl.keras.utils.generic_utils import slice_arrays from tensorflow.python.layers.base import _DeferredTensor from tensorflow.python.ops import array_ops from tensorflow.python.platform import tf_logging as logging from tensorflow.python.training import optimizer as tf_optimizer_module from tensorflow.python.util.tf_export import tf_export @tf_export('keras.models.Model', 'keras.Model') class Model(Network): """`Model` groups layers into an object with training and inference features. There are two ways to instantiate a `Model`: 1 - With the "functional API", where you start from `Input`, you chain layer calls to specify the model's forward pass, and finally you create your model from inputs and outputs: ```python import tensorflow as tf inputs = tf.keras.Input(shape=(3,)) x = tf.keras.layers.Dense(4, activation=tf.nn.relu)(inputs) outputs = tf.keras.layers.Dense(5, activation=tf.nn.softmax)(x) model = tf.keras.Model(inputs=inputs, outputs=outputs) ``` 2 - By subclassing the `Model` class: in that case, you should define your layers in `__init__` and you should implement the model's forward pass in `call`. ```python import tensorflow as tf class MyModel(tf.keras.Model): def __init__(self): self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu) self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax) def call(self, inputs): x = self.dense1(inputs) return self.dense2(x) model = MyModel() ``` If you subclass `Model`, you can optionally have a `training` argument (boolean) in `call`, which you can use to specify a different behavior in training and inference: ```python import tensorflow as tf class MyModel(tf.keras.Model): def __init__(self): self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu) self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax) self.dropout = tf.keras.layers.Dropout(0.5) def call(self, inputs, training=False): x = self.dense1(inputs) if training: x = self.dropout(x, training=training) return self.dense2(x) model = MyModel() ``` """ def compile(self, optimizer, loss=None, metrics=None, loss_weights=None, sample_weight_mode=None, weighted_metrics=None, target_tensors=None, **kwargs): """Configures the model for training. Arguments: optimizer: String (name of optimizer) or optimizer instance. See [optimizers](/optimizers). loss: String (name of objective function) or objective function. See [losses](/losses). If the model has multiple outputs, you can use a different loss on each output by passing a dictionary or a list of losses. The loss value that will be minimized by the model will then be the sum of all individual losses. metrics: List of metrics to be evaluated by the model during training and testing. Typically you will use `metrics=['accuracy']`. To specify different metrics for different outputs of a multi-output model, you could also pass a dictionary, such as `metrics={'output_a': 'accuracy'}`. loss_weights: Optional list or dictionary specifying scalar coefficients (Python floats) to weight the loss contributions of different model outputs. The loss value that will be minimized by the model will then be the *weighted sum* of all individual losses, weighted by the `loss_weights` coefficients. If a list, it is expected to have a 1:1 mapping to the model's outputs. If a tensor, it is expected to map output names (strings) to scalar coefficients. sample_weight_mode: If you need to do timestep-wise sample weighting (2D weights), set this to `"temporal"`. `None` defaults to sample-wise weights (1D). If the model has multiple outputs, you can use a different `sample_weight_mode` on each output by passing a dictionary or a list of modes. weighted_metrics: List of metrics to be evaluated and weighted by sample_weight or class_weight during training and testing. target_tensors: By default, Keras will create placeholders for the model's target, which will be fed with the target data during training. If instead you would like to use your own target tensors (in turn, Keras will not expect external Numpy data for these targets at training time), you can specify them via the `target_tensors` argument. It can be a single tensor (for a single-output model), a list of tensors, or a dict mapping output names to target tensors. **kwargs: These arguments are passed to `tf.Session.run`. Raises: ValueError: In case of invalid arguments for `optimizer`, `loss`, `metrics` or `sample_weight_mode`. """ loss = loss or {} if context.executing_eagerly() and not isinstance( optimizer, (tf_optimizer_module.Optimizer, optimizers.TFOptimizer)): raise ValueError('Only TF native optimizers are supported in Eager mode.') self.optimizer = optimizers.get(optimizer) self.loss = loss self.metrics = metrics or [] self.loss_weights = loss_weights if context.executing_eagerly() and sample_weight_mode is not None: raise ValueError('sample_weight_mode is not supported in Eager mode.') self.sample_weight_mode = sample_weight_mode if context.executing_eagerly() and weighted_metrics is not None: raise ValueError('weighted_metrics is not supported in Eager mode.') self.weighted_metrics = weighted_metrics if context.executing_eagerly() and target_tensors is not None: raise ValueError('target_tensors is not supported in Eager mode.') self.target_tensors = target_tensors if not self.built: # Model is not compilable because it does not know its number of inputs # and outputs, nor their shapes and names. We will compile after the first # time the model gets called on training data. return self._is_compiled = True # Prepare loss functions. if isinstance(loss, dict): for name in loss: if name not in self.output_names: raise ValueError( 'Unknown entry in loss ' 'dictionary: "' + name + '". ' 'Only expected the following keys: ' + str(self.output_names)) loss_functions = [] for name in self.output_names: if name not in loss: logging.warning( 'Output "' + name + '" missing from loss dictionary. ' 'We assume this was done on purpose, ' 'and we will not be expecting ' 'any data to be passed to "' + name + '" during training.') loss_functions.append(losses.get(loss.get(name))) elif isinstance(loss, list): if len(loss) != len(self.outputs): raise ValueError('When passing a list as loss, ' 'it should have one entry per model outputs. ' 'The model has ' + str(len(self.outputs)) + ' outputs, but you passed loss=' + str(loss)) loss_functions = [losses.get(l) for l in loss] else: loss_function = losses.get(loss) loss_functions = [loss_function for _ in range(len(self.outputs))] self.loss_functions = loss_functions weighted_losses = [training_utils.weighted_masked_objective(fn) for fn in loss_functions] skip_target_indices = [] skip_target_weighing_indices = [] self._feed_outputs = [] self._feed_output_names = [] self._feed_output_shapes = [] self._feed_loss_fns = [] for i in range(len(weighted_losses)): if weighted_losses[i] is None: skip_target_indices.append(i) skip_target_weighing_indices.append(i) # Prepare output masks. if not context.executing_eagerly(): masks = self.compute_mask(self.inputs, mask=None) if masks is None: masks = [None for _ in self.outputs] if not isinstance(masks, list): masks = [masks] # Prepare loss weights. if loss_weights is None: loss_weights_list = [1. for _ in range(len(self.outputs))] elif isinstance(loss_weights, dict): for name in loss_weights: if name not in self.output_names: raise ValueError( 'Unknown entry in loss_weights ' 'dictionary: "' + name + '". ' 'Only expected the following keys: ' + str(self.output_names)) loss_weights_list = [] for name in self.output_names: loss_weights_list.append(loss_weights.get(name, 1.)) elif isinstance(loss_weights, list): if len(loss_weights) != len(self.outputs): raise ValueError( 'When passing a list as loss_weights, ' 'it should have one entry per model output. ' 'The model has ' + str(len(self.outputs)) + ' outputs, but you passed loss_weights=' + str(loss_weights)) loss_weights_list = loss_weights else: raise TypeError('Could not interpret loss_weights argument: ' + str(loss_weights) + ' - expected a list of dicts.') self.loss_weights_list = loss_weights_list # initialization for Eager mode execution if context.executing_eagerly(): if target_tensors is not None: raise ValueError('target_tensors are not currently supported in Eager ' 'mode.') self.total_loss = None self.metrics_tensors = [] self.metrics_names = ['loss'] for i in range(len(self.outputs)): if len(self.outputs) > 1: self.metrics_names.append(self.output_names[i] + '_loss') self.nested_metrics = training_utils.collect_metrics(metrics, self.output_names) self._feed_sample_weight_modes = [] for i in range(len(self.outputs)): self._feed_sample_weight_modes.append(None) self.sample_weights = [] self.targets = [] for i in range(len(self.outputs)): self._feed_output_names.append(self.output_names[i]) self._collected_trainable_weights = self.trainable_weights return # Prepare targets of model. self.targets = [] self._feed_targets = [] if target_tensors not in (None, []): if isinstance(target_tensors, list): if len(target_tensors) != len(self.outputs): raise ValueError( 'When passing a list as `target_tensors`, ' 'it should have one entry per model output. ' 'The model has ' + str(len(self.outputs)) + ' outputs, but you passed target_tensors=' + str(target_tensors)) elif isinstance(target_tensors, dict): for name in target_tensors: if name not in self.output_names: raise ValueError( 'Unknown entry in `target_tensors` ' 'dictionary: "' + name + '". ' 'Only expected the following keys: ' + str(self.output_names)) tmp_target_tensors = [] for name in self.output_names: tmp_target_tensors.append(target_tensors.get(name, None)) target_tensors = tmp_target_tensors else: raise TypeError('Expected `target_tensors` to be ' 'a list or dict, but got:', target_tensors) for i in range(len(self.outputs)): if i in skip_target_indices: self.targets.append(None) else: shape = K.int_shape(self.outputs[i]) name = self.output_names[i] if target_tensors not in (None, []): target = target_tensors[i] else: target = None if target is None or K.is_placeholder(target): if target is None: target = K.placeholder( ndim=len(shape), name=name + '_target', sparse=K.is_sparse(self.outputs[i]), dtype=K.dtype(self.outputs[i])) self._feed_targets.append(target) self._feed_outputs.append(self.outputs[i]) self._feed_output_names.append(name) self._feed_output_shapes.append(shape) self._feed_loss_fns.append(self.loss_functions[i]) else: skip_target_weighing_indices.append(i) self.targets.append(target) # Prepare sample weights. sample_weights = [] sample_weight_modes = [] if isinstance(sample_weight_mode, dict): for name in sample_weight_mode: if name not in self.output_names: raise ValueError( 'Unknown entry in ' 'sample_weight_mode dictionary: "' + name + '". ' 'Only expected the following keys: ' + str(self.output_names)) for i, name in enumerate(self.output_names): if i in skip_target_weighing_indices: weight = None sample_weight_modes.append(None) else: if name not in sample_weight_mode: raise ValueError( 'Output "' + name + '" missing from sample_weight_modes ' 'dictionary') if sample_weight_mode.get(name) == 'temporal': weight = K.placeholder(ndim=2, name=name + '_sample_weights') sample_weight_modes.append('temporal') else: weight = K.placeholder(ndim=1, name=name + 'sample_weights') sample_weight_modes.append(None) sample_weights.append(weight) elif isinstance(sample_weight_mode, list): if len(sample_weight_mode) != len(self.outputs): raise ValueError('When passing a list as sample_weight_mode, ' 'it should have one entry per model output. ' 'The model has ' + str(len(self.outputs)) + ' outputs, but you passed ' 'sample_weight_mode=' + str(sample_weight_mode)) for i in range(len(self.output_names)): if i in skip_target_weighing_indices: weight = None sample_weight_modes.append(None) else: mode = sample_weight_mode[i] name = self.output_names[i] if mode == 'temporal': weight = K.placeholder(ndim=2, name=name + '_sample_weights') sample_weight_modes.append('temporal') else: weight = K.placeholder(ndim=1, name=name + '_sample_weights') sample_weight_modes.append(None) sample_weights.append(weight) else: for i, name in enumerate(self.output_names): if i in skip_target_weighing_indices: sample_weight_modes.append(None) sample_weights.append(None) else: if sample_weight_mode == 'temporal': sample_weights.append(array_ops.placeholder_with_default( [[1.]], shape=[None, None], name=name + '_sample_weights')) sample_weight_modes.append('temporal') else: sample_weights.append(array_ops.placeholder_with_default( [1.], shape=[None], name=name + '_sample_weights')) sample_weight_modes.append(None) self.sample_weight_modes = sample_weight_modes self._feed_sample_weight_modes = [] for i in range(len(self.outputs)): if i not in skip_target_weighing_indices: self._feed_sample_weight_modes.append(self.sample_weight_modes[i]) # Prepare metrics. self.weighted_metrics = weighted_metrics self.metrics_names = ['loss'] self.metrics_tensors = [] # Compute total loss. total_loss = None with K.name_scope('loss'): for i in range(len(self.outputs)): if i in skip_target_indices: continue y_true = self.targets[i] y_pred = self.outputs[i] weighted_loss = weighted_losses[i] sample_weight = sample_weights[i] mask = masks[i] loss_weight = loss_weights_list[i] with K.name_scope(self.output_names[i] + '_loss'): output_loss = weighted_loss(y_true, y_pred, sample_weight, mask) if len(self.outputs) > 1: self.metrics_tensors.append(output_loss) self.metrics_names.append(self.output_names[i] + '_loss') if total_loss is None: total_loss = loss_weight * output_loss else: total_loss += loss_weight * output_loss if total_loss is None: if not self.losses: raise ValueError('The model cannot be compiled ' 'because it has no loss to optimize.') else: total_loss = 0. # Add regularization penalties # and other layer-specific losses. for loss_tensor in self.losses: total_loss += loss_tensor # List of same size as output_names. # contains tuples (metrics for output, names of metrics). nested_metrics = training_utils.collect_metrics(metrics, self.output_names) nested_weighted_metrics = training_utils.collect_metrics(weighted_metrics, self.output_names) self.metrics_updates = [] self.stateful_metric_names = [] with K.name_scope('metrics'): for i in range(len(self.outputs)): if i in skip_target_indices: continue y_true = self.targets[i] y_pred = self.outputs[i] weights = sample_weights[i] output_metrics = nested_metrics[i] output_weighted_metrics = nested_weighted_metrics[i] def handle_metrics(metrics, weights=None): metric_name_prefix = 'weighted_' if weights is not None else '' for metric in metrics: if metric in ('accuracy', 'acc', 'crossentropy', 'ce'): # custom handling of accuracy/crossentropy # (because of class mode duality) output_shape = self.outputs[i].get_shape().as_list() if (output_shape[-1] == 1 or self.loss_functions[i] == losses.binary_crossentropy): # case: binary accuracy/crossentropy if metric in ('accuracy', 'acc'): metric_fn = metrics_module.binary_accuracy elif metric in ('crossentropy', 'ce'): metric_fn = metrics_module.binary_crossentropy elif self.loss_functions[ i] == losses.sparse_categorical_crossentropy: # case: categorical accuracy/crossentropy with sparse targets if metric in ('accuracy', 'acc'): metric_fn = metrics_module.sparse_categorical_accuracy elif metric in ('crossentropy', 'ce'): metric_fn = metrics_module.sparse_categorical_crossentropy else: # case: categorical accuracy/crossentropy if metric in ('accuracy', 'acc'): metric_fn = metrics_module.categorical_accuracy elif metric in ('crossentropy', 'ce'): metric_fn = metrics_module.categorical_crossentropy if metric in ('accuracy', 'acc'): suffix = 'acc' elif metric in ('crossentropy', 'ce'): suffix = 'ce' weighted_metric_fn = training_utils.weighted_masked_objective( metric_fn) metric_name = metric_name_prefix + suffix else: metric_fn = metrics_module.get(metric) weighted_metric_fn = training_utils.weighted_masked_objective( metric_fn) # Get metric name as string if hasattr(metric_fn, 'name'): metric_name = metric_fn.name else: metric_name = metric_fn.__name__ metric_name = metric_name_prefix + metric_name with K.name_scope(metric_name): metric_result = weighted_metric_fn( y_true, y_pred, weights=weights, mask=masks[i]) # Append to self.metrics_names, self.metric_tensors, # self.stateful_metric_names if len(self.output_names) > 1: metric_name = '%s_%s' % (self.output_names[i], metric_name) # Dedupe name j = 1 base_metric_name = metric_name while metric_name in self.metrics_names: metric_name = '%s_%d' % (base_metric_name, j) j += 1 self.metrics_names.append(metric_name) self.metrics_tensors.append(metric_result) # Keep track of state updates created by # stateful metrics (i.e. metrics layers). if isinstance(metric_fn, Layer): self.stateful_metric_names.append(metric_name) self.metrics_updates += metric_fn.updates handle_metrics(output_metrics) handle_metrics(output_weighted_metrics, weights=weights) # Prepare gradient updates and state updates. self.total_loss = total_loss self.sample_weights = sample_weights self._feed_sample_weights = [] for i in range(len(self.sample_weights)): if i not in skip_target_weighing_indices: self._feed_sample_weights.append(self.sample_weights[i]) # Functions for train, test and predict will # be compiled lazily when required. # This saves time when the user is not using all functions. self._function_kwargs = kwargs self.train_function = None self.test_function = None self.predict_function = None # Collected trainable weights, sorted in topological order. trainable_weights = self.trainable_weights self._collected_trainable_weights = trainable_weights def _check_trainable_weights_consistency(self): """Check trainable weights count consistency. This will raise a warning if `trainable_weights` and `_collected_trainable_weights` are inconsistent (i.e. have different number of parameters). Inconsistency will typically arise when one modifies `model.trainable` without calling `model.compile` again. """ if not hasattr(self, '_collected_trainable_weights'): return if len(self.trainable_weights) != len(self._collected_trainable_weights): logging.warning( UserWarning( 'Discrepancy between trainable weights and collected trainable' ' weights, did you set `model.trainable` without calling' ' `model.compile` after ?')) def _make_train_function(self): if not hasattr(self, 'train_function'): raise RuntimeError('You must compile your model before using it.') self._check_trainable_weights_consistency() if self.train_function is None: inputs = (self._feed_inputs + self._feed_targets + self._feed_sample_weights) if self.uses_learning_phase and not isinstance(K.learning_phase(), int): inputs += [K.learning_phase()] with K.name_scope('training'): with K.name_scope(self.optimizer.__class__.__name__): # Training updates updates = self.optimizer.get_updates( params=self._collected_trainable_weights, loss=self.total_loss) # Unconditional updates updates += self.get_updates_for(None) # Conditional updates relevant to this model updates += self.get_updates_for(self._feed_inputs) # Stateful metrics updates updates += self.metrics_updates # Gets loss and metrics. Updates weights at each call. self.train_function = K.function( inputs, [self.total_loss] + self.metrics_tensors, updates=updates, name='train_function', **self._function_kwargs) def _make_test_function(self): if not hasattr(self, 'test_function'): raise RuntimeError('You must compile your model before using it.') if self.test_function is None: inputs = (self._feed_inputs + self._feed_targets + self._feed_sample_weights) if self.uses_learning_phase and not isinstance(K.learning_phase(), int): inputs += [K.learning_phase()] # Return loss and metrics, no gradient updates. # Does update the network states. self.test_function = K.function( inputs, [self.total_loss] + self.metrics_tensors, updates=self.state_updates + self.metrics_updates, name='test_function', **self._function_kwargs) def _make_predict_function(self): if not hasattr(self, 'predict_function'): self.predict_function = None if self.predict_function is None: if self.uses_learning_phase and not isinstance(K.learning_phase(), int): inputs = self._feed_inputs + [K.learning_phase()] else: inputs = self._feed_inputs # Gets network outputs. Does not update weights. # Does update the network states. kwargs = getattr(self, '_function_kwargs', {}) self.predict_function = K.function( inputs, self.outputs, updates=self.state_updates, name='predict_function', **kwargs) def _standardize_user_data(self, x, y=None, sample_weight=None, class_weight=None, batch_size=None): """Runs validation checks on input and target data passed by the user. Also standardizes the data to lists of arrays, in order. Also builds and compiles the model on the fly if it is a subclassed model that has never been called before (and thus has no inputs/outputs). This is a purely internal method, subject to refactoring at any time. Args: x: An array or list of arrays, to be used as input data. If the model has known, named inputs, this could also be a dict mapping input names to the corresponding array. y: An array or list of arrays, to be used as target data. If the model has known, named outputs, this could also be a dict mapping output names to the corresponding array. sample_weight: An optional sample-weight array passed by the user to weight the importance of each sample in `x`. class_weight: An optional class-weight array by the user to weight the importance of samples in `x` based on the class they belong to, as conveyed by `y`. batch_size: Integer batch size. If provided, it is used to run additional validation checks on stateful models. Returns: A tuple of 3 lists: input arrays, target arrays, sample-weight arrays. If the model's input and targets are symbolic, these lists are empty (since the model takes no user-provided data, instead the data comes from the symbolic inputs/targets). Raises: ValueError: In case of invalid user-provided data. RuntimeError: If the model was never compiled. """ # First, we build/compile the model on the fly if necessary. all_inputs = [] if not self.built: # We need to use `x` to set the model inputs. # We type-check that `x` and `y` are either single arrays # or lists of arrays. if isinstance(x, (list, tuple)): if not all(isinstance(v, np.ndarray) or tensor_util.is_tensor(v) for v in x): raise ValueError('Please provide as model inputs either a single ' 'array or a list of arrays. You passed: x=' + str(x)) all_inputs += list(x) elif isinstance(x, dict): raise ValueError('Please do not pass a dictionary as model inputs.') else: if not isinstance(x, np.ndarray) and not tensor_util.is_tensor(x): raise ValueError('Please provide as model inputs either a single ' 'array or a list of arrays. You passed: x=' + str(x)) all_inputs.append(x) # Build the model using the retrieved inputs (value or symbolic). # If values, then in symbolic-mode placeholders will be created # to match the value shapes. if not self.inputs: self._set_inputs(x) if y is not None: if not self.optimizer: raise RuntimeError('You must compile a model before ' 'training/testing. ' 'Use `model.compile(optimizer, loss)`.') if not self._is_compiled: # On-the-fly compilation of the model. # We need to use `y` to set the model targets. if isinstance(y, (list, tuple)): if not all(isinstance(v, np.ndarray) or tensor_util.is_tensor(v) for v in y): raise ValueError('Please provide as model targets either a single ' 'array or a list of arrays. ' 'You passed: y=' + str(y)) elif isinstance(y, dict): raise ValueError('Please do not pass a dictionary as model targets.') else: if not isinstance(y, np.ndarray) and not tensor_util.is_tensor(y): raise ValueError('Please provide as model targets either a single ' 'array or a list of arrays. ' 'You passed: y=' + str(y)) # Typecheck that all inputs are *either* value *or* symbolic. # TODO(fchollet): this check could be removed in Eager mode? if y is not None: if isinstance(y, (list, tuple)): all_inputs += list(y) else: all_inputs.append(y) if any(tensor_util.is_tensor(v) for v in all_inputs): if not all(tensor_util.is_tensor(v) for v in all_inputs): raise ValueError('Do not pass inputs that mix Numpy arrays and ' 'TensorFlow tensors. ' 'You passed: x=' + str(x) + '; y=' + str(y)) if context.executing_eagerly(): target_tensors = None else: # Handle target tensors if any passed. if not isinstance(y, (list, tuple)): y = [y] target_tensors = [v for v in y if tensor_util.is_tensor(v)] self.compile(optimizer=self.optimizer, loss=self.loss, metrics=self.metrics, loss_weights=self.loss_weights, target_tensors=target_tensors) # If `x` and `y` were all symbolic, then no model should not be fed any # inputs and targets. # Note: in this case, `any` and `all` are equivalent since we disallow # mixed symbolic/value inputs. if any(tensor_util.is_tensor(v) for v in all_inputs): return [], [], [] # What follows is input validation and standardization to list format, # in the case where all inputs are value arrays. if context.executing_eagerly(): # In eager mode, do not do shape validation. feed_input_names = self.input_names feed_input_shapes = None elif not self._is_graph_network: # Case: symbolic-mode subclassed network. Do not do shape validation. feed_input_names = self._feed_input_names feed_input_shapes = None else: # Case: symbolic-mode graph network. # In this case, we run extensive shape validation checks. feed_input_names = self._feed_input_names feed_input_shapes = self._feed_input_shapes # Standardize the inputs. x = training_utils.standardize_input_data( x, feed_input_names, feed_input_shapes, check_batch_axis=False, # Don't enforce the batch size. exception_prefix='input') if y is not None: if context.executing_eagerly(): feed_output_names = self.output_names feed_output_shapes = None # Sample weighting not supported in this case. # TODO(fchollet): consider supporting it. feed_sample_weight_modes = [None for _ in self.outputs] elif not self._is_graph_network: feed_output_names = self._feed_output_names feed_output_shapes = None # Sample weighting not supported in this case. # TODO(fchollet): consider supporting it. feed_sample_weight_modes = [None for _ in self.outputs] else: feed_output_names = self._feed_output_names feed_sample_weight_modes = self._feed_sample_weight_modes feed_output_shapes = [] for output_shape, loss_fn in zip(self._feed_output_shapes, self._feed_loss_fns): if loss_fn is losses.sparse_categorical_crossentropy: feed_output_shapes.append(output_shape[:-1] + (1,)) elif (not hasattr(loss_fn, '__name__') or getattr(losses, loss_fn.__name__, None) is None): # If `loss_fn` is not a function (e.g. callable class) # or if it not in the `losses` module, then # it is a user-defined loss and we make no assumptions # about it. feed_output_shapes.append(None) else: feed_output_shapes.append(output_shape) # Standardize the outputs. y = training_utils.standardize_input_data( y, feed_output_names, feed_output_shapes, check_batch_axis=False, # Don't enforce the batch size. exception_prefix='target') # Generate sample-wise weight values given the `sample_weight` and # `class_weight` arguments. sample_weights = training_utils.standardize_sample_weights( sample_weight, feed_output_names) class_weights = training_utils.standardize_class_weights( class_weight, feed_output_names) sample_weights = [ training_utils.standardize_weights(ref, sw, cw, mode) for (ref, sw, cw, mode) in zip(y, sample_weights, class_weights, feed_sample_weight_modes) ] # Check that all arrays have the same length. training_utils.check_array_lengths(x, y, sample_weights) if self._is_graph_network and not context.executing_eagerly(): # Additional checks to avoid users mistakenly using improper loss fns. training_utils.check_loss_and_target_compatibility( y, self._feed_loss_fns, feed_output_shapes) else: y = [] sample_weights = [] if self.stateful and batch_size: # Check that for stateful networks, number of samples is a multiple # of the static batch size. if x[0].shape[0] % batch_size != 0: raise ValueError('In a stateful network, ' 'you should only pass inputs with ' 'a number of samples that can be ' 'divided by the batch size. Found: ' + str(x[0].shape[0]) + ' samples') return x, y, sample_weights def _set_inputs(self, inputs, training=None): """Set model's input and output specs based on the input data received. This is to be used for Model subclasses, which do not know at instantiation time what their inputs look like. Args: inputs: Single array, or list of arrays. The arrays could be placeholders, Numpy arrays, or data tensors. - if placeholders: the model is built on top of these placeholders, and we expect Numpy data to be fed for them when calling `fit`/etc. - if Numpy data: we create placeholders matching the shape of the Numpy arrays. We expect Numpy data to be fed for these placeholders when calling `fit`/etc. - if data tensors: the model is built on top of these tensors. We do not expect any Numpy data to be provided when calling `fit`/etc. training: Boolean or None. Only relevant in symbolic mode. Specifies whether to build the model's graph in inference mode (False), training mode (True), or using the Keras learning phase (None). """ if self.__class__.__name__ == 'Sequential': # Note: we can't test whether the model is `Sequential` via `isinstance` # since `Sequential` depends on `Model`. if isinstance(inputs, list): assert len(inputs) == 1 inputs = inputs[0] self.build(input_shape=(None,) + inputs.shape[1:]) elif context.executing_eagerly(): self._eager_set_inputs(inputs) else: self._symbolic_set_inputs(inputs, training=training) def _set_scope(self, scope=None): """Modify the Layer scope creation logic to create ResourceVariables.""" super(Model, self)._set_scope(scope=scope) # Subclassed Models create ResourceVariables by default. This makes it # easier to use Models in an eager/graph agnostic way (since eager execution # always uses ResourceVariables). if not self._is_graph_network: self._scope.set_use_resource(True) def _eager_set_inputs(self, inputs): """Set model's input and output specs based on the input data received. This is to be used for Model subclasses, which do not know at instantiation time what their inputs look like. We assume the number and ndim of outputs does not change over different calls. Args: inputs: Argument `x` (input data) passed by the user upon first model use. Raises: ValueError: If the model's inputs are already set. """ assert context.executing_eagerly() if self.inputs: raise ValueError('Model inputs are already set.') # On-the-fly setting of model inputs/outputs as DeferredTensors, # to keep track of number of inputs and outputs and their ndim. if isinstance(inputs, (list, tuple)): dummy_output_values = self.call( [ops.convert_to_tensor(v, dtype=K.floatx()) for v in inputs]) dummy_input_values = list(inputs) else: dummy_output_values = self.call( ops.convert_to_tensor(inputs, dtype=K.floatx())) dummy_input_values = [inputs] if isinstance(dummy_output_values, (list, tuple)): dummy_output_values = list(dummy_output_values) else: dummy_output_values = [dummy_output_values] self.outputs = [ _DeferredTensor(shape=(None for _ in v.shape), dtype=v.dtype) for v in dummy_output_values] self.inputs = [ _DeferredTensor(shape=(None for _ in v.shape), dtype=v.dtype) for v in dummy_input_values] self.input_names = [ 'input_%d' % (i + 1) for i in range(len(dummy_input_values))] self.output_names = [ 'output_%d' % (i + 1) for i in range(len(dummy_output_values))] self.built = True def _symbolic_set_inputs(self, inputs, outputs=None, training=None): """Set model's inputs and output specs based. This is to be used for Model subclasses, which do not know at instantiation time what their inputs look like. Args: inputs: Argument `x` (input data) passed by the user upon first model use. outputs: None, a data tensor, or a list of data tensors. If None, the outputs will be determined by invoking self.call(), otherwise the provided value will be used. training: Boolean or None. Only relevant in symbolic mode. Specifies whether to build the model's graph in inference mode (False), training mode (True), or using the Keras learning phase (None). Raises: ValueError: If the model's inputs are already set. """ assert not context.executing_eagerly() if self.inputs: raise ValueError('Model inputs are already set.') # On-the-fly setting of symbolic model inputs (either by using the tensor # provided, or by creating a placeholder if Numpy data was provided). self.inputs = [] self.input_names = [] self._feed_inputs = [] self._feed_input_names = [] self._feed_input_shapes = [] if isinstance(inputs, (list, tuple)): inputs = list(inputs) else: inputs = [inputs] for i, v in enumerate(inputs): name = 'input_%d' % (i + 1) self.input_names.append(name) if isinstance(v, list): v = np.asarray(v) if v.ndim == 1: v = np.expand_dims(v, 1) if isinstance(v, (np.ndarray)): # We fix the placeholder shape except the batch size. # This is suboptimal, but it is the best we can do with the info # we have. The user should call `model._set_inputs(placeholders)` # to specify custom placeholders if the need arises. shape = (None,) + v.shape[1:] placeholder = K.placeholder(shape=shape, name=name) self.inputs.append(placeholder) self._feed_inputs.append(placeholder) self._feed_input_names.append(name) self._feed_input_shapes.append(shape) else: # Assumed tensor - TODO(fchollet) additional type check? self.inputs.append(v) if K.is_placeholder(v): self._feed_inputs.append(v) self._feed_input_names.append(name) self._feed_input_shapes.append(K.int_shape(v)) if outputs is None: # Obtain symbolic outputs by calling the model. if len(self.inputs) == 1: if self._expects_training_arg: outputs = self.call(self.inputs[0], training=training) else: outputs = self.call(self.inputs[0]) else: if self._expects_training_arg: outputs = self.call(self.inputs, training=training) else: outputs = self.call(self.inputs) if isinstance(outputs, (list, tuple)): outputs = list(outputs) else: outputs = [outputs] self.outputs = outputs self.output_names = [ 'output_%d' % (i + 1) for i in range(len(self.outputs))] self.built = True def fit(self, x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0., validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, **kwargs): """Trains the model for a fixed number of epochs (iterations on a dataset). Arguments: x: Numpy array of training data (if the model has a single input), or list of Numpy arrays (if the model has multiple inputs). If input layers in the model are named, you can also pass a dictionary mapping input names to Numpy arrays. `x` can be `None` (default) if feeding from TensorFlow data tensors. y: Numpy array of target (label) data (if the model has a single output), or list of Numpy arrays (if the model has multiple outputs). If output layers in the model are named, you can also pass a dictionary mapping output names to Numpy arrays. `y` can be `None` (default) if feeding from TensorFlow data tensors. batch_size: Integer or `None`. Number of samples per gradient update. If unspecified, `batch_size` will default to 32. epochs: Integer. Number of epochs to train the model. An epoch is an iteration over the entire `x` and `y` data provided. Note that in conjunction with `initial_epoch`, `epochs` is to be understood as "final epoch". The model is not trained for a number of iterations given by `epochs`, but merely until the epoch of index `epochs` is reached. verbose: Integer. 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = one line per epoch. callbacks: List of `keras.callbacks.Callback` instances. List of callbacks to apply during training. See [callbacks](/callbacks). validation_split: Float between 0 and 1. Fraction of the training data to be used as validation data. The model will set apart this fraction of the training data, will not train on it, and will evaluate the loss and any model metrics on this data at the end of each epoch. The validation data is selected from the last samples in the `x` and `y` data provided, before shuffling. validation_data: tuple `(x_val, y_val)` or tuple `(x_val, y_val, val_sample_weights)` on which to evaluate the loss and any model metrics at the end of each epoch. The model will not be trained on this data. `validation_data` will override `validation_split`. shuffle: Boolean (whether to shuffle the training data before each epoch) or str (for 'batch'). 'batch' is a special option for dealing with the limitations of HDF5 data; it shuffles in batch-sized chunks. Has no effect when `steps_per_epoch` is not `None`. class_weight: Optional dictionary mapping class indices (integers) to a weight (float) value, used for weighting the loss function (during training only). This can be useful to tell the model to "pay more attention" to samples from an under-represented class. sample_weight: Optional Numpy array of weights for the training samples, used for weighting the loss function (during training only). You can either pass a flat (1D) Numpy array with the same length as the input samples (1:1 mapping between weights and samples), or in the case of temporal data, you can pass a 2D array with shape `(samples, sequence_length)`, to apply a different weight to every timestep of every sample. In this case you should make sure to specify `sample_weight_mode="temporal"` in `compile()`. initial_epoch: Integer. Epoch at which to start training (useful for resuming a previous training run). steps_per_epoch: Integer or `None`. Total number of steps (batches of samples) before declaring one epoch finished and starting the next epoch. When training with input tensors such as TensorFlow data tensors, the default `None` is equal to the number of samples in your dataset divided by the batch size, or 1 if that cannot be determined. validation_steps: Only relevant if `steps_per_epoch` is specified. Total number of steps (batches of samples) to validate before stopping. **kwargs: Used for backwards compatibility. Returns: A `History` object. Its `History.history` attribute is a record of training loss values and metrics values at successive epochs, as well as validation loss values and validation metrics values (if applicable). Raises: RuntimeError: If the model was never compiled. ValueError: In case of mismatch between the provided input data and what the model expects. """ # TODO(fchollet): this method may be creating reference cycles, which would # lead to accumulating garbage in memory when called in a loop. Investigate. # Backwards compatibility if batch_size is None and steps_per_epoch is None: batch_size = 32 # Legacy support if 'nb_epoch' in kwargs: logging.warning( 'The `nb_epoch` argument in `fit` ' 'has been renamed `epochs`.') epochs = kwargs.pop('nb_epoch') if kwargs: raise TypeError('Unrecognized keyword arguments: ' + str(kwargs)) if x is None and y is None and steps_per_epoch is None: raise ValueError('If fitting from data tensors, ' 'you should specify the `steps_per_epoch` ' 'argument.') # Validate user data. x, y, sample_weights = self._standardize_user_data( x, y, sample_weight=sample_weight, class_weight=class_weight, batch_size=batch_size) # Prepare validation data. if validation_data: if len(validation_data) == 2: val_x, val_y = validation_data # pylint: disable=unpacking-non-sequence val_sample_weight = None elif len(validation_data) == 3: val_x, val_y, val_sample_weight = validation_data # pylint: disable=unpacking-non-sequence else: raise ValueError( 'When passing validation_data, ' 'it must contain 2 (x_val, y_val) ' 'or 3 (x_val, y_val, val_sample_weights) ' 'items, however it contains %d items' % len(validation_data)) val_x, val_y, val_sample_weights = self._standardize_user_data( val_x, val_y, sample_weight=val_sample_weight, batch_size=batch_size) elif validation_split and 0. < validation_split < 1.: if hasattr(x[0], 'shape'): split_at = int(x[0].shape[0] * (1. - validation_split)) else: split_at = int(len(x[0]) * (1. - validation_split)) x, val_x = (slice_arrays(x, 0, split_at), slice_arrays(x, split_at)) y, val_y = (slice_arrays(y, 0, split_at), slice_arrays(y, split_at)) sample_weights, val_sample_weights = (slice_arrays( sample_weights, 0, split_at), slice_arrays(sample_weights, split_at)) elif validation_steps: val_x = [] val_y = [] val_sample_weights = [] else: val_x = None val_y = None val_sample_weights = None if context.executing_eagerly(): return training_eager.fit_loop( self, inputs=x, targets=y, sample_weights=sample_weights, batch_size=batch_size, epochs=epochs, verbose=verbose, callbacks=callbacks, val_inputs=val_x, val_targets=val_y, val_sample_weights=val_sample_weights, shuffle=shuffle, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps) else: return training_arrays.fit_loop( self, x, y, sample_weights=sample_weights, batch_size=batch_size, epochs=epochs, verbose=verbose, callbacks=callbacks, val_inputs=val_x, val_targets=val_y, val_sample_weights=val_sample_weights, shuffle=shuffle, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps) def evaluate(self, x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None): """Returns the loss value & metrics values for the model in test mode. Computation is done in batches. Arguments: x: Numpy array of test data (if the model has a single input), or list of Numpy arrays (if the model has multiple inputs). If input layers in the model are named, you can also pass a dictionary mapping input names to Numpy arrays. `x` can be `None` (default) if feeding from TensorFlow data tensors. y: Numpy array of target (label) data (if the model has a single output), or list of Numpy arrays (if the model has multiple outputs). If output layers in the model are named, you can also pass a dictionary mapping output names to Numpy arrays. `y` can be `None` (default) if feeding from TensorFlow data tensors. batch_size: Integer or `None`. Number of samples per evaluation step. If unspecified, `batch_size` will default to 32. verbose: 0 or 1. Verbosity mode. 0 = silent, 1 = progress bar. sample_weight: Optional Numpy array of weights for the test samples, used for weighting the loss function. You can either pass a flat (1D) Numpy array with the same length as the input samples (1:1 mapping between weights and samples), or in the case of temporal data, you can pass a 2D array with shape `(samples, sequence_length)`, to apply a different weight to every timestep of every sample. In this case you should make sure to specify `sample_weight_mode="temporal"` in `compile()`. steps: Integer or `None`. Total number of steps (batches of samples) before declaring the evaluation round finished. Ignored with the default value of `None`. Returns: Scalar test loss (if the model has a single output and no metrics) or list of scalars (if the model has multiple outputs and/or metrics). The attribute `model.metrics_names` will give you the display labels for the scalar outputs. Raises: ValueError: in case of invalid arguments. """ # Backwards compatibility. if batch_size is None and steps is None: batch_size = 32 if x is None and y is None and steps is None: raise ValueError('If evaluating from data tensors, ' 'you should specify the `steps` ' 'argument.') # Validate user data. x, y, sample_weights = self._standardize_user_data( x, y, sample_weight=sample_weight, batch_size=batch_size) if context.executing_eagerly(): return training_eager.test_loop( self, inputs=x, targets=y, sample_weights=sample_weights, batch_size=batch_size, verbose=verbose, steps=steps) else: return training_arrays.test_loop( self, inputs=x, targets=y, sample_weights=sample_weights, batch_size=batch_size, verbose=verbose, steps=steps) def predict(self, x, batch_size=None, verbose=0, steps=None): """Generates output predictions for the input samples. Computation is done in batches. Arguments: x: The input data, as a Numpy array (or list of Numpy arrays if the model has multiple outputs). batch_size: Integer. If unspecified, it will default to 32. verbose: Verbosity mode, 0 or 1. steps: Total number of steps (batches of samples) before declaring the prediction round finished. Ignored with the default value of `None`. Returns: Numpy array(s) of predictions. Raises: ValueError: In case of mismatch between the provided input data and the model's expectations, or in case a stateful model receives a number of samples that is not a multiple of the batch size. """ # Backwards compatibility. if batch_size is None and steps is None: batch_size = 32 if x is None and steps is None: raise ValueError('If predicting from data tensors, ' 'you should specify the `steps` ' 'argument.') x, _, _ = self._standardize_user_data(x) if context.executing_eagerly(): return training_eager.predict_loop( self, x, batch_size=batch_size, verbose=verbose, steps=steps) else: return training_arrays.predict_loop( self, x, batch_size=batch_size, verbose=verbose, steps=steps) def train_on_batch(self, x, y, sample_weight=None, class_weight=None): """Runs a single gradient update on a single batch of data. Arguments: x: Numpy array of training data, or list of Numpy arrays if the model has multiple inputs. If all inputs in the model are named, you can also pass a dictionary mapping input names to Numpy arrays. y: Numpy array of target data, or list of Numpy arrays if the model has multiple outputs. If all outputs in the model are named, you can also pass a dictionary mapping output names to Numpy arrays. sample_weight: Optional array of the same length as x, containing weights to apply to the model's loss for each sample. In the case of temporal data, you can pass a 2D array with shape (samples, sequence_length), to apply a different weight to every timestep of every sample. In this case you should make sure to specify sample_weight_mode="temporal" in compile(). class_weight: Optional dictionary mapping class indices (integers) to a weight (float) to apply to the model's loss for the samples from this class during training. This can be useful to tell the model to "pay more attention" to samples from an under-represented class. Returns: Scalar training loss (if the model has a single output and no metrics) or list of scalars (if the model has multiple outputs and/or metrics). The attribute `model.metrics_names` will give you the display labels for the scalar outputs. Raises: ValueError: In case of invalid user-provided arguments. """ x, y, sample_weights = self._standardize_user_data( x, y, sample_weight=sample_weight, class_weight=class_weight) if context.executing_eagerly(): outputs = training_eager.train_on_batch( self, x, y, sample_weights=sample_weights) else: if self.uses_learning_phase and not isinstance(K.learning_phase(), int): ins = x + y + sample_weights + [1] else: ins = x + y + sample_weights self._make_train_function() outputs = self.train_function(ins) if len(outputs) == 1: return outputs[0] return outputs def test_on_batch(self, x, y, sample_weight=None): """Test the model on a single batch of samples. Arguments: x: Numpy array of test data, or list of Numpy arrays if the model has multiple inputs. If all inputs in the model are named, you can also pass a dictionary mapping input names to Numpy arrays. y: Numpy array of target data, or list of Numpy arrays if the model has multiple outputs. If all outputs in the model are named, you can also pass a dictionary mapping output names to Numpy arrays. sample_weight: Optional array of the same length as x, containing weights to apply to the model's loss for each sample. In the case of temporal data, you can pass a 2D array with shape (samples, sequence_length), to apply a different weight to every timestep of every sample. In this case you should make sure to specify sample_weight_mode="temporal" in compile(). Returns: Scalar test loss (if the model has a single output and no metrics) or list of scalars (if the model has multiple outputs and/or metrics). The attribute `model.metrics_names` will give you the display labels for the scalar outputs. Raises: ValueError: In case of invalid user-provided arguments. """ x, y, sample_weights = self._standardize_user_data( x, y, sample_weight=sample_weight) if context.executing_eagerly(): outputs = training_eager.test_on_batch( self, x, y, sample_weights=sample_weights) else: if self.uses_learning_phase and not isinstance(K.learning_phase(), int): ins = x + y + sample_weights + [0] else: ins = x + y + sample_weights self._make_test_function() outputs = self.test_function(ins) if len(outputs) == 1: return outputs[0] return outputs def predict_on_batch(self, x): """Returns predictions for a single batch of samples. Arguments: x: Input samples, as a Numpy array. Returns: Numpy array(s) of predictions. """ x, _, _ = self._standardize_user_data(x) if context.executing_eagerly(): inputs = [ops.convert_to_tensor(val, dtype=K.floatx()) for val in x] return self(inputs) # pylint: disable=not-callable if not context.executing_eagerly(): if self.uses_learning_phase and not isinstance(K.learning_phase(), int): ins = x + [0] else: ins = x self._make_predict_function() outputs = self.predict_function(ins) if len(outputs) == 1: return outputs[0] return outputs def fit_generator(self, generator, steps_per_epoch=None, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, class_weight=None, max_queue_size=10, workers=1, use_multiprocessing=False, shuffle=True, initial_epoch=0): """Fits the model on data yielded batch-by-batch by a Python generator. The generator is run in parallel to the model, for efficiency. For instance, this allows you to do real-time data augmentation on images on CPU in parallel to training your model on GPU. The use of `keras.utils.Sequence` guarantees the ordering and guarantees the single use of every input per epoch when using `use_multiprocessing=True`. Arguments: generator: A generator or an instance of `Sequence` (`keras.utils.Sequence`) object in order to avoid duplicate data when using multiprocessing. The output of the generator must be either - a tuple `(inputs, targets)` - a tuple `(inputs, targets, sample_weights)`. This tuple (a single output of the generator) makes a single batch. Therefore, all arrays in this tuple must have the same length (equal to the size of this batch). Different batches may have different sizes. For example, the last batch of the epoch is commonly smaller than the others, if the size of the dataset is not divisible by the batch size. The generator is expected to loop over its data indefinitely. An epoch finishes when `steps_per_epoch` batches have been seen by the model. steps_per_epoch: Total number of steps (batches of samples) to yield from `generator` before declaring one epoch finished and starting the next epoch. It should typically be equal to the number of samples of your dataset divided by the batch size. Optional for `Sequence`: if unspecified, will use the `len(generator)` as a number of steps. epochs: Integer, total number of iterations on the data. verbose: Verbosity mode, 0, 1, or 2. callbacks: List of callbacks to be called during training. validation_data: This can be either - a generator for the validation data - a tuple (inputs, targets) - a tuple (inputs, targets, sample_weights). validation_steps: Only relevant if `validation_data` is a generator. Total number of steps (batches of samples) to yield from `generator` before stopping. Optional for `Sequence`: if unspecified, will use the `len(validation_data)` as a number of steps. class_weight: Dictionary mapping class indices to a weight for the class. max_queue_size: Integer. Maximum size for the generator queue. If unspecified, `max_queue_size` will default to 10. workers: Integer. Maximum number of processes to spin up when using process-based threading. If unspecified, `workers` will default to 1. If 0, will execute the generator on the main thread. use_multiprocessing: Boolean. If `True`, use process-based threading. If unspecified, `use_multiprocessing` will default to `False`. Note that because this implementation relies on multiprocessing, you should not pass non-picklable arguments to the generator as they can't be passed easily to children processes. shuffle: Boolean. Whether to shuffle the order of the batches at the beginning of each epoch. Only used with instances of `Sequence` (`keras.utils.Sequence`). Has no effect when `steps_per_epoch` is not `None`. initial_epoch: Epoch at which to start training (useful for resuming a previous training run) Returns: A `History` object. Example: ```python def generate_arrays_from_file(path): while 1: f = open(path) for line in f: # create numpy arrays of input data # and labels, from each line in the file x1, x2, y = process_line(line) yield ({'input_1': x1, 'input_2': x2}, {'output': y}) f.close() model.fit_generator(generate_arrays_from_file('/my_file.txt'), steps_per_epoch=10000, epochs=10) ``` Raises: ValueError: In case the generator yields data in an invalid format. """ if not self.built and not self._is_graph_network: raise NotImplementedError( '`fit_generator` is not yet enabled for unbuilt Model subclasses') return training_generator.fit_generator( self, generator, steps_per_epoch=steps_per_epoch, epochs=epochs, verbose=verbose, callbacks=callbacks, validation_data=validation_data, validation_steps=validation_steps, class_weight=class_weight, max_queue_size=max_queue_size, workers=workers, use_multiprocessing=use_multiprocessing, shuffle=shuffle, initial_epoch=initial_epoch) def evaluate_generator(self, generator, steps=None, max_queue_size=10, workers=1, use_multiprocessing=False): """Evaluates the model on a data generator. The generator should return the same kind of data as accepted by `test_on_batch`. Arguments: generator: Generator yielding tuples (inputs, targets) or (inputs, targets, sample_weights) or an instance of Sequence (keras.utils.Sequence) object in order to avoid duplicate data when using multiprocessing. steps: Total number of steps (batches of samples) to yield from `generator` before stopping. Optional for `Sequence`: if unspecified, will use the `len(generator)` as a number of steps. max_queue_size: maximum size for the generator queue workers: Integer. Maximum number of processes to spin up when using process-based threading. If unspecified, `workers` will default to 1. If 0, will execute the generator on the main thread. use_multiprocessing: Boolean. If `True`, use process-based threading. If unspecified, `use_multiprocessing` will default to `False`. Note that because this implementation relies on multiprocessing, you should not pass non-picklable arguments to the generator as they can't be passed easily to children processes. Returns: Scalar test loss (if the model has a single output and no metrics) or list of scalars (if the model has multiple outputs and/or metrics). The attribute `model.metrics_names` will give you the display labels for the scalar outputs. Raises: ValueError: in case of invalid arguments. Raises: ValueError: In case the generator yields data in an invalid format. """ if not self.built and not self._is_graph_network: raise NotImplementedError( '`evaluate_generator` is not yet enabled for ' 'unbuilt Model subclasses') return training_generator.evaluate_generator( self, generator, steps=steps, max_queue_size=max_queue_size, workers=workers, use_multiprocessing=use_multiprocessing) def predict_generator(self, generator, steps=None, max_queue_size=10, workers=1, use_multiprocessing=False, verbose=0): """Generates predictions for the input samples from a data generator. The generator should return the same kind of data as accepted by `predict_on_batch`. Arguments: generator: Generator yielding batches of input samples or an instance of Sequence (keras.utils.Sequence) object in order to avoid duplicate data when using multiprocessing. steps: Total number of steps (batches of samples) to yield from `generator` before stopping. Optional for `Sequence`: if unspecified, will use the `len(generator)` as a number of steps. max_queue_size: Maximum size for the generator queue. workers: Integer. Maximum number of processes to spin up when using process-based threading. If unspecified, `workers` will default to 1. If 0, will execute the generator on the main thread. use_multiprocessing: Boolean. If `True`, use process-based threading. If unspecified, `use_multiprocessing` will default to `False`. Note that because this implementation relies on multiprocessing, you should not pass non-picklable arguments to the generator as they can't be passed easily to children processes. verbose: verbosity mode, 0 or 1. Returns: Numpy array(s) of predictions. Raises: ValueError: In case the generator yields data in an invalid format. """ if not self.built and not self._is_graph_network: raise NotImplementedError( '`predict_generator` is not yet enabled for unbuilt Model subclasses') return training_generator.predict_generator( self, generator, steps=steps, max_queue_size=max_queue_size, workers=workers, use_multiprocessing=use_multiprocessing, verbose=verbose)

apache-2.0

annahs/atmos_research

WHI_long_term_2min_data_to_db.py

1

8596

import sys import os import numpy as np from pprint import pprint from datetime import datetime from datetime import timedelta import mysql.connector import math import calendar import matplotlib.pyplot as plt import matplotlib.cm as cm from matplotlib import dates start = datetime(2009,7,15,4) #2009 - 20090628 2010 - 20100610 2012 - 20100405 end = datetime(2009,8,17) #2009 - 20090816 2010 - 20100726 2012 - 20100601 timestep = 6.#1./30 #hours sample_min = 117 #117 for all 2009-2012 sample_max = 123 #123 for all 2009-2012 yag_min = 3.8 #3.8 for all 2009-2012 yag_max = 6 #6 for all 2009-2012 BC_VED_min = 70 BC_VED_max = 220 min_scat_pkht = 20 mass_min = ((BC_VED_min/(10.**7))**3)*(math.pi/6.)*1.8*(10.**15) mass_max = ((BC_VED_max/(10.**7))**3)*(math.pi/6.)*1.8*(10.**15) lag_threshold_2009 = 0.1 lag_threshold_2010 = 0.25 lag_threshold_2012 = 1.5 print 'mass limits', mass_min, mass_max cnx = mysql.connector.connect(user='root', password='Suresh15', host='localhost', database='black_carbon') cursor = cnx.cursor() def check_spike_times(particle_start_time,particle_end_time): cursor.execute('''SELECT count(*) FROM whi_spike_times_2009to2012 WHERE (spike_start_UTC <= %s AND spike_end_UTC > %s) OR (spike_start_UTC <= %s AND spike_end_UTC > %s) ''', (particle_start_time,particle_start_time,particle_end_time,particle_end_time)) spike_count = cursor.fetchall()[0][0] return spike_count def get_hysplit_id(particle_start_time): cursor.execute('''SELECT id FROM whi_hysplit_hourly_data WHERE (UNIX_UTC_start_time <= %s AND UNIX_UTC_end_time > %s) ''', (particle_start_time,particle_start_time)) hy_id_list = cursor.fetchall() if hy_id_list == []: hy_id = None else: hy_id = hy_id_list[0][0] return hy_id def get_met_info(particle_start_time): cursor.execute('''SELECT id,pressure_Pa,room_temp_C FROM whi_sampling_conditions WHERE (UNIX_UTC_start_time <= %s AND UNIX_UTC_end_time > %s) ''', (particle_start_time,particle_start_time)) met_list = cursor.fetchall() if met_list == []: met_list = [[np.nan,np.nan,np.nan]] return met_list[0] def get_gc_id(particle_start_time): cursor.execute('''SELECT id FROM whi_gc_hourly_bc_data WHERE (UNIX_UTC_start_time <= %s AND UNIX_UTC_end_time > %s) ''', (particle_start_time,particle_start_time)) gc_id_list = cursor.fetchall() if gc_id_list == []: gc_id = None else: gc_id = gc_id_list[0][0] return gc_id def get_sample_factor(UNIX_start): date_time = datetime.utcfromtimestamp(UNIX_start) sample_factors_2012 = [ [datetime(2012,4,4,19,43,4), datetime(2012,4,5,13,47,9), 3.0], [datetime(2012,4,5,13,47,9), datetime(2012,4,10,3,3,25), 1.0], [datetime(2012,4,10,3,3,25), datetime(2012,5,16,6,9,13), 3.0], [datetime(2012,5,16,6,9,13), datetime(2012,6,7,18,14,39), 10.0], ] if date_time.year in [2009,2010]: sample_factor = 1.0 if date_time.year == 2012: for date_range in sample_factors_2012: start_date = date_range[0] end_date = date_range[1] range_sample_factor = date_range[2] if start_date<= date_time < end_date: sample_factor = range_sample_factor return sample_factor def lag_time_calc(BB_incand_pk_pos,BB_scat_pk_pos): long_lags = 0 short_lags = 0 lag_time = np.nan if (-10 < lag_time < 10): lag_time = (BB_incand_pk_pos-BB_scat_pk_pos)*0.2 #us if start_dt.year == 2009 and lag_time > lag_threshold_2009: long_lags = 1 elif start_dt.year == 2010 and lag_time > lag_threshold_2010: long_lags = 1 elif start_dt.year == 2012 and lag_time > lag_threshold_2012: long_lags = 1 else: short_lags = 1 return [lag_time,long_lags,short_lags] #query to add 1h mass conc data add_data = ('''INSERT INTO whi_sp2_2min_data (UNIX_UTC_start_time,UNIX_UTC_end_time,number_particles,rBC_mass_conc,rBC_mass_conc_err,volume_air_sampled,sampling_duration,mean_lag_time,sample_factor,hysplit_hourly_id,whi_sampling_cond_id,gc_hourly_id) VALUES (%(UNIX_UTC_start_time)s,%(UNIX_UTC_end_time)s,%(number_particles)s,%(rBC_mass_conc)s,%(rBC_mass_conc_err)s,%(volume_air_sampled)s,%(sampling_duration)s,%(mean_lag_time)s,%(sample_factor)s,%(hysplit_hourly_id)s,%(whi_sampling_cond_id)s,%(gc_hourly_id)s)''' ) # multiple_records = [] i=1 while start <= end: long_lags = 0 short_lags = 0 if (4 <= start.hour < 16): UNIX_start = calendar.timegm(start.utctimetuple()) UNIX_end = UNIX_start + timestep*3600.0 print start, UNIX_start+60 print datetime.utcfromtimestamp(UNIX_end) #filter on hk data here cursor.execute('''(SELECT mn.UNIX_UTC_ts_int_start, mn.UNIX_UTC_ts_int_end, mn.rBC_mass_fg_BBHG, mn.rBC_mass_fg_BBHG_err, mn.BB_incand_pk_pos, mn.BB_scat_pk_pos, mn.BB_scat_pkht, hk.sample_flow, mn.BB_incand_HG FROM whi_sp2_particle_data mn FORCE INDEX (hourly_binning) JOIN whi_hk_data hk on mn.HK_id = hk.id WHERE mn.UNIX_UTC_ts_int_start >= %s AND mn.UNIX_UTC_ts_int_end < %s AND hk.sample_flow >= %s AND hk.sample_flow < %s AND hk.yag_power >= %s AND hk.yag_power < %s)''', (UNIX_start,UNIX_end,sample_min,sample_max,yag_min,yag_max)) ind_data = cursor.fetchall() data={ 'rBC_mass_fg':[], 'rBC_mass_fg_err':[], 'lag_time':[] } total_sample_vol = 0 for row in ind_data: ind_start_time = float(row[0]) ind_end_time = float(row[1]) bbhg_mass_corr11 = float(row[2]) bbhg_mass_corr_err = float(row[3]) BB_incand_pk_pos = float(row[4]) BB_scat_pk_pos = float(row[5]) BB_scat_pk_ht = float(row[6]) sample_flow = float(row[7]) #in vccm incand_pkht = float(row[8]) #filter spike times here if check_spike_times(ind_start_time,ind_end_time): print 'spike' continue #skip the long interval if (ind_end_time - ind_start_time) > 540: print 'long interval' continue #skip if no sample flow if sample_flow == None: print 'no flow' continue #get sampling conditions id and met conditions met_data = get_met_info(UNIX_start) met_id = met_data[0] pressure = met_data[1] temperature = met_data[2]+273.15 correction_factor_for_STP = (273*pressure)/(101325*temperature) sample_vol = (sample_flow*(ind_end_time-ind_start_time)/60)*correction_factor_for_STP #/60 b/c sccm and time in secs total_sample_vol = total_sample_vol + sample_vol bbhg_mass_corr = 0.01244+0.0172*incand_pkht if (mass_min <= bbhg_mass_corr < mass_max): #get sample factor sample_factor = get_sample_factor(UNIX_start) data['rBC_mass_fg'].append(bbhg_mass_corr*sample_factor) data['rBC_mass_fg_err'].append(bbhg_mass_corr_err) #only calc lag time if there is a scattering signal if BB_scat_pk_ht > min_scat_pkht: lags = lag_time_calc(BB_incand_pk_pos,BB_scat_pk_pos) data['lag_time'].append(lags[0]) long_lags += lags[1] short_lags += lags[2] tot_rBC_mass_fg = sum(data['rBC_mass_fg']) tot_rBC_mass_uncer = sum(data['rBC_mass_fg_err']) rBC_number = len(data['rBC_mass_fg']) mean_lag = float(np.mean(data['lag_time'])) if np.isnan(mean_lag): mean_lag = None #get hysplit_id hysplit_id = None #get_hysplit_id(UNIX_start) #get GC id gc_id = None #get_gc_id(UNIX_start) if total_sample_vol != 0: mass_conc = (tot_rBC_mass_fg/total_sample_vol) mass_conc_uncer = (tot_rBC_mass_uncer/total_sample_vol) #add to db single_record = { 'UNIX_UTC_start_time' :UNIX_start, 'UNIX_UTC_end_time' :UNIX_end, 'number_particles' :rBC_number, 'rBC_mass_conc' :mass_conc, 'rBC_mass_conc_err' :mass_conc_uncer, 'volume_air_sampled' :total_sample_vol, 'sampling_duration' :(total_sample_vol/2), 'mean_lag_time' :mean_lag, 'number_long_lag' :long_lags, 'number_short_lag' :short_lags, 'sample_factor' :sample_factor, 'hysplit_hourly_id' :hysplit_id, 'whi_sampling_cond_id' :met_id, 'gc_hourly_id' :gc_id, } multiple_records.append((single_record)) #bulk insert to db table if i%1 == 0: cursor.executemany(add_data, multiple_records) cnx.commit() multiple_records = [] #increment count i+= 1 start += timedelta(hours = timestep) #bulk insert of remaining records to db if multiple_records != []: cursor.executemany(add_data, multiple_records) cnx.commit() multiple_records = [] cnx.close()

mit

topix-hackademy/social-listener

application/twitter/tweets/collector.py

1

3236

from application.mongo import Connection from application.twitter.interface import TwitterInterface from application.twitter.tweets.fetcher import TweetsFetcher from application.processmanager import ProcessManager from application.utils.helpers import what_time_is_it import logging class TweetCollector(TwitterInterface): def __init__(self, user, *args, **kwargs): """ Twitter Collector. This class is used for retrieve tweets from a specific user """ super(TweetCollector, self).__init__(*args, **kwargs) self.user = user self.process_name = "Tweets Collector: <%s>" % user self.fetcherInstance = TweetsFetcher(self.auth, self.user, self.process_name) def __str__(self): """ String representation :return: """ return "Tweet Collector for user <{user}>".format(user=self.user) def start(self, process_manager): """ Start async job for user's tweets :param process_manager: Process manager instance :return: """ try: process_manager.create_process(target=self.fetcher, name=self.process_name, ptype='twitter_collector') except Exception: raise Exception('Error Creating new Process') def fetcher(self): """ Tweets loader :return: """ for page in self.fetcherInstance.get_tweets(): for tweet in page: try: if not Connection.Instance().db.twitter.find_one({'user': tweet.user.screen_name, 'source': 'collector', 'data.id': tweet.id}): Connection.Instance().db.twitter.insert_one({ 'source': 'collector', 'data': { 'created_at': tweet.created_at, 'favorite_count': tweet.favorite_count, 'geo': tweet.geo, 'id': tweet.id, 'source': tweet.source, 'in_reply_to_screen_name': tweet.in_reply_to_screen_name, 'in_reply_to_status_id': tweet.in_reply_to_status_id, 'in_reply_to_user_id': tweet.in_reply_to_user_id, 'retweet_count': tweet.retweet_count, 'retweeted': tweet.retweeted, 'text': tweet.text, 'entities': tweet.entities }, 'user': tweet.user.screen_name, 'created': what_time_is_it() }) except Exception as genericException: logging.error("MongoDB Insert Error in collector: %s" % genericException) import multiprocessing ProcessManager.terminate_process(multiprocessing.current_process().pid, True)

mit

baris/pushmanager

testing/testdb.py

1

4248

#!/usr/bin/python from datetime import datetime, timedelta import os import sqlite3 import tempfile import time from core import db def create_temp_db_file(): fd, db_file_path = tempfile.mkstemp(suffix="pushmanager.db") os.close(fd) return db_file_path def get_temp_db_uri(dbfile=None): if not dbfile: dbfile = create_temp_db_file() return "sqlite:///" + dbfile def make_test_db(dbfile=None): if not dbfile: dbfile = create_temp_db_file() testsql = open( os.path.join( os.path.dirname(__file__), "testdb.sql" ) ).read() test_db = sqlite3.connect(dbfile) test_db.cursor().executescript(testsql) test_db.commit() test_db.close() return dbfile class FakeDataMixin(object): now = time.time() yesterday = time.mktime((datetime.now() - timedelta(days=1)).timetuple()) push_data = [ [10, 'OnePush', 'bmetin', 'deploy-1', 'abc', 'live', yesterday, now, 'regular', ''], [11, 'TwoPush', 'troscoe', 'deploy-2', 'def', 'accepting', now, now, 'regular', ''], [12, 'RedPush', 'heyjoe', 'deploy-3', 'ghi', 'accepting', now, now, 'regular', ''], [13, 'BluePush', 'humpty', 'deploy-4', 'jkl', 'accepting', now, now, 'regular', ''], ] push_keys = [ 'id', 'title', 'user', 'branch', 'revision', 'state', 'created', 'modified', 'pushtype', 'extra_pings' ] fake_revision = "0"*40 request_data = [ [10, 'keysersoze', 'requested', 'keysersoze', 'usual_fix', '', now, now, 'Fix stuff', 'no comment', 12345, '', fake_revision], [11, 'bmetin', 'requested', 'bmetin', 'fix1', '', now, now, 'Fixing more stuff', 'yes comment', 234, '', fake_revision], [12, 'testuser1', 'requested', 'testuser2', 'fix1', 'search', now, now, 'Fixing1', 'no comment', 123, '', fake_revision], [13, 'testuser2', 'requested', 'testuser2', 'fix2', 'search', now, now, 'Fixing2', 'yes comment', 456, '', fake_revision], ] request_keys = [ 'id', 'user', 'state', 'repo', 'branch', 'tags', 'created', 'modified', 'title', 'comments', 'reviewid', 'description', 'revision' ] def on_db_return(self, success, db_results): assert success def make_push_dict(self, data): return dict(zip(self.push_keys, data)) def make_request_dict(self, data): return dict(zip(self.request_keys, data)) def insert_pushes(self): push_queries = [] for pd in self.push_data: push_queries.append(db.push_pushes.insert(self.make_push_dict(pd))) db.execute_transaction_cb(push_queries, self.on_db_return) def insert_requests(self): request_queries = [] for rd in self.request_data: request_queries.append(db.push_requests.insert(self.make_request_dict(rd))) db.execute_transaction_cb(request_queries, self.on_db_return) def insert_pushcontent(self, requestid, pushid): db.execute_cb( db.push_pushcontents.insert({'request': requestid, 'push': pushid}), self.on_db_return ) def get_push_for_request(self, requestid): pushid = [None] def on_select_return(success, db_results): assert success _, pushid[0] = db_results.fetchone() # check if we have a push in with request first_pushcontent_query = db.push_pushcontents.select( db.push_pushcontents.c.request == requestid ) db.execute_cb(first_pushcontent_query, on_select_return) return pushid[0] def get_pushes(self): pushes = [None] def on_select_return(success, db_results): assert success pushes[0] = db_results.fetchall() db.execute_cb(db.push_pushes.select(), on_select_return) return pushes[0] def get_requests(self): requests = [None] def on_select_return(success, db_results): assert success requests[0] = db_results.fetchall() db.execute_cb(db.push_requests.select(), on_select_return) return requests[0] def get_requests_by_user(self, user): return [req for req in self.get_requests() if req['user'] == user]

apache-2.0