text
stringlengths
6
947k
repo_name
stringlengths
5
100
path
stringlengths
4
231
language
stringclasses
1 value
license
stringclasses
15 values
size
int64
6
947k
score
float64
0
0.34
# Copyright (C) 2013, Stefan Schwarzer # See the file LICENSE for licensing terms. """ tool.py - helper code """ from __future__ import unicode_literals import compat as compat __all__ = ["same_string_type_as", "as_bytes", "as_unicode", "as_default_string"] # Encoding to convert between byte string and unicode string. This is # a "lossless" encoding: Strings can be encoded/decoded back and forth # without information loss or causing encoding-related errors. The # `ftplib` module under Python 3 also uses the "latin1" encoding # internally. It's important to use the same encoding here, so that users who # used `ftplib` to create FTP items with non-ASCII characters can access them # in the same way with ftputil. LOSSLESS_ENCODING = "utf-8" def same_string_type_as(type_source, content_source): """ Return a string of the same type as `type_source` with the content from `content_source`. If the `type_source` and `content_source` don't have the same type, use `LOSSLESS_ENCODING` above to encode or decode, whatever operation is needed. """ if ( isinstance(type_source, compat.bytes_type) and isinstance(content_source, compat.unicode_type)): return content_source.encode(LOSSLESS_ENCODING) elif ( isinstance(type_source, compat.unicode_type) and isinstance(content_source, compat.bytes_type)): return content_source.decode(LOSSLESS_ENCODING) else: return content_source def as_bytes(string): """ Return the argument `string` converted to a byte string if it's a unicode string. Otherwise just return the string. """ return same_string_type_as(b"", string) def as_unicode(string): """ Return the argument `string` converted to a unicode string if it's a byte string. Otherwise just return the string. """ return same_string_type_as("", string) def as_default_string(string): """ Return the argument `string` converted to a the default string type for the Python version. For unicode strings, `LOSSLESS_ENCODING` is used for encoding or decoding. """ return same_string_type_as(compat.default_string_type(), string) def encode_if_unicode(string, encoding): """ Return the string `string`, encoded with `encoding` if `string` is a unicode string. Otherwise return `string` unchanged. """ if isinstance(string, compat.unicode_type): return string.encode(encoding) else: return string def recursive_str_to_unicode(target): """ recursive function for convert all string in dict, tuple and list to unicode """ pack_result = [] if isinstance(target, dict): level = {} for key, val in target.iteritems(): ukey = recursive_str_to_unicode(key) uval = recursive_str_to_unicode(val) level[ukey] = uval pack_result.append(level) elif isinstance(target, list): level = [] for leaf in target: uleaf = recursive_str_to_unicode(leaf) level.append(uleaf) pack_result.append(level) elif isinstance(target, tuple): level = [] for leaf in target: uleaf = recursive_str_to_unicode(leaf) level.append(uleaf) pack_result.append(tuple(level)) elif isinstance(target, str): return as_unicode(target) else: return target result = pack_result.pop() return result ################################################################################ # Testing if __name__ == '__main__': test_obj = {str('myList'): [str('inList1'), str('inList2')], str('myTuple'): (str('inTuple1'), str('inTuple2')), str('mystr'): str('text'), str('myint'): 99} print repr(test_obj) print repr(recursive_str_to_unicode(test_obj))
pavel-odintsov/ru_open_statistics
helpers/helperUnicode.py
Python
gpl-2.0
3,890
0.001028
from inc import * modFunc.addCommand('suggest', 'suggest', 'suggest') modFunc.addCommand('sug', 'suggest', 'suggest') modFunc.addCommand('issue', 'suggest', 'suggest') modFunc.addCommand('sug-read', 'suggest', 'read') modFunc.addCommand('sug-clear', 'suggest', 'clear') def suggest(line, irc): message, username, msgto = ircFunc.ircMessage(line) combinedMsg = ' '.join(message[1:]) numArgs = len(message) - 1 if numArgs > 0 and combinedMsg.strip() != "": f = open('suggestions.txt' , 'a') f.write(username + ': ' + combinedMsg) f.close() ircFunc.ircSay(username, '%s, thank you for your suggestion... It has been documented and will be reviewed. :)' % username, irc) else: ircFunc.ircSay(username, 'You didnt even suggest anything... :/ Command usage is : !suggest <suggestion goes here>', irc) def read(line, irc): message, username, msgto = ircFunc.ircMessage(line) if username in configFunc.getBotConf('botadmins').split(" "): if (ircFunc.isRegged(username, irc)): with open('suggestions.txt') as sugfile: print 'in with' for sugline in sugfile: ircFunc.ircSay(msgto, sugline, irc) def clear(line, irc): message, username, msgto = ircFunc.ircMessage(line) if username.lower() in configFunc.getBotConf('botadmins').split(" "): if (ircFunc.isRegged(username, irc)): f = open('suggestions.txt', 'w') f.write('Suggestions:' + '\n') f.close() ircFunc.ircSay(username, 'Suggestions Cleared.....', irc)
chris2727/BeastBot
src/inc/modules/suggest.py
Python
gpl-3.0
1,611
0.003724
# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations class Migration(migrations.Migration): dependencies = [ ('studentguide', '0005_add_studentguide_clubs'), ] operations = [ migrations.AddField( model_name='tag', name='image', field=models.FileField(null=True, upload_to=b'studentguide/tags/', blank=True), ), ]
enjaz/enjaz
studentguide/migrations/0006_tag_image.py
Python
agpl-3.0
446
0.002242
# Copyright 2013-2015 Lenna X. Peterson. All rights reserved. from .meta import classproperty class AtomData(object): # Maximum ASA for each residue # from Miller et al. 1987, JMB 196: 641-656 total_asa = { 'A': 113.0, 'R': 241.0, 'N': 158.0, 'D': 151.0, 'C': 140.0, 'Q': 189.0, 'E': 183.0, 'G': 85.0, 'H': 194.0, 'I': 182.0, 'L': 180.0, 'K': 211.0, 'M': 204.0, 'F': 218.0, 'P': 143.0, 'S': 122.0, 'T': 146.0, 'W': 259.0, 'Y': 229.0, 'V': 160.0, } @classmethod def is_surface(cls, resn, asa, total_asa=None, cutoff=0.1): """Return True if ratio of residue ASA to max ASA >= cutoff""" if total_asa is None: total_asa = cls.total_asa resn = resn.upper() if len(resn) == 3: resn = cls.three_to_one[resn] return float(asa) / total_asa[resn] >= cutoff three_to_full = { 'Val': 'Valine', 'Ile': 'Isoleucine', 'Leu': 'Leucine', 'Glu': 'Glutamic acid', 'Gln': 'Glutamine', 'Asp': 'Aspartic acid', 'Asn': 'Asparagine', 'His': 'Histidine', 'Trp': 'Tryptophan', 'Phe': 'Phenylalanine', 'Tyr': 'Tyrosine', 'Arg': 'Arginine', 'Lys': 'Lysine', 'Ser': 'Serine', 'Thr': 'Threonine', 'Met': 'Methionine', 'Ala': 'Alanine', 'Gly': 'Glycine', 'Pro': 'Proline', 'Cys': 'Cysteine'} three_to_one = { 'VAL': 'V', 'ILE': 'I', 'LEU': 'L', 'GLU': 'E', 'GLN': 'Q', 'ASP': 'D', 'ASN': 'N', 'HIS': 'H', 'TRP': 'W', 'PHE': 'F', 'TYR': 'Y', 'ARG': 'R', 'LYS': 'K', 'SER': 'S', 'THR': 'T', 'MET': 'M', 'ALA': 'A', 'GLY': 'G', 'PRO': 'P', 'CYS': 'C'} one_to_three = {o: t for t, o in three_to_one.iteritems()} @classproperty def one_to_full(cls): """ This can't see three_to_full unless explicitly passed because dict comprehensions create their own local scope """ return {o: cls.three_to_full[t.title()] for t, o in cls.three_to_one.iteritems()} res_atom_list = dict( ALA=['C', 'CA', 'CB', 'N', 'O'], ARG=['C', 'CA', 'CB', 'CD', 'CG', 'CZ', 'N', 'NE', 'NH1', 'NH2', 'O'], ASN=['C', 'CA', 'CB', 'CG', 'N', 'ND2', 'O', 'OD1'], ASP=['C', 'CA', 'CB', 'CG', 'N', 'O', 'OD1', 'OD2'], CYS=['C', 'CA', 'CB', 'N', 'O', 'SG'], GLN=['C', 'CA', 'CB', 'CD', 'CG', 'N', 'NE2', 'O', 'OE1'], GLU=['C', 'CA', 'CB', 'CD', 'CG', 'N', 'O', 'OE1', 'OE2'], GLY=['C', 'CA', 'N', 'O'], HIS=['C', 'CA', 'CB', 'CD2', 'CE1', 'CG', 'N', 'ND1', 'NE2', 'O'], ILE=['C', 'CA', 'CB', 'CD1', 'CG1', 'CG2', 'N', 'O'], LEU=['C', 'CA', 'CB', 'CD1', 'CD2', 'CG', 'N', 'O'], LYS=['C', 'CA', 'CB', 'CD', 'CE', 'CG', 'N', 'NZ', 'O'], MET=['C', 'CA', 'CB', 'CE', 'CG', 'N', 'O', 'SD'], PHE=['C', 'CA', 'CB', 'CD1', 'CD2', 'CE1', 'CE2', 'CG', 'CZ', 'N', 'O'], PRO=['C', 'CA', 'CB', 'CD', 'CG', 'N', 'O'], SER=['C', 'CA', 'CB', 'N', 'O', 'OG'], THR=['C', 'CA', 'CB', 'CG2', 'N', 'O', 'OG1'], TRP=['C', 'CA', 'CB', 'CD1', 'CD2', 'CE2', 'CE3', 'CG', 'CH2', 'CZ2', 'CZ3', 'N', 'NE1', 'O'], TYR=['C', 'CA', 'CB', 'CD1', 'CD2', 'CE1', 'CE2', 'CG', 'CZ', 'N', 'O', 'OH'], VAL=['C', 'CA', 'CB', 'CG1', 'CG2', 'N', 'O'], ) all_chi = dict( chi1=dict( ARG=['N', 'CA', 'CB', 'CG'], ASN=['N', 'CA', 'CB', 'CG'], ASP=['N', 'CA', 'CB', 'CG'], CYS=['N', 'CA', 'CB', 'SG'], GLN=['N', 'CA', 'CB', 'CG'], GLU=['N', 'CA', 'CB', 'CG'], HIS=['N', 'CA', 'CB', 'CG'], ILE=['N', 'CA', 'CB', 'CG1'], LEU=['N', 'CA', 'CB', 'CG'], LYS=['N', 'CA', 'CB', 'CG'], MET=['N', 'CA', 'CB', 'CG'], PHE=['N', 'CA', 'CB', 'CG'], PRO=['N', 'CA', 'CB', 'CG'], SER=['N', 'CA', 'CB', 'OG'], THR=['N', 'CA', 'CB', 'OG1'], TRP=['N', 'CA', 'CB', 'CG'], TYR=['N', 'CA', 'CB', 'CG'], VAL=['N', 'CA', 'CB', 'CG1'], ), chi2=dict( ARG=['CA', 'CB', 'CG', 'CD'], ASN=['CA', 'CB', 'CG', 'OD1'], ASP=['CA', 'CB', 'CG', 'OD1'], GLN=['CA', 'CB', 'CG', 'CD'], GLU=['CA', 'CB', 'CG', 'CD'], HIS=['CA', 'CB', 'CG', 'ND1'], ILE=['CA', 'CB', 'CG1', 'CD1'], LEU=['CA', 'CB', 'CG', 'CD1'], LYS=['CA', 'CB', 'CG', 'CD'], MET=['CA', 'CB', 'CG', 'SD'], PHE=['CA', 'CB', 'CG', 'CD1'], PRO=['CA', 'CB', 'CG', 'CD'], TRP=['CA', 'CB', 'CG', 'CD1'], TYR=['CA', 'CB', 'CG', 'CD1'], ), chi3=dict( ARG=['CB', 'CG', 'CD', 'NE'], GLN=['CB', 'CG', 'CD', 'OE1'], GLU=['CB', 'CG', 'CD', 'OE1'], LYS=['CB', 'CG', 'CD', 'CE'], MET=['CB', 'CG', 'SD', 'CE'], ), chi4=dict( ARG=['CG', 'CD', 'NE', 'CZ'], LYS=['CG', 'CD', 'CE', 'NZ'], ), chi5=dict( ARG=['CD', 'NE', 'CZ', 'NH1'], ), ) alt_chi = dict( chi1=dict( VAL=['N', 'CA', 'CB', 'CG2'], ), chi2=dict( ASP=['CA', 'CB', 'CG', 'OD2'], LEU=['CA', 'CB', 'CG', 'CD2'], PHE=['CA', 'CB', 'CG', 'CD2'], TYR=['CA', 'CB', 'CG', 'CD2'], ), ) chi_atoms = dict( ARG=set(['CB', 'CA', 'CG', 'NE', 'N', 'CZ', 'NH1', 'CD']), ASN=set(['CB', 'CA', 'N', 'CG', 'OD1']), ASP=set(['CB', 'CA', 'N', 'CG', 'OD1', 'OD2']), CYS=set(['CB', 'CA', 'SG', 'N']), GLN=set(['CB', 'CA', 'CG', 'N', 'CD', 'OE1']), GLU=set(['CB', 'CA', 'CG', 'N', 'CD', 'OE1']), HIS=set(['ND1', 'CB', 'CA', 'CG', 'N']), ILE=set(['CG1', 'CB', 'CA', 'CD1', 'N']), LEU=set(['CB', 'CA', 'CG', 'CD1', 'CD2', 'N']), LYS=set(['CB', 'CA', 'CG', 'CE', 'N', 'NZ', 'CD']), MET=set(['CB', 'CA', 'CG', 'CE', 'N', 'SD']), PHE=set(['CB', 'CA', 'CG', 'CD1', 'CD2', 'N']), PRO=set(['CB', 'CA', 'N', 'CG', 'CD']), SER=set(['OG', 'CB', 'CA', 'N']), THR=set(['CB', 'CA', 'OG1', 'N']), TRP=set(['CB', 'CA', 'CG', 'CD1', 'N']), TYR=set(['CB', 'CA', 'CG', 'CD1', 'CD2', 'N']), VAL=set(['CG1', 'CG2', 'CB', 'CA', 'N']), )
lennax/util
util/atom_data.py
Python
gpl-3.0
6,616
0.000151
# -*- coding: utf-8 -*- from openerp import models, fields, api from datetime import datetime, timedelta, date from dateutil.relativedelta import relativedelta class Inspection(models.Model): _name = 'property.inspection' _order = 'date desc' _inherit = ['mail.thread', 'ir.needaction_mixin'] property_id = fields.Many2one('property', string='Property ID', required=True, readonly=True) ### inspection ### date = fields.Date(string='Date', required=True,) inspector_id = fields.Many2one('res.users', string='Inspector') act_type = fields.Selection([ ('inspect', 'Tenken'), ('routine_inspection', 'Teikitenken'), ('change', 'Koukan'), ('repair', 'Syuri'), ('coordinate', 'Tyousei'), ('others', 'Other'),], string='Act type') inspection_note = fields.Text(string='Note') product_memo = fields.Text(string='product_memo', help='Koukan sita kiki wo kaitene') ### request ### request_id = fields.Many2one('property.inspection.request', string='Request') request_date = fields.Date(string='request_date', related='request_id.date', readonly=True) requester_name = fields.Char(string='requester_name', related='request_id.partner_id.name', readonly=True) request_note = fields.Text(string='request_note', related='request_id.request_note', readonly=True) responder_name = fields.Char(string='responder_name', related='request_id.user_id.name', readonly=True) ### ### state = fields.Selection([ ('ongoing', 'Taioutyu'), ('arranging', 'Tehaityu'), ('finishing', 'Kanryo'),], string='state') class InspectionRequest(models.Model): _name = 'property.inspection.request' _order = 'date desc' date = fields.Date(string='Date', required=True, copy=False,) partner_id = fields.Many2one('res.partner', string='partner_id',) request_note = fields.Text(string='request_note',) user_id = fields.Many2one('res.users', string='user_id', required=True, help='hosyu no irai wo uketahitoy') @api.model def create(self, vals): if vals.get('name', 'New') == 'New': vals['name'] = self.env['ir.sequence'].next_by_code('inspection.request') or 'New' result = super(InspectionRequest, self).create(vals) return result
ichi23de5/ichi_Repo
property/models/inspection.py
Python
gpl-3.0
2,328
0.007732
#!/usr/bin/env python # -*- coding: utf-8 -*- from runner.koan import * class AboutStringManipulation(Koan): def test_use_format_to_interpolate_variables(self): value1 = 'one' value2 = 2 string = "The values are {0} and {1}".format(value1, value2) self.assertEqual("The values are one and 2", string) def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self): value1 = 'doh' value2 = 'DOH' string = "The values are {1}, {0}, {0} and {1}!".format(value1, value2) self.assertEqual("The values are DOH, doh, doh and DOH!", string) def test_any_python_expression_may_be_interpolated(self): import math # import a standard python module with math functions decimal_places = 4 string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5), \ decimal_places) self.assertEqual("The square root of 5 is 2.2361", string) def test_you_can_get_a_substring_from_a_string(self): string = "Bacon, lettuce and tomato" self.assertEqual("let", string[7:10]) def test_you_can_get_a_single_character_from_a_string(self): string = "Bacon, lettuce and tomato" self.assertEqual("a", string[1]) def test_single_characters_can_be_represented_by_integers(self): self.assertEqual(97, ord('a')) self.assertEqual(True, ord('b') == (ord('a') + 1)) def test_strings_can_be_split(self): string = "Sausage Egg Cheese" words = string.split() self.assertEqual(["Sausage", "Egg", "Cheese"], words) def test_strings_can_be_split_with_different_patterns(self): import re # import python regular expression library string = "the,rain;in,spain" pattern = re.compile(',|;') words = pattern.split(string) self.assertEqual(["the", "rain", "in", "spain"], words) # `pattern` is a Python regular expression pattern which matches # ',' or ';' def test_raw_strings_do_not_interpret_escape_characters(self): string = r'\n' self.assertNotEqual('\n', string) self.assertEqual('\\n', string) self.assertEqual(2, len(string)) # Useful in regular expressions, file paths, URLs, etc. def test_strings_can_be_joined(self): words = ["Now", "is", "the", "time"] self.assertEqual("Now is the time", ' '.join(words)) def test_strings_can_change_case(self): self.assertEqual('Guido', 'guido'.capitalize()) self.assertEqual('GUIDO', 'guido'.upper()) self.assertEqual('timbot', 'TimBot'.lower()) self.assertEqual('Guido Van Rossum', 'guido van rossum'.title()) self.assertEqual('tOtAlLy AwEsOmE', 'ToTaLlY aWeSoMe'.swapcase())
fengren/python_koans
python2/koans/about_string_manipulation.py
Python
mit
2,781
0.000719
import numpy from PIL import Image import sys #if len(sys.argv) != 3: # sys.exit('usage: dice.py path_to_segmented_image path_to_ground_truth_image') pairs = [['/home/ognawala/data/PatientMS-R/20140120T143753/20140120T143753_annotated_rf.png', '/home/ognawala/data/Patient-Mask/20140120T143753-mask.png'], ['/home/ognawala/data/PatientMS-R/20140120T150515/20140120T150515_annotated_rf.png', '/home/ognawala/data/Patient-Mask/20140120T150515-mask.png']] # intersection set n_aib = 0 #individual markings n_y = 0 n_truth = 0 for p in pairs: y = Image.open(p[0]) y = numpy.array(y, dtype='uint8') print p[0] print y.shape truth_im = Image.open(p[1]) truth_y = numpy.array(truth_im, dtype='uint8') print p[1] print truth_y.shape # flatten arrays truth_y = truth_y.flatten() y = y.flatten() print truth_y.shape print y.shape for i in range(len(y)): # both marked? if y[i]==200 and truth_y[i]==0: n_aib += 1 # y marked if y[i]==200: n_y += 1 # truth marked if truth_y[i]==0: n_truth += 1 dice = float(2*n_aib)/float(n_y+n_truth) print dice
saahil/MSSegmentation
dice.py
Python
gpl-2.0
1,199
0.010008
# -*- coding: utf-8 -*- """ .. _tut-artifact-overview: Overview of artifact detection ============================== This tutorial covers the basics of artifact detection, and introduces the artifact detection tools available in MNE-Python. We begin as always by importing the necessary Python modules and loading some :ref:`example data <sample-dataset>`: """ import os import numpy as np import mne sample_data_folder = mne.datasets.sample.data_path() sample_data_raw_file = os.path.join(sample_data_folder, 'MEG', 'sample', 'sample_audvis_raw.fif') raw = mne.io.read_raw_fif(sample_data_raw_file) raw.crop(0, 60).load_data() # just use a fraction of data for speed here ############################################################################### # What are artifacts? # ^^^^^^^^^^^^^^^^^^^ # # Artifacts are parts of the recorded signal that arise from sources other than # the source of interest (i.e., neuronal activity in the brain). As such, # artifacts are a form of interference or noise relative to the signal of # interest. There are many possible causes of such interference, for example: # # - Environmental artifacts # - Persistent oscillations centered around the `AC power line frequency`_ # (typically 50 or 60 Hz) # - Brief signal jumps due to building vibration (such as a door slamming) # - Electromagnetic field noise from nearby elevators, cell phones, the # geomagnetic field, etc. # # - Instrumentation artifacts # - Electromagnetic interference from stimulus presentation (such as EEG # sensors picking up the field generated by unshielded headphones) # - Continuous oscillations at specific frequencies used by head position # indicator (HPI) coils # - Random high-amplitude fluctuations (or alternatively, constant zero # signal) in a single channel due to sensor malfunction (e.g., in surface # electrodes, poor scalp contact) # # - Biological artifacts # - Periodic `QRS`_-like signal patterns (especially in magnetometer # channels) due to electrical activity of the heart # - Short step-like deflections (especially in frontal EEG channels) due to # eye movements # - Large transient deflections (especially in frontal EEG channels) due to # blinking # - Brief bursts of high frequency fluctuations across several channels due # to the muscular activity during swallowing # # There are also some cases where signals from within the brain can be # considered artifactual. For example, if a researcher is primarily interested # in the sensory response to a stimulus, but the experimental paradigm involves # a behavioral response (such as button press), the neural activity associated # with the planning and executing the button press could be considered an # artifact relative to signal of interest (i.e., the evoked sensory response). # # .. note:: # Artifacts of the same genesis may appear different in recordings made by # different EEG or MEG systems, due to differences in sensor design (e.g., # passive vs. active EEG electrodes; axial vs. planar gradiometers, etc). # # # What to do about artifacts # ^^^^^^^^^^^^^^^^^^^^^^^^^^ # # There are 3 basic options when faced with artifacts in your recordings: # # 1. *Ignore* the artifact and carry on with analysis # 2. *Exclude* the corrupted portion of the data and analyze the remaining data # 3. *Repair* the artifact by suppressing artifactual part of the recording # while (hopefully) leaving the signal of interest intact # # There are many different approaches to repairing artifacts, and MNE-Python # includes a variety of tools for artifact repair, including digital filtering, # independent components analysis (ICA), Maxwell filtering / signal-space # separation (SSS), and signal-space projection (SSP). Separate tutorials # demonstrate each of these techniques for artifact repair. Many of the # artifact repair techniques work on both continuous (raw) data and on data # that has already been epoched (though not necessarily equally well); some can # be applied to `memory-mapped`_ data while others require the data to be # copied into RAM. Of course, before you can choose any of these strategies you # must first *detect* the artifacts, which is the topic of the next section. # # # Artifact detection # ^^^^^^^^^^^^^^^^^^ # # MNE-Python includes a few tools for automated detection of certain artifacts # (such as heartbeats and blinks), but of course you can always visually # inspect your data to identify and annotate artifacts as well. # # We saw in :ref:`the introductory tutorial <tut-overview>` that the example # data includes :term:`SSP projectors <projector>`, so before we look at # artifacts let's set aside the projectors in a separate variable and then # remove them from the :class:`~mne.io.Raw` object using the # :meth:`~mne.io.Raw.del_proj` method, so that we can inspect our data in it's # original, raw state: ssp_projectors = raw.info['projs'] raw.del_proj() ############################################################################### # Low-frequency drifts # ~~~~~~~~~~~~~~~~~~~~ # # Low-frequency drifts are most readily detected by visual inspection using the # basic :meth:`~mne.io.Raw.plot` method, though it is helpful to plot a # relatively long time span and to disable channel-wise DC shift correction. # Here we plot 60 seconds and show all the magnetometer channels: mag_channels = mne.pick_types(raw.info, meg='mag') raw.plot(duration=60, order=mag_channels, n_channels=len(mag_channels), remove_dc=False) ############################################################################### # Low-frequency drifts are readily removed by high-pass filtering at a fairly # low cutoff frequency (the wavelength of the drifts seen above is probably # around 20 seconds, so in this case a cutoff of 0.1 Hz would probably suppress # most of the drift). # # # Power line noise # ~~~~~~~~~~~~~~~~ # # Power line artifacts are easiest to see on plots of the spectrum, so we'll # use :meth:`~mne.io.Raw.plot_psd` to illustrate. fig = raw.plot_psd(tmax=np.inf, fmax=250, average=True) # add some arrows at 60 Hz and its harmonics: for ax in fig.axes[1:]: freqs = ax.lines[-1].get_xdata() psds = ax.lines[-1].get_ydata() for freq in (60, 120, 180, 240): idx = np.searchsorted(freqs, freq) ax.arrow(x=freqs[idx], y=psds[idx] + 18, dx=0, dy=-12, color='red', width=0.1, head_width=3, length_includes_head=True) ############################################################################### # Here we see narrow frequency peaks at 60, 120, 180, and 240 Hz — the power # line frequency of the USA (where the sample data was recorded) and its 2nd, # 3rd, and 4th harmonics. Other peaks (around 25 to 30 Hz, and the second # harmonic of those) are probably related to the heartbeat, which is more # easily seen in the time domain using a dedicated heartbeat detection function # as described in the next section. # # # Heartbeat artifacts (ECG) # ~~~~~~~~~~~~~~~~~~~~~~~~~ # # MNE-Python includes a dedicated function # :func:`~mne.preprocessing.find_ecg_events` in the :mod:`mne.preprocessing` # submodule, for detecting heartbeat artifacts from either dedicated ECG # channels or from magnetometers (if no ECG channel is present). Additionally, # the function :func:`~mne.preprocessing.create_ecg_epochs` will call # :func:`~mne.preprocessing.find_ecg_events` under the hood, and use the # resulting events array to extract epochs centered around the detected # heartbeat artifacts. Here we create those epochs, then show an image plot of # the detected ECG artifacts along with the average ERF across artifacts. We'll # show all three channel types, even though EEG channels are less strongly # affected by heartbeat artifacts: # sphinx_gallery_thumbnail_number = 4 ecg_epochs = mne.preprocessing.create_ecg_epochs(raw) ecg_epochs.plot_image(combine='mean') ############################################################################### # The horizontal streaks in the magnetometer image plot reflect the fact that # the heartbeat artifacts are superimposed on low-frequency drifts like the one # we saw in an earlier section; to avoid this you could pass # ``baseline=(-0.5, -0.2)`` in the call to # :func:`~mne.preprocessing.create_ecg_epochs`. # You can also get a quick look at the # ECG-related field pattern across sensors by averaging the ECG epochs together # via the :meth:`~mne.Epochs.average` method, and then using the # :meth:`mne.Evoked.plot_topomap` method: avg_ecg_epochs = ecg_epochs.average().apply_baseline((-0.5, -0.2)) ############################################################################### # Here again we can visualize the spatial pattern of the associated field at # various times relative to the peak of the EOG response: avg_ecg_epochs.plot_topomap(times=np.linspace(-0.05, 0.05, 11)) ############################################################################### # Or, we can get an ERP/F plot with :meth:`~mne.Evoked.plot` or a combined # scalp field maps and ERP/F plot with :meth:`~mne.Evoked.plot_joint`. Here # we've specified the times for scalp field maps manually, but if not provided # they will be chosen automatically based on peaks in the signal: avg_ecg_epochs.plot_joint(times=[-0.25, -0.025, 0, 0.025, 0.25]) ############################################################################### # Ocular artifacts (EOG) # ~~~~~~~~~~~~~~~~~~~~~~ # # Similar to the ECG detection and epoching methods described above, MNE-Python # also includes functions for detecting and extracting ocular artifacts: # :func:`~mne.preprocessing.find_eog_events` and # :func:`~mne.preprocessing.create_eog_epochs`. Once again we'll use the # higher-level convenience function that automatically finds the artifacts and # extracts them in to an :class:`~mne.Epochs` object in one step. Unlike the # heartbeat artifacts seen above, ocular artifacts are usually most prominent # in the EEG channels, but we'll still show all three channel types. We'll use # the ``baseline`` parameter this time too; note that there are many fewer # blinks than heartbeats, which makes the image plots appear somewhat blocky: eog_epochs = mne.preprocessing.create_eog_epochs(raw, baseline=(-0.5, -0.2)) eog_epochs.plot_image(combine='mean') eog_epochs.average().plot_joint() ############################################################################### # Summary # ^^^^^^^ # # Familiarizing yourself with typical artifact patterns and magnitudes is a # crucial first step in assessing the efficacy of later attempts to repair # those artifacts. A good rule of thumb is that the artifact amplitudes should # be orders of magnitude larger than your signal of interest — and there should # be several occurrences of such events — in order to find signal # decompositions that effectively estimate and repair the artifacts. # # Several other tutorials in this section illustrate the various tools for # artifact repair, and discuss the pros and cons of each technique, for # example: # # - :ref:`tut-artifact-ssp` # - :ref:`tut-artifact-ica` # - :ref:`tut-artifact-sss` # # There are also tutorials on general-purpose preprocessing steps such as # :ref:`filtering and resampling <tut-filter-resample>` and :ref:`excluding # bad channels <tut-bad-channels>` or :ref:`spans of data # <tut-reject-data-spans>`. # # .. LINKS # # .. _`AC power line frequency`: # https://en.wikipedia.org/wiki/Mains_electricity # .. _`QRS`: https://en.wikipedia.org/wiki/QRS_complex # .. _`memory-mapped`: https://en.wikipedia.org/wiki/Memory-mapped_file
kambysese/mne-python
tutorials/preprocessing/plot_10_preprocessing_overview.py
Python
bsd-3-clause
11,702
0
#! /usr/bin/env python """ couchbasekit.fields ~~~~~~~~~~~~~~~~~~~ :website: http://github.com/kirpit/couchbasekit :copyright: Copyright 2013, Roy Enjoy <kirpit *at* gmail.com>, see AUTHORS.txt. :license: MIT, see LICENSE.txt for details. * :class:`couchbasekit.fields.CustomField` * :class:`couchbasekit.fields.ChoiceField` * :class:`couchbasekit.fields.EmailField` * :class:`couchbasekit.fields.PasswordField` """ import re from abc import ABCMeta class CustomField(object): """The abstract custom field to be extended by all other field classes. .. note:: You can also create your own custom field types by implementing this class. All you have to do is to assign your final (that is calculated and ready to be saved) value to the :attr:`value` property. Please note that it should also accept unicode raw values, which are fetched and returned from couchbase server. See :class:`PasswordField` source code as an example. Please contribute back if you create a generic and useful custom field. """ __metaclass__ = ABCMeta _value = None def __init__(self): raise NotImplementedError() def __repr__(self): return repr(self.value) def __eq__(self, other): if type(other) is type(self) and other.value==self.value: return True return False def __ne__(self, other): return not self.__eq__(other) @property def value(self): """Property to be used when saving a custom field into :class:`couchbasekit.document.Document` instance. :returns: The value to be saved for the field within :class:`couchbasekit.document.Document` instances. :rtype: mixed """ if self._value is None: raise ValueError("%s's 'value' is not set." % type(self).__name__) return self._value @value.setter def value(self, value): """Propery setter that should be used to assign final (calculated) value. """ self._value = value class ChoiceField(CustomField): """The custom field to be used for multi choice options such as gender, static category list etc. This class can't be used directly that has to be extended by your choice list class. Thankfully, it's just easy:: class Gender(ChoiceField): CHOICES = { 'M': 'Male', 'F': 'Female', } and all you have to do is to pass the current value to create your choice object: >>> choice = Gender('F') >>> choice.value 'F' >>> choice.text 'Female' :param choice: The choice value. :type choice: basestring """ __metaclass__ = ABCMeta CHOICES = {} def __eq__(self, other): if super(ChoiceField, self).__eq__(other) and other.CHOICES==self.CHOICES: return True return False def __init__(self, choice): if not isinstance(self.CHOICES, dict) or not len(self.CHOICES): raise AttributeError("ChoiceFields must have dictionary 'CHOICES' " "attribute and cannot be empty.") if choice not in self.CHOICES: raise ValueError("Default choice for %s must be " "within the 'CHOICES' attribute." % type(self).__name__) self.value = choice @property def text(self): """Returns the text of the current choice, object property. :rtype: unicode """ return self.CHOICES.get(self.value) def iteritems(self): return self.CHOICES.iteritems() # stolen from django email validator: EMAIL_RE = re.compile( r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*" # dot-atom # quoted-string, see also http://tools.ietf.org/html/rfc2822#section-3.2.5 r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"' r')@((?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)$)' # domain r'|\[(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\]$', re.IGNORECASE) # literal form, ipv4 address (SMTP 4.1.3) class EmailField(CustomField): """The custom field to be used for email addresses and intended to validate them as well. :param email: Email address to be saved. :type email: basestring """ def __init__(self, email): if not self.is_valid(email): raise ValueError("Email address is invalid.") self.value = email @staticmethod def is_valid(email): """Email address validation method. :param email: Email address to be saved. :type email: basestring :returns: True if email address is correct, False otherwise. :rtype: bool """ if isinstance(email, basestring) and EMAIL_RE.match(email): return True return False class PasswordField(CustomField): """The custom field to be used for password types. It encrypts the raw passwords on-the-fly and depends on `py-bcrypt` library for such encryption. :param password: Raw or encrypted password value. :type password: unicode :raises: :exc:`ImportError` if `py-bcrypt` was not found. """ LOG_ROUNDS = 12 def __init__(self, password): if not isinstance(password, basestring): raise ValueError("Password must be a string or unicode.") # do the encryption if raw password provided if not password.startswith(('$2a$', '$2y$')): bcrypt = self.get_bcrypt() password = bcrypt.hashpw(password, bcrypt.gensalt(self.LOG_ROUNDS)) self.value = password @staticmethod def get_bcrypt(): """Returns the `py-bcrypt` library for internal usage. :returns: `py-bcrypt` package. :raises: :exc:`ImportError` if `py-bcrypt` was not found. """ try: import bcrypt except ImportError: raise ImportError("PasswordField requires 'py-bcrypt' " "library to hash the passwords.") else: return bcrypt def check_password(self, raw_password): """Validates the given raw password against the intance's encrypted one. :param raw_password: Raw password to be checked against. :type raw_password: unicode :returns: True if comparison was successful, False otherwise. :rtype: bool :raises: :exc:`ImportError` if `py-bcrypt` was not found. """ bcrypt = self.get_bcrypt() return bcrypt.hashpw(raw_password, self.value)==self.value
kirpit/couchbasekit
couchbasekit/fields.py
Python
mit
6,692
0.002241
# Copyright (c) 2015, MapR Technologies # # 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 sahara.i18n import _ import sahara.plugins.mapr.versions.version_handler_factory as vhf import sahara.plugins.provisioning as p class MapRPlugin(p.ProvisioningPluginBase): title = 'MapR Hadoop Distribution' description = _('The MapR Distribution provides a full Hadoop stack that' ' includes the MapR File System (MapR-FS), MapReduce,' ' a complete Hadoop ecosystem, and the MapR Control System' ' user interface') def _get_handler(self, hadoop_version): return vhf.VersionHandlerFactory.get().get_handler(hadoop_version) def get_title(self): return MapRPlugin.title def get_description(self): return MapRPlugin.description def get_versions(self): return vhf.VersionHandlerFactory.get().get_versions() def get_node_processes(self, hadoop_version): return self._get_handler(hadoop_version).get_node_processes() def get_configs(self, hadoop_version): return self._get_handler(hadoop_version).get_configs() def configure_cluster(self, cluster): self._get_handler(cluster.hadoop_version).configure_cluster(cluster) def start_cluster(self, cluster): self._get_handler(cluster.hadoop_version).start_cluster(cluster) def validate(self, cluster): self._get_handler(cluster.hadoop_version).validate(cluster) def validate_scaling(self, cluster, existing, additional): v_handler = self._get_handler(cluster.hadoop_version) v_handler.validate_scaling(cluster, existing, additional) def scale_cluster(self, cluster, instances): v_handler = self._get_handler(cluster.hadoop_version) v_handler.scale_cluster(cluster, instances) def decommission_nodes(self, cluster, instances): v_handler = self._get_handler(cluster.hadoop_version) v_handler.decommission_nodes(cluster, instances) def get_edp_engine(self, cluster, job_type): v_handler = self._get_handler(cluster.hadoop_version) return v_handler.get_edp_engine(cluster, job_type) def get_open_ports(self, node_group): v_handler = self._get_handler(node_group.cluster.hadoop_version) return v_handler.get_open_ports(node_group)
esikachev/scenario
sahara/plugins/mapr/plugin.py
Python
apache-2.0
2,850
0
# This code is part of Ansible, but is an independent component. # This particular file snippet, and this file snippet only, is BSD licensed. # Modules you write using this snippet, which is embedded dynamically by Ansible # still belong to the author of the module, and may assign their own license # to the complete work. # # Copyright (c) 2014 Hewlett-Packard Development Company, L.P. # All rights reserved. # # Redistribution and use in source and binary forms, with or without modification, # are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * 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. import os def openstack_argument_spec(): # DEPRECATED: This argument spec is only used for the deprecated old # OpenStack modules. It turns out that modern OpenStack auth is WAY # more complex than this. # Consume standard OpenStack environment variables. # This is mainly only useful for ad-hoc command line operation as # in playbooks one would assume variables would be used appropriately OS_AUTH_URL=os.environ.get('OS_AUTH_URL', 'http://127.0.0.1:35357/v2.0/') OS_PASSWORD=os.environ.get('OS_PASSWORD', None) OS_REGION_NAME=os.environ.get('OS_REGION_NAME', None) OS_USERNAME=os.environ.get('OS_USERNAME', 'admin') OS_TENANT_NAME=os.environ.get('OS_TENANT_NAME', OS_USERNAME) spec = dict( login_username = dict(default=OS_USERNAME), auth_url = dict(default=OS_AUTH_URL), region_name = dict(default=OS_REGION_NAME), availability_zone = dict(default=None), ) if OS_PASSWORD: spec['login_password'] = dict(default=OS_PASSWORD) else: spec['login_password'] = dict(required=True) if OS_TENANT_NAME: spec['login_tenant_name'] = dict(default=OS_TENANT_NAME) else: spec['login_tenant_name'] = dict(required=True) return spec def openstack_find_nova_addresses(addresses, ext_tag, key_name=None): ret = [] for (k, v) in addresses.iteritems(): if key_name and k == key_name: ret.extend([addrs['addr'] for addrs in v]) else: for interface_spec in v: if 'OS-EXT-IPS:type' in interface_spec and interface_spec['OS-EXT-IPS:type'] == ext_tag: ret.append(interface_spec['addr']) return ret def openstack_full_argument_spec(**kwargs): spec = dict( cloud=dict(default=None), auth_type=dict(default=None), auth=dict(default=None, no_log=True), region_name=dict(default=None), availability_zone=dict(default=None), verify=dict(default=True, aliases=['validate_certs']), cacert=dict(default=None), cert=dict(default=None), key=dict(default=None, no_log=True), wait=dict(default=True, type='bool'), timeout=dict(default=180, type='int'), api_timeout=dict(default=None, type='int'), endpoint_type=dict( default='public', choices=['public', 'internal', 'admin'] ) ) spec.update(kwargs) return spec def openstack_module_kwargs(**kwargs): ret = {} for key in ('mutually_exclusive', 'required_together', 'required_one_of'): if key in kwargs: if key in ret: ret[key].extend(kwargs[key]) else: ret[key] = kwargs[key] return ret
matburt/ansible
lib/ansible/module_utils/openstack.py
Python
gpl-3.0
4,528
0.006846
# -*- encoding: utf-8 -*- ############################################################################## # # Account Journal Always Check Date module for OpenERP # Copyright (C) 2013-2014 Akretion (http://www.akretion.com) # @author Alexis de Lattre <alexis.delattre@akretion.com> # # 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/>. # ############################################################################## { 'name': 'Account Journal Always Check Date', 'version': '0.1', 'category': 'Accounting & Finance', 'license': 'AGPL-3', 'summary': 'Option Check Date in Period always active on journals', 'description': """ Check Date in Period always active on Account Journals ====================================================== This module: * activates the 'Check Date in Period' option on all existing account journals, * enable the 'Check Date in Period' option on new account journals, * prevent users from deactivating the 'Check Date in Period' option. So this module is an additionnal security for countries where, on an account move, the date must be inside the period. Please contact Alexis de Lattre from Akretion <alexis.delattre@akretion.com> for any help or question about this module. """, 'author': "Akretion,Odoo Community Association (OCA)", 'website': 'http://www.akretion.com', 'depends': ['account'], 'data': [], 'installable': True, 'active': False, }
raycarnes/account-financial-tools
account_journal_always_check_date/__openerp__.py
Python
agpl-3.0
2,081
0
# -*- coding: utf-8 -*- # © 2016 Cristian Moncho <cristian.moncho@diagram.es> # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html). import logging _logger = logging.getLogger(__name__) _LOADED_VCS = [] def load_vcs(vcs): vcs = vcs.lower() modname = 'vcs.%s' % (vcs,) clsname = vcs.title().replace('_', '') try: mod = getattr(__import__(modname, globals(), locals(), [], -1), vcs) return getattr(mod, clsname) except AttributeError: raise Exception( 'Wrapper not found: from %s import %s' % (modname, clsname)) # [TODO] Automatically detect *.py files in 'vcs' folder for vcs in ('git', 'bzr', 'hg', 'svn'): try: _LOADED_VCS.append((vcs, load_vcs(vcs))) except Exception as e: _logger.warning('Unable to load "%s" module: %s', vcs, e) _logger.debug('Enabled VCS: %s', ', '.join(t[0] for t in _LOADED_VCS)) class VcsWrapper(object): """ Version Control System Wrapper. """ def __new__(cls, vcs, path, **kwargs): if not vcs: vcs = cls._guess_vcs(path) try: return dict(_LOADED_VCS)[vcs](path, **kwargs) except KeyError: raise Exception('Unknown repository structure in %s' % (path,)) @classmethod def available_vcs(cls): return zip(*_LOADED_VCS)[0] if _LOADED_VCS else () @classmethod def from_source(cls, vcs, path, source, branch=None, **kwargs): res = cls(vcs, path) res.init(source, branch=branch, **kwargs) res.load() return res @classmethod def from_dir(cls, vcs, path, **kwargs): res = cls(vcs, path) res.load(**kwargs) return res @staticmethod def _guess_vcs(path): """ Inspect the given path and search which VCS wrapper needs. """ for vcs, cls in _LOADED_VCS: if cls.is_repo(path): return vcs
crimoniv/odoo-module-tools
repository_management/vcs_wrapper/vcs_wrapper.py
Python
agpl-3.0
1,918
0
# This file is part of Indico. # Copyright (C) 2002 - 2016 European Organization for Nuclear Research (CERN). # # Indico 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. # # Indico 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 Indico; if not, see <http://www.gnu.org/licenses/>. from __future__ import unicode_literals from datetime import timedelta from sqlalchemy import DDL from sqlalchemy.event import listens_for from sqlalchemy.ext.declarative import declared_attr from sqlalchemy.ext.hybrid import hybrid_property from sqlalchemy.orm.base import NEVER_SET, NO_VALUE from indico.core.db import db from indico.core.db.sqlalchemy import UTCDateTime, PyIntEnum from indico.core.db.sqlalchemy.util.models import populate_one_to_one_backrefs from indico.util.date_time import overlaps from indico.util.locators import locator_property from indico.util.string import format_repr, return_ascii from indico.util.struct.enum import TitledIntEnum from indico.util.i18n import _ class TimetableEntryType(TitledIntEnum): __titles__ = [None, _("Session Block"), _("Contribution"), _("Break")] # entries are uppercase since `break` is a keyword... SESSION_BLOCK = 1 CONTRIBUTION = 2 BREAK = 3 def _make_check(type_, *cols): all_cols = {'session_block_id', 'contribution_id', 'break_id'} required_cols = all_cols & set(cols) forbidden_cols = all_cols - required_cols criteria = ['{} IS NULL'.format(col) for col in sorted(forbidden_cols)] criteria += ['{} IS NOT NULL'.format(col) for col in sorted(required_cols)] condition = 'type != {} OR ({})'.format(type_, ' AND '.join(criteria)) return db.CheckConstraint(condition, 'valid_{}'.format(type_.name.lower())) class TimetableEntry(db.Model): __tablename__ = 'timetable_entries' @declared_attr def __table_args__(cls): return (db.Index('ix_timetable_entries_start_dt_desc', cls.start_dt.desc()), _make_check(TimetableEntryType.SESSION_BLOCK, 'session_block_id'), _make_check(TimetableEntryType.CONTRIBUTION, 'contribution_id'), _make_check(TimetableEntryType.BREAK, 'break_id'), db.CheckConstraint("type != {} OR parent_id IS NULL".format(TimetableEntryType.SESSION_BLOCK), 'valid_parent'), {'schema': 'events'}) id = db.Column( db.Integer, primary_key=True ) event_id = db.Column( db.Integer, db.ForeignKey('events.events.id'), index=True, nullable=False ) parent_id = db.Column( db.Integer, db.ForeignKey('events.timetable_entries.id'), index=True, nullable=True, ) session_block_id = db.Column( db.Integer, db.ForeignKey('events.session_blocks.id'), index=True, unique=True, nullable=True ) contribution_id = db.Column( db.Integer, db.ForeignKey('events.contributions.id'), index=True, unique=True, nullable=True ) break_id = db.Column( db.Integer, db.ForeignKey('events.breaks.id'), index=True, unique=True, nullable=True ) type = db.Column( PyIntEnum(TimetableEntryType), nullable=False ) start_dt = db.Column( UTCDateTime, nullable=False ) event_new = db.relationship( 'Event', lazy=True, backref=db.backref( 'timetable_entries', order_by=lambda: TimetableEntry.start_dt, cascade='all, delete-orphan', lazy='dynamic' ) ) session_block = db.relationship( 'SessionBlock', lazy=False, backref=db.backref( 'timetable_entry', cascade='all, delete-orphan', uselist=False, lazy=True ) ) contribution = db.relationship( 'Contribution', lazy=False, backref=db.backref( 'timetable_entry', cascade='all, delete-orphan', uselist=False, lazy=True ) ) break_ = db.relationship( 'Break', cascade='all, delete-orphan', single_parent=True, lazy=False, backref=db.backref( 'timetable_entry', cascade='all, delete-orphan', uselist=False, lazy=True ) ) children = db.relationship( 'TimetableEntry', order_by='TimetableEntry.start_dt', lazy=True, backref=db.backref( 'parent', remote_side=[id], lazy=True ) ) # relationship backrefs: # - parent (TimetableEntry.children) @property def object(self): if self.type == TimetableEntryType.SESSION_BLOCK: return self.session_block elif self.type == TimetableEntryType.CONTRIBUTION: return self.contribution elif self.type == TimetableEntryType.BREAK: return self.break_ @object.setter def object(self, value): from indico.modules.events.contributions import Contribution from indico.modules.events.sessions.models.blocks import SessionBlock from indico.modules.events.timetable.models.breaks import Break self.session_block = self.contribution = self.break_ = None if isinstance(value, SessionBlock): self.session_block = value elif isinstance(value, Contribution): self.contribution = value elif isinstance(value, Break): self.break_ = value elif value is not None: raise TypeError('Unexpected object: {}'.format(value)) @hybrid_property def duration(self): return self.object.duration if self.object is not None else None @duration.setter def duration(self, value): self.object.duration = value @duration.expression def duration(cls): from indico.modules.events.contributions import Contribution from indico.modules.events.sessions.models.blocks import SessionBlock from indico.modules.events.timetable.models.breaks import Break return db.case({ TimetableEntryType.SESSION_BLOCK.value: db.select([SessionBlock.duration]) .where(SessionBlock.id == cls.session_block_id) .correlate_except(SessionBlock) .as_scalar(), TimetableEntryType.CONTRIBUTION.value: db.select([Contribution.duration]) .where(Contribution.id == cls.contribution_id) .correlate_except(Contribution) .as_scalar(), TimetableEntryType.BREAK.value: db.select([Break.duration]) .where(Break.id == cls.break_id) .correlate_except(Break) .as_scalar(), }, value=cls.type) @hybrid_property def end_dt(self): if self.start_dt is None or self.duration is None: return None return self.start_dt + self.duration @end_dt.expression def end_dt(cls): return cls.start_dt + cls.duration @property def session_siblings(self): if self.type == TimetableEntryType.SESSION_BLOCK: return [x for x in self.siblings if x.session_block and x.session_block.session == self.session_block.session] elif self.parent: return self.siblings else: return [] @property def siblings(self): from indico.modules.events.timetable.util import get_top_level_entries, get_nested_entries tzinfo = self.event_new.tzinfo day = self.start_dt.astimezone(tzinfo).date() siblings = (get_nested_entries(self.event_new)[self.parent_id] if self.parent_id else get_top_level_entries(self.event_new)) return [x for x in siblings if x.start_dt.astimezone(tzinfo).date() == day and x.id != self.id] @property def siblings_query(self): tzinfo = self.event_new.tzinfo day = self.start_dt.astimezone(tzinfo).date() criteria = (TimetableEntry.id != self.id, TimetableEntry.parent == self.parent, db.cast(TimetableEntry.start_dt.astimezone(tzinfo), db.Date) == day) return TimetableEntry.query.with_parent(self.event_new).filter(*criteria) @locator_property def locator(self): return dict(self.event_new.locator, entry_id=self.id) @return_ascii def __repr__(self): return format_repr(self, 'id', 'type', 'start_dt', 'end_dt', _repr=self.object) def can_view(self, user): """Checks whether the user will see this entry in the timetable.""" if self.type in (TimetableEntryType.CONTRIBUTION, TimetableEntryType.BREAK): return self.object.can_access(user) elif self.type == TimetableEntryType.SESSION_BLOCK: if self.object.can_access(user): return True return any(x.can_access(user) for x in self.object.contributions if not x.is_inheriting) def extend_start_dt(self, start_dt): assert start_dt < self.start_dt extension = self.start_dt - start_dt self.start_dt = start_dt self.duration = self.duration + extension def extend_end_dt(self, end_dt): diff = end_dt - self.end_dt if diff < timedelta(0): raise ValueError("New end_dt is before current end_dt.") self.duration += diff def extend_parent(self, by_start=True, by_end=True): """Extend start/end of parent objects if needed. No extension if performed for entries crossing a day boundary in the event timezone. :param by_start: Extend parent by start datetime. :param by_end: Extend parent by end datetime. """ tzinfo = self.event_new.tzinfo if self.start_dt.astimezone(tzinfo).date() != self.end_dt.astimezone(tzinfo).date(): return if self.parent is None: if by_start and self.start_dt < self.event_new.start_dt: self.event_new.start_dt = self.start_dt if by_end and self.end_dt > self.event_new.end_dt: self.event_new.end_dt = self.end_dt else: extended = False if by_start and self.start_dt < self.parent.start_dt: self.parent.extend_start_dt(self.start_dt) extended = True if by_end and self.end_dt > self.parent.end_dt: self.parent.extend_end_dt(self.end_dt) extended = True if extended: self.parent.extend_parent(by_start=by_start, by_end=by_end) def is_parallel(self, in_session=False): siblings = self.siblings if not in_session else self.session_siblings for sibling in siblings: if overlaps((self.start_dt, self.end_dt), (sibling.start_dt, sibling.end_dt)): return True return False def move(self, start_dt): """Move the entry to start at a different time. This method automatically moves children of the entry to preserve their start time relative to the parent's start time. """ if self.type == TimetableEntryType.SESSION_BLOCK: diff = start_dt - self.start_dt for child in self.children: child.start_dt += diff self.start_dt = start_dt def move_next_to(self, sibling, position='before'): if sibling not in self.siblings: raise ValueError("Not a sibling") if position not in ('before', 'after'): raise ValueError("Invalid position") if position == 'before': start_dt = sibling.start_dt - self.duration else: start_dt = sibling.end_dt self.move(start_dt) @listens_for(TimetableEntry.__table__, 'after_create') def _add_timetable_consistency_trigger(target, conn, **kw): sql = """ CREATE CONSTRAINT TRIGGER consistent_timetable AFTER INSERT OR UPDATE ON {} DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE events.check_timetable_consistency('timetable_entry'); """.format(target.fullname) DDL(sql).execute(conn) @listens_for(TimetableEntry.session_block, 'set') def _set_session_block(target, value, *unused): target.type = TimetableEntryType.SESSION_BLOCK @listens_for(TimetableEntry.contribution, 'set') def _set_contribution(target, value, *unused): target.type = TimetableEntryType.CONTRIBUTION @listens_for(TimetableEntry.break_, 'set') def _set_break(target, value, *unused): target.type = TimetableEntryType.BREAK @listens_for(TimetableEntry.start_dt, 'set') def _set_start_dt(target, value, oldvalue, *unused): from indico.modules.events.util import register_time_change if oldvalue in (NEVER_SET, NO_VALUE): return if value != oldvalue and target.object is not None: register_time_change(target) populate_one_to_one_backrefs(TimetableEntry, 'session_block', 'contribution', 'break_')
DavidAndreev/indico
indico/modules/events/timetable/models/entries.py
Python
gpl-3.0
13,696
0.001168
from __future__ import absolute_import, unicode_literals import unittest from mopidy.internal import path from mopidy.models import Album, Artist, Playlist, TlTrack, Track from mopidy.mpd import translator class TrackMpdFormatTest(unittest.TestCase): track = Track( uri='a uri', artists=[Artist(name='an artist')], name='a name', album=Album( name='an album', num_tracks=13, artists=[Artist(name='an other artist')]), track_no=7, composers=[Artist(name='a composer')], performers=[Artist(name='a performer')], genre='a genre', date='1977-01-01', disc_no=1, comment='a comment', length=137000, ) def setUp(self): # noqa: N802 self.media_dir = '/dir/subdir' path.mtime.set_fake_time(1234567) def tearDown(self): # noqa: N802 path.mtime.undo_fake() def test_track_to_mpd_format_for_empty_track(self): # TODO: this is likely wrong, see: # https://github.com/mopidy/mopidy/issues/923#issuecomment-79584110 result = translator.track_to_mpd_format(Track()) self.assertIn(('file', ''), result) self.assertIn(('Time', 0), result) self.assertIn(('Artist', ''), result) self.assertIn(('Title', ''), result) self.assertIn(('Album', ''), result) self.assertIn(('Track', 0), result) self.assertNotIn(('Date', ''), result) self.assertEqual(len(result), 6) def test_track_to_mpd_format_with_position(self): result = translator.track_to_mpd_format(Track(), position=1) self.assertNotIn(('Pos', 1), result) def test_track_to_mpd_format_with_tlid(self): result = translator.track_to_mpd_format(TlTrack(1, Track())) self.assertNotIn(('Id', 1), result) def test_track_to_mpd_format_with_position_and_tlid(self): result = translator.track_to_mpd_format( TlTrack(2, Track()), position=1) self.assertIn(('Pos', 1), result) self.assertIn(('Id', 2), result) def test_track_to_mpd_format_for_nonempty_track(self): result = translator.track_to_mpd_format( TlTrack(122, self.track), position=9) self.assertIn(('file', 'a uri'), result) self.assertIn(('Time', 137), result) self.assertIn(('Artist', 'an artist'), result) self.assertIn(('Title', 'a name'), result) self.assertIn(('Album', 'an album'), result) self.assertIn(('AlbumArtist', 'an other artist'), result) self.assertIn(('Composer', 'a composer'), result) self.assertIn(('Performer', 'a performer'), result) self.assertIn(('Genre', 'a genre'), result) self.assertIn(('Track', '7/13'), result) self.assertIn(('Date', '1977-01-01'), result) self.assertIn(('Disc', 1), result) self.assertIn(('Pos', 9), result) self.assertIn(('Id', 122), result) self.assertNotIn(('Comment', 'a comment'), result) self.assertEqual(len(result), 14) def test_track_to_mpd_format_with_last_modified(self): track = self.track.replace(last_modified=995303899000) result = translator.track_to_mpd_format(track) self.assertIn(('Last-Modified', '2001-07-16T17:18:19Z'), result) def test_track_to_mpd_format_with_last_modified_of_zero(self): track = self.track.replace(last_modified=0) result = translator.track_to_mpd_format(track) keys = [k for k, v in result] self.assertNotIn('Last-Modified', keys) def test_track_to_mpd_format_musicbrainz_trackid(self): track = self.track.replace(musicbrainz_id='foo') result = translator.track_to_mpd_format(track) self.assertIn(('MUSICBRAINZ_TRACKID', 'foo'), result) def test_track_to_mpd_format_musicbrainz_albumid(self): album = self.track.album.replace(musicbrainz_id='foo') track = self.track.replace(album=album) result = translator.track_to_mpd_format(track) self.assertIn(('MUSICBRAINZ_ALBUMID', 'foo'), result) def test_track_to_mpd_format_musicbrainz_albumartistid(self): artist = list(self.track.artists)[0].replace(musicbrainz_id='foo') album = self.track.album.replace(artists=[artist]) track = self.track.replace(album=album) result = translator.track_to_mpd_format(track) self.assertIn(('MUSICBRAINZ_ALBUMARTISTID', 'foo'), result) def test_track_to_mpd_format_musicbrainz_artistid(self): artist = list(self.track.artists)[0].replace(musicbrainz_id='foo') track = self.track.replace(artists=[artist]) result = translator.track_to_mpd_format(track) self.assertIn(('MUSICBRAINZ_ARTISTID', 'foo'), result) def test_concat_multi_values(self): artists = [Artist(name='ABBA'), Artist(name='Beatles')] translated = translator.concat_multi_values(artists, 'name') self.assertEqual(translated, 'ABBA;Beatles') def test_concat_multi_values_artist_with_no_name(self): artists = [Artist(name=None)] translated = translator.concat_multi_values(artists, 'name') self.assertEqual(translated, '') def test_concat_multi_values_artist_with_no_musicbrainz_id(self): artists = [Artist(name='Jah Wobble')] translated = translator.concat_multi_values(artists, 'musicbrainz_id') self.assertEqual(translated, '') def test_track_to_mpd_format_with_stream_title(self): result = translator.track_to_mpd_format(self.track, stream_title='foo') self.assertIn(('Name', 'a name'), result) self.assertIn(('Title', 'foo'), result) def test_track_to_mpd_format_with_empty_stream_title(self): result = translator.track_to_mpd_format(self.track, stream_title='') self.assertIn(('Name', 'a name'), result) self.assertIn(('Title', ''), result) def test_track_to_mpd_format_with_stream_and_no_track_name(self): track = self.track.replace(name=None) result = translator.track_to_mpd_format(track, stream_title='foo') self.assertNotIn(('Name', ''), result) self.assertIn(('Title', 'foo'), result) class PlaylistMpdFormatTest(unittest.TestCase): def test_mpd_format(self): playlist = Playlist(tracks=[ Track(track_no=1), Track(track_no=2), Track(track_no=3)]) result = translator.playlist_to_mpd_format(playlist) self.assertEqual(len(result), 3) def test_mpd_format_with_range(self): playlist = Playlist(tracks=[ Track(track_no=1), Track(track_no=2), Track(track_no=3)]) result = translator.playlist_to_mpd_format(playlist, 1, 2) self.assertEqual(len(result), 1) self.assertEqual(dict(result[0])['Track'], 2)
dbrgn/mopidy
tests/mpd/test_translator.py
Python
apache-2.0
6,809
0
######################################################################### ## This program is part of 'MOOSE', the ## Messaging Object Oriented Simulation Environment. ## Copyright (C) 2013 Upinder S. Bhalla. and NCBS ## It is made available under the terms of the ## GNU Lesser General Public License version 2.1 ## See the file COPYING.LIB for the full notice. ######################################################################### import math import pylab import numpy import moose runtime = 50.0 def makeModel(): # create container for model model = moose.Neutral( 'model' ) harmonic = moose.CubeMesh( '/model/harmonic' ) harmonic.volume = 1e-15 lotka = moose.CubeMesh( '/model/lotka' ) lotka.volume = 1e-15 # create molecules and reactions x = moose.Pool( '/model/lotka/x' ) y = moose.Pool( '/model/lotka/y' ) z = moose.BufPool( '/model/lotka/z' ) # Dummy molecule. xreac = moose.Reac( '/model/lotka/xreac' ) yreac = moose.Reac( '/model/lotka/yreac' ) xrate = moose.Function( '/model/lotka/xreac/func' ) yrate = moose.Function( '/model/lotka/yreac/func' ) # Parameters alpha = 1.0 beta = 1.0 gamma = 1.0 delta = 1.0 k = 1.0 x.nInit = 2.0 y.nInit = 1.0 z.nInit = 0.0 xrate.x.num = 1 yrate.x.num = 1 xrate.expr = "x0 * " + str( beta ) + " - " + str( alpha ) yrate.expr = str( gamma ) + " - x0 * " + str( delta ) xreac.Kf = k yreac.Kf = k xreac.Kb = 0 yreac.Kb = 0 # connect them up for reactions moose.connect( y, 'nOut', xrate.x[0], 'input' ) moose.connect( x, 'nOut', yrate.x[0], 'input' ) moose.connect( xrate, 'valueOut', xreac, 'setNumKf' ) moose.connect( yrate, 'valueOut', yreac, 'setNumKf' ) moose.connect( xreac, 'sub', x, 'reac' ) moose.connect( xreac, 'prd', z, 'reac' ) moose.connect( yreac, 'sub', y, 'reac' ) moose.connect( yreac, 'prd', z, 'reac' ) # Create the output tables graphs = moose.Neutral( '/model/graphs' ) xplot = moose.Table2 ( '/model/graphs/x' ) yplot = moose.Table2 ( '/model/graphs/y' ) # connect up the tables moose.connect( xplot, 'requestOut', x, 'getN' ); moose.connect( yplot, 'requestOut', y, 'getN' ); def main(): """ The funcReacLotkaVolterra example shows how to use function objects as part of differential equation systems in the framework of the MOOSE kinetic solvers. Here the system is set up explicitly using the scripting, in normal use one would expect to use SBML. In this example we set up a Lotka-Volterra system. The equations are readily expressed as a pair of reactions each of whose rate is governed by a function:: x' = x( alpha - beta.y ) y' = -y( gamma - delta.x ) This translates into two reactions:: x ---> z Kf = beta.y - alpha y ---> z Kf = gamma - delta.x Here z is a dummy molecule whose concentration is buffered to zero. The model first runs using default Exponential Euler integration. This is not particularly accurate even with a small timestep. The model is then converted to use the deterministic Kinetic solver Ksolve. This is accurate and faster. Note that we cannot use the stochastic GSSA solver for this system, it cannot handle a reaction term whose rate keeps changing. """ makeModel() for i in range( 11, 18 ): moose.setClock( i, 0.001 ) moose.setClock( 18, 0.1 ) moose.reinit() moose.start( runtime ) # Run the model # Iterate through all plots, dump their contents to data.plot. for x in moose.wildcardFind( '/model/graphs/#' ): #x.xplot( 'scriptKineticModel.plot', x.name ) t = numpy.arange( 0, x.vector.size, 1 ) * x.dt # sec pylab.plot( t, x.vector, label=x.name ) pylab.ylim( 0, 2.5 ) pylab.title( "Exponential Euler solution. Note slight error buildup" ) pylab.legend() pylab.figure() compt = moose.element( '/model/lotka' ) ksolve = moose.Ksolve( '/model/lotka/ksolve' ) stoich = moose.Stoich( '/model/lotka/stoich' ) stoich.compartment = compt stoich.ksolve = ksolve stoich.path = '/model/lotka/##' moose.reinit() moose.start( runtime ) # Run the model for i in range( 11, 18 ): moose.setClock( i, 0.1 ) for x in moose.wildcardFind( '/model/graphs/#' ): t = numpy.arange( 0, x.vector.size, 1 ) * x.dt # sec pylab.plot( t, x.vector, label=x.name ) pylab.ylim( 0, 2.5 ) pylab.title( "Runge-Kutta solution." ) pylab.legend() pylab.show() quit() # Run the 'main' if this script is executed standalone. if __name__ == '__main__': main()
dilawar/moose-full
moose-examples/snippets/funcReacLotkaVolterra.py
Python
gpl-2.0
5,043
0.029942
""" Key-value store that holds XBlock field data read out of Blockstore """ from collections import namedtuple from weakref import WeakKeyDictionary import logging from xblock.exceptions import InvalidScopeError, NoSuchDefinition from xblock.fields import Field, BlockScope, Scope, UserScope, Sentinel from xblock.field_data import FieldData from openedx.core.djangoapps.xblock.learning_context.manager import get_learning_context_impl from openedx.core.djangolib.blockstore_cache import ( get_bundle_version_files_cached, get_bundle_draft_files_cached, ) log = logging.getLogger(__name__) ActiveBlock = namedtuple('ActiveBlock', ['olx_hash', 'changed_fields']) DELETED = Sentinel('DELETED') # Special value indicating a field was reset to its default value CHILDREN_INCLUDES = Sentinel('CHILDREN_INCLUDES') # Key for a pseudo-field that stores the XBlock's children info MAX_DEFINITIONS_LOADED = 100 # How many of the most recently used XBlocks' field data to keep in memory at max. class BlockInstanceUniqueKey(object): """ An empty object used as a unique key for each XBlock instance, see get_weak_key_for_block() and BlockstoreFieldData._get_active_block(). Every XBlock instance will get a unique one of these keys, even if they are otherwise identical. Its purpose is similar to `id(block)`. """ def get_weak_key_for_block(block): """ Given an XBlock instance, return an object with the same lifetime as the block, suitable as a key to hold block-specific data in a WeakKeyDictionary. """ # We would like to make the XBlock instance 'block' itself the key of # BlockstoreFieldData.active_blocks, so that we have exactly one entry per # XBlock instance in memory, and they'll each be automatically freed by the # WeakKeyDictionary as needed. But because XModules implement # __eq__() in a way that reads all field values, just attempting to use # the block as a dict key here will trigger infinite recursion. So # instead we key the dict on an arbitrary object, # block key = BlockInstanceUniqueKey() which we create here. That way # the weak reference will still cause the entry in the WeakKeyDictionary to # be freed automatically when the block is no longer needed, and we # still get one entry per XBlock instance. if not hasattr(block, '_field_data_key_obj'): block._field_data_key_obj = BlockInstanceUniqueKey() # pylint: disable=protected-access return block._field_data_key_obj # pylint: disable=protected-access def get_olx_hash_for_definition_key(def_key): """ Given a BundleDefinitionLocator, which identifies a specific version of an OLX file, return the hash of the OLX file as given by the Blockstore API. """ if def_key.bundle_version: # This is referring to an immutable file (BundleVersions are immutable so this can be aggressively cached) files_list = get_bundle_version_files_cached(def_key.bundle_uuid, def_key.bundle_version) else: # This is referring to a draft OLX file which may be recently updated: files_list = get_bundle_draft_files_cached(def_key.bundle_uuid, def_key.draft_name) for entry in files_list: if entry.path == def_key.olx_path: return entry.hash_digest raise NoSuchDefinition("Could not load OLX file for key {}".format(def_key)) class BlockstoreFieldData(FieldData): """ An XBlock FieldData implementation that reads XBlock field data directly out of Blockstore. It requires that every XBlock have a BundleDefinitionLocator as its "definition key", since the BundleDefinitionLocator is what specifies the OLX file path and version to use. Within Blockstore there is no mechanism for setting different field values at the usage level compared to the definition level, so we treat usage-scoped fields identically to definition-scoped fields. """ def __init__(self): """ Initialize this BlockstoreFieldData instance. """ # loaded definitions: a dict where the key is the hash of the XBlock's # olx file (as stated by the Blockstore API), and the values is the # dict of field data as loaded from that OLX file. The field data dicts # in this should be considered immutable, and never modified. self.loaded_definitions = {} # Active blocks: this holds the field data *changes* for all the XBlocks # that are currently in memory being used for something. We only keep a # weak reference so that the memory will be freed when the XBlock is no # longer needed (e.g. at the end of a request) # The key of this dictionary is on ID object owned by the XBlock itself # (see _get_active_block()) and the value is an ActiveBlock object # (which holds olx_hash and changed_fields) self.active_blocks = WeakKeyDictionary() super(BlockstoreFieldData, self).__init__() # lint-amnesty, pylint: disable=super-with-arguments def _getfield(self, block, name): """ Return the field with the given `name` from `block`. If the XBlock doesn't have such a field, raises a KeyError. """ # First, get the field from the class, if defined block_field = getattr(block.__class__, name, None) if block_field is not None and isinstance(block_field, Field): return block_field # Not in the class, so name really doesn't name a field raise KeyError(name) def _check_field(self, block, name): """ Given a block and the name of one of its fields, check that we will be able to read/write it. """ if name == CHILDREN_INCLUDES: return # This is a pseudo-field used in conjunction with BlockstoreChildrenData field = self._getfield(block, name) if field.scope in (Scope.children, Scope.parent): # lint-amnesty, pylint: disable=no-else-raise # This field data store is focused on definition-level field data, and children/parent is mostly # relevant at the usage level. Scope.parent doesn't even seem to be used? raise NotImplementedError("Setting Scope.children/parent is not supported by BlockstoreFieldData.") else: if field.scope.user != UserScope.NONE: raise InvalidScopeError("BlockstoreFieldData only supports UserScope.NONE fields") if field.scope.block not in (BlockScope.DEFINITION, BlockScope.USAGE): raise InvalidScopeError( "BlockstoreFieldData does not support BlockScope.{} fields".format(field.scope.block) ) # There is also BlockScope.TYPE but we don't need to support that; # it's mostly relevant as Scope.preferences(UserScope.ONE, BlockScope.TYPE) # Which would be handled by a user-aware FieldData implementation def _get_active_block(self, block): """ Get the ActiveBlock entry for the specified block, creating it if necessary. """ key = get_weak_key_for_block(block) if key not in self.active_blocks: self.active_blocks[key] = ActiveBlock( olx_hash=get_olx_hash_for_definition_key(block.scope_ids.def_id), changed_fields={}, ) return self.active_blocks[key] def get(self, block, name): """ Get the given field value from Blockstore If the XBlock has been making changes to its fields, the value will be in self._get_active_block(block).changed_fields[name] Otherwise, the value comes from self.loaded_definitions which is a dict of OLX file field data, keyed by the hash of the OLX file. """ self._check_field(block, name) entry = self._get_active_block(block) if name in entry.changed_fields: value = entry.changed_fields[name] if value == DELETED: raise KeyError # KeyError means use the default value, since this field was deliberately set to default return value try: saved_fields = self.loaded_definitions[entry.olx_hash] except KeyError: if name == CHILDREN_INCLUDES: # Special case: parse_xml calls add_node_as_child which calls 'block.children.append()' # BEFORE parse_xml is done, and .append() needs to read the value of children. So return [] # start with an empty list, it will get filled in. # Otherwise, this is an anomalous get() before the XML was fully loaded: # This could happen if an XBlock's parse_xml() method tried to read a field before setting it, # if an XBlock read field data in its constructor (forbidden), or if an XBlock was loaded via # some means other than runtime.get_block(). One way this can happen is if you log/print an XBlock during # XML parsing, because ScopedStorageMixin.__repr__ will try to print all field values, and any fields which # aren't mentioned in the XML (which are left at their default) will be "not loaded yet." log.exception( "XBlock %s tried to read from field data (%s) that wasn't loaded from Blockstore!", block.scope_ids.usage_id, name, ) raise # Just use the default value for now; any exception raised here is caught anyways return saved_fields[name] # If 'name' is not found, this will raise KeyError, which means to use the default value def set(self, block, name, value): """ Set the value of the field named `name` """ entry = self._get_active_block(block) entry.changed_fields[name] = value def delete(self, block, name): """ Reset the value of the field named `name` to the default """ self.set(block, name, DELETED) def default(self, block, name): """ Get the default value for block's field 'name'. The XBlock class will provide the default if KeyError is raised; this is mostly for the purpose of context-specific overrides. """ raise KeyError(name) def cache_fields(self, block): """ Cache field data: This is called by the runtime after a block has parsed its OLX via its parse_xml() methods and written all of its field values into this field data store. The values will be stored in self._get_active_block(block).changed_fields so we know at this point that that isn't really "changed" field data, it's the result of parsing the OLX. Save a copy into loaded_definitions. """ entry = self._get_active_block(block) self.loaded_definitions[entry.olx_hash] = entry.changed_fields.copy() # Reset changed_fields to indicate this block hasn't actually made any field data changes, just loaded from XML: entry.changed_fields.clear() if len(self.loaded_definitions) > MAX_DEFINITIONS_LOADED: self.free_unused_definitions() def has_changes(self, block): """ Does the specified block have any unsaved changes? """ entry = self._get_active_block(block) return bool(entry.changed_fields) def has_cached_definition(self, definition_key): """ Has the specified OLX file been loaded into memory? """ olx_hash = get_olx_hash_for_definition_key(definition_key) return olx_hash in self.loaded_definitions def free_unused_definitions(self): """ Free unused field data cache entries from self.loaded_definitions as long as they're not in use. """ olx_hashes = set(self.loaded_definitions.keys()) olx_hashes_needed = set(entry.olx_hash for entry in self.active_blocks.values()) olx_hashes_safe_to_delete = olx_hashes - olx_hashes_needed # To avoid doing this too often, randomly cull unused entries until # we have only half as many as MAX_DEFINITIONS_LOADED in memory, if possible. while olx_hashes_safe_to_delete and (len(self.loaded_definitions) > MAX_DEFINITIONS_LOADED / 2): del self.loaded_definitions[olx_hashes_safe_to_delete.pop()] class BlockstoreChildrenData(FieldData): """ An XBlock FieldData implementation that reads 'children' data out of the definition fields in BlockstoreFieldData. The children field contains usage keys and so is usage-specific; the BlockstoreFieldData can only store field data that is not usage-specific. So we store data about the <xblock-include /> elements that define the children in BlockstoreFieldData (since that is not usage-specific), and this field data implementation loads that <xblock-include /> data and transforms it into the usage keys that comprise the standard .children field. """ def __init__(self, blockstore_field_data): """ Initialize this BlockstoreChildrenData instance. """ # The data store that holds Scope.usage and Scope.definition data: self.authored_data_store = blockstore_field_data super(BlockstoreChildrenData, self).__init__() # lint-amnesty, pylint: disable=super-with-arguments def _check_field(self, block, name): # pylint: disable=unused-argument """ Given a block and the name of one of its fields, check that we will be able to read/write it. """ if name != 'children': raise InvalidScopeError("BlockstoreChildrenData can only read/write from a field named 'children'") def get(self, block, name): """ Get the "children' field value. We do this by reading the parsed <xblock-include /> values from the regular authored data store and then transforming them to usage IDs. """ self._check_field(block, name) children_includes = self.get_includes(block) if not children_includes: return [] # Now the .children field is required to be a list of usage IDs: learning_context = get_learning_context_impl(block.scope_ids.usage_id) child_usages = [] for parsed_include in children_includes: child_usages.append( learning_context.usage_for_child_include( block.scope_ids.usage_id, block.scope_ids.def_id, parsed_include, ) ) return child_usages def set(self, block, name, value): """ Set the value of the field; requires name='children' """ self._check_field(block, name) children_includes = self.authored_data_store.get(block, CHILDREN_INCLUDES) if len(value) != len(children_includes): raise RuntimeError( "This runtime does not allow changing .children directly - use runtime.add_child_include instead." ) # This is a no-op; the value of 'children' is derived from CHILDREN_INCLUDES # so we never write to the children field directly. All we do is make sure it # looks like it's still in sync with CHILDREN_INCLUDES def get_includes(self, block): """ Get the list of <xblock-include /> elements representing this XBlock's children. """ try: return self.authored_data_store.get(block, CHILDREN_INCLUDES) except KeyError: # KeyError raised by an XBlock field data store means "use the # default value", and the default value for the children field is an # empty list. return [] def append_include(self, block, parsed_include): """ Append an <xblock-include /> element to this XBlock's list of children """ self.authored_data_store.set(block, CHILDREN_INCLUDES, self.get_includes(block) + [parsed_include]) def delete(self, block, name): """ Reset the value of the field named `name` to the default """ self._check_field(block, name) self.authored_data_store.set(block, CHILDREN_INCLUDES, []) self.set(block, name, [])
stvstnfrd/edx-platform
openedx/core/djangoapps/xblock/runtime/blockstore_field_data.py
Python
agpl-3.0
16,343
0.003243
#!/usr/bin/python3.4 ############################################################################# # # Dictionnary DB managing script. Add/Del/Search definitions # Copyright (C) 2014 bertrand # # 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. # ############################################################################# ############### ### Imports ### import sys import psycopg2 as PSQL import textwrap as txtwrp ##################### ### Configuration ### config = { 'VERSION_MAJOR' : '0', 'VERSION_MINOR' : '1', 'dbname' : 'bertrand', 'user' : 'bertrand' } ############# ### USAGE ### def usage(): print("Tool to insert/remove entries in the dicotionnnary.") print("Version: " + config['VERSION_MAJOR'] + "." + config['VERSION_MINOR']) print("Usage: " + sys.argv[0] + " <command> <options>") print("") print("Commands:") print(" add Add definition to dictionnary.") print(" del Remove definition from dictionnary.") print(" help Print general help or command specific help.") print(" search Search definition in dictionnary.") print("") ########### ### ADD ### def add(): argc = len(sys.argv) if argc < 3: __help_cmd(sys.argv[1]) return req = { 'fields' : '', 'name' : '', 'def' : '', 'url' : '' } i=2 while i < argc: if sys.argv[i] == "-d": i += 1 req['def'] = sys.argv[i] elif sys.argv[i] == "-f": i += 1 req['fields'] = sys.argv[i] elif sys.argv[i] == '-n': i += 1 req['name'] = sys.argv[i] elif sys.argv[i] == "-u": i += 1 req['url'] = sys.argv[i] else: print("Unknown option '" + sys.argv[i] + "'") __help_cmd(sys.argv[1]) return i += 1 if req['fields'] == '': print("Please specify fields with option '-f'.") __help_cmd(sys.argv[1]) return elif req['name'] == '': print("Please specify fields with option '-f'.") __help_cmd(sys.argv[1]) return elif req['def'] == '': print("Please specify definition with option '-d'.") __help_cmd(sys.argv[1]) return conn = PSQL.connect("dbname=" + config['dbname'] + " user=" + config['user']) cur = conn.cursor() req = cur.mogrify("INSERT INTO dico (fields,name,def,url) VALUES (%s, %s, %s, %s)", ("{" + req['fields'] + "}", req['name'], req['def'], req['url'])) print(req) cur.execute(req) conn.commit() cur.close() conn.close() ########### ### DEL ### def delete(): try: defid = sys.argv[2] except IndexError: print("Missing argument.") __help_cmd(sys.argv[1]) return conn = PSQL.connect("dbname=" + config['dbname'] + " user=" + config['user']) cur = conn.cursor() req = cur.mogrify("DELETE FROM dico WHERE id=%s", (defid,)) print(req) cur.execute(req) conn.commit() cur.close() conn.close() ##################### ### HELP COMMANDS ### def help_cmd(): try: cmd = sys.argv[2] except: cmd = '' __help_cmd(cmd) def __help_cmd(cmd): if cmd == '' : usage() elif cmd == "add" : print("Command '" + cmd + "': Add definition to dictionnary.") print("Usage: " + sys.argv[0] + " " + cmd + " <options>") print("") print("Options:") print(" -d <str> Definition.") print(" -f <str,str,..> List of fields.") print(" -n <str> Name of the entry") print(" -u <url> One url to a more complete definition.") print("") elif cmd == "del" : print("Command '" + cmd + "': Delete definition from dictionnary.") print("Usage: " + sys.argv[0] + " " + cmd + " <id>") print("") print("Param:") print(" id ID of the definition to delete.") print("") elif cmd == "help" : print("Command '" + cmd + "': Print help.") print("Usage: " + sys.argv[0] + " " + cmd + " [command]") print("") print("Giving NO 'command' this will print the general help.") print("Giving 'command' this will print the command specific help. ") print("") elif cmd == "search" : print("Command '" + cmd + "': Search definition in dictionnary.") print("Usage: " + sys.argv[0] + " " + cmd + " <options>") print("") print("Options:") print(" -a Print all definitions in the table.") print(" -f <str,str,...> Print definitions matching the set of given fields.") print(" -i <id> Print definition matching the given ID.") print(" -n <str> Print definition mathing the given entry name.") print("") else: print("Unknown command: '" + cmd + "'") usage() ############## ### SEARCH ### def search(): try: opt = sys.argv[2] except IndexError: __help_cmd(sys.argv[1]) return else: if not opt in ('-a', '-f', '-i', '-n'): print("Unknown option '" + sys.argv[2] + "'") __help_cmd(sys.argv[1]) return conn = PSQL.connect("dbname=" + config['dbname'] + " user=" + config['user']) cur = conn.cursor() try: if opt == "-a": req = cur.mogrify("SELECT id,fields,name,def,url FROM dico") elif opt == "-f": optarg = sys.argv[3] req = __search_build_req_fields(optarg.split(',')) elif opt == '-i': optarg = sys.argv[3] req = cur.mogrify("SELECT id,fields,name,def,url FROM dico WHERE id=%s", (optarg,)) elif opt == "-n": optarg = sys.argv[3] req = cur.mogrify("SELECT id,fields,name,def,url FROM dico WHERE name=%s", (optarg,)) except IndexError: print("Missing argument.") __help_cmd(sys.argv[1]) else: print(req) cur.execute(req) print_rows(cur.fetchall()) conn.commit() finally: cur.close() conn.close() def __search_build_req_fields(fields): # How do you like your SQL injection? # I like mine crispy and with a python '+' ;) # http://initd.org/psycopg/docs/usage.html # http://xkcd.com/327/ # That will do for now ... req = "SELECT id,fields,name,def,url FROM dico WHERE " req += "'" + fields[0] + "'=ANY(fields)" for f in fields[1:]: req += " OR '" + f + "'=ANY(fields)" return req ################################### ### PRINT PSQL REQUESTS RESULTS ### def print_rows(rows): for row in rows: print("---------------------") print("ID : ", row[0]) __print_row_wrapped("FIELDS : ", row[1]) __print_row_wrapped("NAME : ", row[2]) __print_row_wrapped("DEF : ", row[3]) __print_row_wrapped("URL : ", row[4]) print("") def __print_row_wrapped(label, value): labellen = len(label) wrapped = txtwrp.wrap(value) print(label, wrapped[0]) for i in range(1, len(wrapped)): print(' ' * labellen, wrapped[i]) ############ ### MAIN ### commands = { 'add' : add, 'del' : delete, 'help' : help_cmd, 'search' : search } try: cmd = sys.argv[1] except KeyError: print("Unknown command: " + cmd) usage() sys.exit() except IndexError: usage() sys.exit() else: commands[cmd]()
bertrandF/DictionaryDB
db.py
Python
gpl-2.0
8,296
0.008799
import os import sys import json from optional_django import staticfiles from optional_django.serializers import JSONEncoder from optional_django.safestring import mark_safe from optional_django import six from js_host.function import Function from js_host.exceptions import FunctionError from react.render import RenderedComponent from react.exceptions import ComponentSourceFileNotFound from react.exceptions import ReactRenderingError from react_router.conf import settings from react_router.templates import MOUNT_JS from react_router.bundle import bundle_component from webpack.compiler import WebpackBundle class RouteRenderedComponent(RenderedComponent): def get_client_asset(self): client_asset = None bundled_component = self.get_bundle() assets = bundled_component.get_assets() for asset in assets: if asset['path'] == self.path_to_source: client_asset = asset break return client_asset def get_var(self): client_asset = self.get_client_asset() if client_asset: return 'client' raise Exception("Client asset not found.") def render_js(self): client_asset = self.get_client_asset() if client_asset: client_bundle = mark_safe(WebpackBundle.render_tag(client_asset['url'])) return mark_safe( '\n{bundle}\n<script>\n{mount_js}\n</script>\n'.format( bundle=client_bundle, mount_js=self.render_mount_js(), ) ) def render_mount_js(self): return mark_safe( MOUNT_JS.format( var=self.get_var(), props=self.serialized_props or 'null', container_id=self.get_container_id() ) ) class RouteRedirect(object): def __init__(self, pathname, query = None, state = None, *args, **kwargs): self.path = pathname self.query = query if state and 'nextPathname' in state: self.nextPath = state['nextPathname'] else: self.nextPath = None if self.path is None: raise ReactRenderingError("No path returned for redirection.") super(RouteRedirect, self).__init__(*args, **kwargs) @property def url(self): if self.query: return "%s?next=%s&%s" % (self.path, self.nextPath, self.query) else: return "%s?next=%s" % (self.path, self.nextPath) class RouteNotFound(object): def __init__(self, *args, **kwargs): super(RouteNotFound, self).__init__(*args, **kwargs) js_host_function = Function(settings.JS_HOST_FUNCTION) def render_route( # Rendering options path, # path to routes file client_path, # path to client routes file request, # pass in request object props=None, to_static_markup=None, # Bundling options bundle=None, translate=None, # Prop handling json_encoder=None ): if not os.path.isabs(path): abs_path = staticfiles.find(path) if not abs_path: raise ComponentSourceFileNotFound(path) path = abs_path if not os.path.exists(path): raise ComponentSourceFileNotFound(path) if not os.path.isabs(client_path): abs_client_path = staticfiles.find(client_path) if not abs_client_path: raise ComponentSourceFileNotFound(client_path) client_path = abs_client_path if not os.path.exists(client_path): raise ComponentSourceFileNotFound(client_path) bundled_component = None import re client_re = re.compile(r"client-(?:\w*\d*).js",re.IGNORECASE) server_re = re.compile(r"server-(?:\w*\d*).js",re.IGNORECASE) if bundle or translate: bundled_component = bundle_component(path, client_path, translate=translate) assets = bundled_component.get_assets() for asset in assets: m = client_re.search(asset['name']) if m: client_path = asset['path'] m = server_re.search(asset['name']) if m: path = asset['path'] if json_encoder is None: json_encoder = JSONEncoder if props is not None: serialized_props = json.dumps(props, cls=json_encoder) else: serialized_props = None try: location = { 'pathname': request.path, 'query': request.GET.dict() } cbData = json.loads(js_host_function.call( path=path, location=location, serializedProps=serialized_props, toStaticMarkup=to_static_markup )) except FunctionError as e: raise six.reraise(ReactRenderingError, ReactRenderingError(*e.args), sys.exc_info()[2]) if cbData['match']: return RouteRenderedComponent(cbData['markup'], client_path, props, serialized_props, bundled_component, to_static_markup) else: if cbData['redirectInfo']: return RouteRedirect(**cbData['redirectInfo']) else: return RouteNotFound()
HorizonXP/python-react-router
react_router/render.py
Python
mit
5,105
0.003918
import nltk import re import pprint def main(): IN = re.compile(r'.*\bin\b(?!\b.+ing)') for doc in nltk.corpus.ieer.parsed_docs('NYT_19980315'): for rel in nltk.sem.extract_rels('ORG', 'LOC', doc, corpus='ieer', pattern=IN): print nltk.sem.relextract.rtuple(rel) if __name__ == "__main__": main()
attibalazs/nltk-examples
7.6_Relation_Extraction.py
Python
mit
332
0.006024
__all__ = ["pval_task", "annotation_task"]
eeyorkey/ipac
tasks/__init__.py
Python
gpl-2.0
42
0.02381
#!/usr/bin/env python # vim: set fileencoding=utf-8 : # Pavel Korshunov <Pavel.Korshunov@idiap.ch> # Tue 22 Sep 17:21:35 CEST 2015 # # Copyright (C) 2012-2015 Idiap Research Institute, Martigny, Switzerland # # 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, version 3 of the License. # # 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 logging import math import numpy logger = logging.getLogger("bob.bio.spear") def zeromean_unitvar_norm(data, mean, std): """ Normalized the data with zero mean and unit variance. Mean and variance are in numpy.ndarray format""" return numpy.divide(data - mean, std) def calc_mean(c0, c1=[]): """ Calculates the mean of the data.""" if c1 != []: return (numpy.mean(c0, 0) + numpy.mean(c1, 0)) / 2.0 else: return numpy.mean(c0, 0) def calc_std(c0, c1=[]): """ Calculates the variance of the data.""" if c1 == []: return numpy.std(c0, 0) prop = float(len(c0)) / float(len(c1)) if prop < 1: p0 = int(math.ceil(1 / prop)) p1 = 1 else: p0 = 1 p1 = int(math.ceil(prop)) return numpy.std(numpy.vstack(p0 * [c0] + p1 * [c1]), 0) """ @param c0 @param c1 @param nonStdZero if the std was zero, convert to one. This will avoid a zero division """ def calc_mean_std(c0, c1=[], nonStdZero=False): """ Calculates both the mean of the data. """ mi = calc_mean(c0, c1) std = calc_std(c0, c1) if nonStdZero: std[std == 0] = 1 return mi, std def vad_filter_features(vad_labels, features, filter_frames="trim_silence"): """Trim the spectrogram to remove silent head/tails from the speech sample. Keep all remaining frames or either speech or non-speech only @param: filter_frames: the value is either 'silence_only' (keep the speech, remove everything else), 'speech_only' (only keep the silent parts), 'trim_silence' (trim silent heads and tails), or 'no_filter' (no filter is applied) """ if not features.size: raise ValueError( "vad_filter_features(): data sample is empty, no features extraction is possible" ) vad_labels = numpy.asarray(vad_labels, dtype=numpy.int8) features = numpy.asarray(features, dtype=numpy.float64) features = numpy.reshape(features, (vad_labels.shape[0], -1)) # logger.info("RatioVectorExtractor, vad_labels shape: %s", str(vad_labels.shape)) # print ("RatioVectorExtractor, features max: %f and min: %f" %(numpy.max(features), numpy.min(features))) # first, take the whole thing, in case there are problems later filtered_features = features # if VAD detection worked on this sample if vad_labels is not None and filter_frames != "no_filter": # make sure the size of VAD labels and sectrogram lenght match if len(vad_labels) == len(features): # take only speech frames, as in VAD speech frames are 1 and silence are 0 (speech,) = numpy.nonzero(vad_labels) silences = None if filter_frames == "silence_only": # take only silent frames - those for which VAD gave zeros (silences,) = numpy.nonzero(vad_labels == 0) if len(speech): nzstart = speech[0] # index of the first non-zero nzend = speech[-1] # index of the last non-zero if filter_frames == "silence_only": # extract only silent frames # take only silent frames in-between the speech silences = silences[silences > nzstart] silences = silences[silences < nzend] filtered_features = features[silences, :] elif filter_frames == "speech_only": filtered_features = features[speech, :] else: # when we take all filtered_features = features[ nzstart : nzend + 1, : ] # numpy slicing is a non-closed interval [) else: logger.error( "vad_filter_features(): VAD labels should be the same length as energy bands" ) logger.info( "vad_filter_features(): filtered_features shape: %s", str(filtered_features.shape), ) return filtered_features
bioidiap/bob.bio.spear
bob/bio/spear/utils/extraction.py
Python
gpl-3.0
4,798
0.002293
# Copyright 2021, Kay Hayen, mailto:kay.hayen@gmail.com # # Part of "Nuitka", an optimizing Python compiler that is compatible and # integrates with CPython, but also works on its own. # # 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. # """ Nodes for coroutine objects and their creations. Coroutines are turned into normal functions that create generator objects, whose implementation lives here. The creation itself also lives here. """ from .ExpressionBases import ExpressionChildHavingBase from .FunctionNodes import ExpressionFunctionEntryPointBase class ExpressionMakeCoroutineObject(ExpressionChildHavingBase): kind = "EXPRESSION_MAKE_COROUTINE_OBJECT" named_child = "coroutine_ref" __slots__ = ("variable_closure_traces",) def __init__(self, coroutine_ref, source_ref): assert coroutine_ref.getFunctionBody().isExpressionCoroutineObjectBody() ExpressionChildHavingBase.__init__( self, value=coroutine_ref, source_ref=source_ref ) self.variable_closure_traces = None def getDetailsForDisplay(self): return {"coroutine": self.subnode_coroutine_ref.getFunctionBody().getCodeName()} def computeExpression(self, trace_collection): self.variable_closure_traces = [] for ( closure_variable ) in self.subnode_coroutine_ref.getFunctionBody().getClosureVariables(): trace = trace_collection.getVariableCurrentTrace(closure_variable) trace.addNameUsage() self.variable_closure_traces.append((closure_variable, trace)) # TODO: Coroutine body may know something too. return self, None, None @staticmethod def mayRaiseException(exception_type): return False @staticmethod def mayHaveSideEffects(): return False def getClosureVariableVersions(self): return self.variable_closure_traces class ExpressionCoroutineObjectBody(ExpressionFunctionEntryPointBase): kind = "EXPRESSION_COROUTINE_OBJECT_BODY" __slots__ = ("qualname_setup", "needs_generator_return_exit") def __init__(self, provider, name, code_object, flags, auto_release, source_ref): ExpressionFunctionEntryPointBase.__init__( self, provider=provider, name=name, code_object=code_object, code_prefix="coroutine", flags=flags, auto_release=auto_release, source_ref=source_ref, ) self.needs_generator_return_exit = False self.qualname_setup = None def getFunctionName(self): return self.name def markAsNeedsGeneratorReturnHandling(self, value): self.needs_generator_return_exit = max(self.needs_generator_return_exit, value) def needsGeneratorReturnHandling(self): return self.needs_generator_return_exit == 2 def needsGeneratorReturnExit(self): return bool(self.needs_generator_return_exit) @staticmethod def needsCreation(): return False @staticmethod def isUnoptimized(): return False class ExpressionAsyncWait(ExpressionChildHavingBase): kind = "EXPRESSION_ASYNC_WAIT" named_child = "expression" __slots__ = ("exception_preserving",) def __init__(self, expression, source_ref): ExpressionChildHavingBase.__init__( self, value=expression, source_ref=source_ref ) self.exception_preserving = False @staticmethod def isExpressionAsyncWait(): return True def computeExpression(self, trace_collection): # TODO: Might be predictable based awaitable analysis or for constants. trace_collection.onExceptionRaiseExit(BaseException) return self, None, None class ExpressionAsyncWaitEnter(ExpressionAsyncWait): kind = "EXPRESSION_ASYNC_WAIT_ENTER" class ExpressionAsyncWaitExit(ExpressionAsyncWait): kind = "EXPRESSION_ASYNC_WAIT_EXIT"
kayhayen/Nuitka
nuitka/nodes/CoroutineNodes.py
Python
apache-2.0
4,498
0.001112
# Copyright 2014 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. import os class URLMappings(object): def __init__(self, src_root, build_dir): self.mappings = { 'dart:mojo.internal': os.path.join(src_root, 'mojo/public/dart/sdk_ext/internal.dart'), 'dart:sky': os.path.join(build_dir, 'gen/sky/bindings/dart_sky.dart'), 'dart:sky.internals': os.path.join(src_root, 'sky/engine/bindings/sky_internals.dart'), 'dart:sky_builtin_natives': os.path.join(src_root, 'sky/engine/bindings/builtin_natives.dart'), } self.packages_root = os.path.join(build_dir, 'gen/dart-pkg/packages') @property def as_args(self): return map(lambda item: '--url-mapping=%s,%s' % item, self.mappings.items())
xunmengfeng/engine
sky/tools/skypy/url_mappings.py
Python
bsd-3-clause
878
0.009112
import urllib from flask import url_for from flask_script import Manager, Server, Shell, Command from config.app import create_app from config.db import db from config.initializers.newrelic_monitoring import NewrelicMonitoring from federation_api.people.model import Person manager = Manager(create_app) server = Server(host='0.0.0.0', port=1786) NewrelicMonitoring(manager.app()) manager.add_command('runserver', server) def _make_context(): models = [Person] models = {model.__name__: model for model in models} return dict(app=create_app(), db=db, **models) manager.add_command('shell', Shell(make_context=_make_context)) class Routes(Command): def run(self): output = [] app = manager.app for rule in app.url_map.iter_rules(): options = {} for arg in rule.arguments: options[arg] = "[{0}]".format(arg) methods = ','.join(rule.methods) # FIXME: Results in http://<host_name>:<host_port>/<blueprint_mount>/<endpoint>g url = url_for(rule.endpoint, **options) line = urllib.unquote("{:50s} {:20s} {}".format(rule.endpoint, methods, url)) output.append(line) for line in sorted(output): print(line) manager.add_command('routes', Routes()) if __name__ == '__main__': manager.run()
practo/federation
manage.py
Python
mit
1,415
0.002827
from direct.interval.IntervalGlobal import * from direct.particles import ParticleEffect from direct.particles import Particles from direct.particles import ForceGroup from pandac.PandaModules import * import random from FireworkGlobals import * colors = {WHITE: Vec4(1, 1, 1, 1), RED: Vec4(1, 0.2, 0.2, 1), BLUE: Vec4(0.2, 0.2, 1, 1), YELLOW: Vec4(1, 1, 0.2, 1), GREEN: Vec4(0.2, 1, 0.2, 1), PINK: Vec4(1, 0.5, 0.5, 1), PEACH: Vec4(0.9, 0.6, 0.4, 1), PURPLE: Vec4(1, 0.1, 1, 1), CYAN: Vec4(0.2, 1, 1, 1)} textures = {SNOWFLAKE: 'phase_8/models/props/snowflake_treasure', MUSICNOTE: 'phase_6/models/props/music_treasure', FLOWER: 'phase_8/models/props/flower_treasure', ICECREAM: 'phase_4/models/props/icecream', STARFISH: 'phase_6/models/props/starfish_treasure', ZZZ: 'phase_8/models/props/zzz_treasure'} fireworkId = 0 def getNextSequenceName(name): global fireworkId fireworkId += 1 return '%s-%s' % (name, fireworkId) def getColor(colorIndex): return colors.get(colorIndex) def getTexture(textureIndex): return loader.loadModel(textures.get(textureIndex)) def shootFirework(style, x = 0, y = 0, z = 0, colorIndex1 = 0, colorIndex2 = 0, amp = 10): func = style2shootFunc.get(style) color1 = getColor(colorIndex1) if style is CIRCLESPRITE: color2 = getTexture(colorIndex2) else: color2 = getColor(colorIndex2) if func and color1 and color2: return func(x, y, z, color1, color2, amp) def shootFireworkRing(x, y, z, color1, color2, amp): f = ParticleEffect.ParticleEffect() p0 = Particles.Particles('particles-1') p0.setFactory('PointParticleFactory') p0.setRenderer('SparkleParticleRenderer') p0.setEmitter('RingEmitter') p0.setPoolSize(100) p0.setBirthRate(0.01) p0.setLitterSize(100) p0.setLitterSpread(0) p0.factory.setLifespanBase(1.5) p0.factory.setLifespanSpread(0.5) p0.factory.setMassBase(1.0) p0.factory.setMassSpread(0.0) p0.factory.setTerminalVelocityBase(20.0) p0.factory.setTerminalVelocitySpread(2.0) p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT) p0.renderer.setUserAlpha(1.0) p0.renderer.setCenterColor(color1) p0.renderer.setEdgeColor(color2) p0.renderer.setBirthRadius(0.3) p0.renderer.setDeathRadius(0.3) p0.renderer.setLifeScale(SparkleParticleRenderer.SPNOSCALE) p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE) p0.emitter.setAmplitude(0) p0.emitter.setAmplitudeSpread(0) f0 = ForceGroup.ForceGroup('gravity') force0 = LinearSourceForce(Point3(x, y, z), LinearDistanceForce.FTONEOVERR, 0.1, 1.1 * amp, 1) force0.setActive(1) f0.addForce(force0) force1 = LinearSinkForce(Point3(x, y, z), LinearDistanceForce.FTONEOVERR, 0.5, 2.0 * amp, 1) force1.setActive(1) f0.addForce(force1) f.addForceGroup(f0) p0.emitter.setRadius(4.0) f.addParticles(p0) f.setPos(x, y, z) f.setHpr(0, random.random() * 180, random.random() * 180) sfx = loader.loadSfx('phase_4/audio/sfx/firework_distance_03.ogg') sfx.setVolume(0.7) t = Sequence(Func(f.start, render, render), Func(sfx.play), Wait(0.5), Func(p0.setBirthRate, 3), Wait(1.5), Func(f.cleanup), name=getNextSequenceName('shootFireworkRing')) t.start() def shootFireworkRocket(x, y, z, color1, color2, amp): f = ParticleEffect.ParticleEffect() p0 = Particles.Particles('particles-1') p0.setFactory('PointParticleFactory') p0.setRenderer('SparkleParticleRenderer') p0.setEmitter('SphereVolumeEmitter') p0.setPoolSize(110) p0.setBirthRate(0.01) p0.setLitterSize(2) p0.setLitterSpread(0) p0.factory.setLifespanBase(0.4) p0.factory.setLifespanSpread(0.1) p0.factory.setMassBase(1.0) p0.factory.setMassSpread(0.0) p0.factory.setTerminalVelocityBase(400.0) p0.factory.setTerminalVelocitySpread(0.0) p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT) p0.renderer.setUserAlpha(1.0) p0.renderer.setCenterColor(color1) p0.renderer.setEdgeColor(color2) p0.renderer.setBirthRadius(0.6) p0.renderer.setDeathRadius(0.6) p0.renderer.setLifeScale(SparkleParticleRenderer.SPNOSCALE) p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE) p0.emitter.setAmplitude(amp) p0.emitter.setAmplitudeSpread(0.0) p0.emitter.setRadius(0.3) f.addParticles(p0) gravityForceGroup = ForceGroup.ForceGroup('gravity') force0 = LinearVectorForce(Vec3(0.0, 0.0, -10.0), 1.0, 0) force0.setActive(1) gravityForceGroup.addForce(force0) f.addForceGroup(gravityForceGroup) f.setPos(x, y, z) sfxName = random.choice(('phase_4/audio/sfx/firework_whistle_01.ogg', 'phase_4/audio/sfx/firework_whistle_02.ogg')) sfx = loader.loadSfx(sfxName) sfx.setVolume(0.4) t = Sequence(Func(f.start, render, render), Func(sfx.play), LerpPosInterval(f, 2.0, Vec3(x, y, z + 20 * amp), blendType='easeInOut'), Func(p0.setBirthRate, 3), Wait(0.5), Func(f.cleanup), name=getNextSequenceName('shootFirework')) t.start() def shootPop(x, y, z, color1, color2, amp): sfxName = random.choice(('phase_4/audio/sfx/firework_distance_01.ogg', 'phase_4/audio/sfx/firework_distance_02.ogg', 'phase_4/audio/sfx/firework_distance_03.ogg')) sfx = loader.loadSfx(sfxName) t = Sequence(Func(sfx.play), Wait(3), name=getNextSequenceName('shootFireworkRocket')) t.start() def shootFireworkCircle(x, y, z, color1, color2, amp): return shootFireworkCircleGeneric(x, y, z, color1, color2, amp, 100) def shootFireworkCircleLarge(x, y, z, color1, color2, amp): return shootFireworkCircleGeneric(x, y, z, color1, color2, amp * 1.5, 200) def shootFireworkCircleSmall(x, y, z, color1, color2, amp): return shootFireworkCircleGeneric(x, y, z, color1, color2, amp * 0.5, 50) def shootFireworkCircleGeneric(x, y, z, color1, color2, amp, poolSize): f = ParticleEffect.ParticleEffect() p0 = Particles.Particles('particles-1') p0.setFactory('PointParticleFactory') p0.setRenderer('SparkleParticleRenderer') p0.setEmitter('SphereVolumeEmitter') p0.setPoolSize(poolSize) p0.setBirthRate(0.01) p0.setLitterSize(poolSize) p0.factory.setLifespanBase(2.0) p0.factory.setLifespanSpread(0.5) p0.factory.setTerminalVelocityBase(400.0) p0.factory.setTerminalVelocitySpread(40.0) p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT) p0.renderer.setUserAlpha(1.0) p0.renderer.setCenterColor(color1) p0.renderer.setEdgeColor(color1) p0.renderer.setBirthRadius(0.4) p0.renderer.setDeathRadius(0.6) p0.renderer.setLifeScale(SparkleParticleRenderer.SPSCALE) p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE) p0.emitter.setAmplitudeSpread(0.1) p0.emitter.setAmplitude(amp) p0.emitter.setRadius(0.1) f.addParticles(p0) circleForceGroup = ForceGroup.ForceGroup('gravity') force1 = LinearSinkForce(Point3(x, y, z - 100), LinearDistanceForce.FTONEOVERRSQUARED, 2.0, 0.3 * amp * 0.1, 1) force1.setActive(1) circleForceGroup.addForce(force1) f.addForceGroup(circleForceGroup) f.setPos(x, y, z) sfxName = random.choice(('phase_4/audio/sfx/firework_explosion_01.ogg', 'phase_4/audio/sfx/firework_explosion_02.ogg', 'phase_4/audio/sfx/firework_explosion_03.ogg')) sfx = loader.loadSfx(sfxName) sfx.setVolume(0.7) t = Sequence(Func(f.start, render, render), Func(sfx.play), Wait(0.5), Func(p0.setBirthRate, 3), Wait(0.5), Func(p0.renderer.setCenterColor, color2), Func(p0.renderer.setEdgeColor, color2), Wait(1.5), Func(f.cleanup), name=getNextSequenceName('shootFireworkCircle')) t.start() def shootFireworkCircleSprite(x, y, z, color, texture, amp): f = ParticleEffect.ParticleEffect() p0 = Particles.Particles('particles-1') p0.setFactory('PointParticleFactory') p0.setRenderer('SpriteParticleRenderer') p0.setEmitter('SphereVolumeEmitter') p0.setPoolSize(100) p0.setBirthRate(0.01) p0.setLitterSize(100) p0.factory.setLifespanBase(2.0) p0.factory.setLifespanSpread(0.5) p0.factory.setTerminalVelocityBase(400.0) p0.factory.setTerminalVelocitySpread(40.0) p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAUSER) p0.renderer.setUserAlpha(1.0) p0.renderer.setFromNode(texture) p0.renderer.setColor(color) p0.renderer.setXScaleFlag(1) p0.renderer.setYScaleFlag(1) p0.renderer.setInitialXScale(0.12) p0.renderer.setFinalXScale(0.48) p0.renderer.setInitialYScale(0.12) p0.renderer.setFinalYScale(0.48) p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE) p0.emitter.setAmplitudeSpread(0.1) p0.emitter.setAmplitude(amp) p0.emitter.setRadius(0.1) f.addParticles(p0) circleForceGroup = ForceGroup.ForceGroup('gravity') force1 = LinearSinkForce(Point3(x, y, z - 100), LinearDistanceForce.FTONEOVERRSQUARED, 2.0, 0.3 * amp * 0.1, 1) force1.setActive(1) circleForceGroup.addForce(force1) f.addForceGroup(circleForceGroup) f.setPos(x, y, z) sfxName = random.choice(('phase_4/audio/sfx/firework_explosion_01.ogg', 'phase_4/audio/sfx/firework_explosion_02.ogg', 'phase_4/audio/sfx/firework_explosion_03.ogg')) sfx = loader.loadSfx(sfxName) sfx.setVolume(0.7) t = Sequence(Func(f.start, render, render), Func(sfx.play), Wait(0.5), Func(p0.setBirthRate, 3), Wait(2.0), Func(f.cleanup), name=getNextSequenceName('shootFireworkSprite')) t.start() style2shootFunc = {CIRCLE: shootFireworkCircle, CIRCLELARGE: shootFireworkCircleLarge, CIRCLESMALL: shootFireworkCircleSmall, CIRCLESPRITE: shootFireworkCircleSprite, ROCKET: shootFireworkRocket, RING: shootFireworkRing, POP: shootPop}
Spiderlover/Toontown
toontown/effects/Fireworks.py
Python
mit
9,697
0.004744
# # Copyright 2016 The Charles Stark Draper Laboratory # # 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 twisted.web.server import Site from twisted.web.static import File from twisted.internet import reactor from twisted.web.resource import Resource from twisted.application import service, internet from twisted.application.app import startApplication import os import sys import logging from logging import config import logging.handlers import argparse import simplejson parser = argparse.ArgumentParser(description='Export incoming JSON logs to a specified file.') parser.add_argument('-c', '--config', type=str, help='Configuration file path.') parser.add_argument('-p', '--port', type=int, default=80, help='Port for the TCP server to run on.') parser.add_argument('-l', '--log-directory', type=str, help='Directory in which to output log files.') parser.add_argument('-f', '--filename', type=str, default="xdata", help='Specify filename to store logs.') parser.add_argument('--allow-origin', type=str,\ help='List of string URLs to allow Cross-Origin requests from.', nargs='*') arguments = parser.parse_known_args()[0] valid_keys = set(['port', 'log_directory', 'filename', 'allow_origin']) if arguments.config is not None: with open(arguments.config, 'r') as config_file: settings = simplejson.loads(config_file.read()) else: settings = vars(arguments) settings = { key: settings[key] for key in settings if key in valid_keys } if 'port' not in settings: settings['port'] = 80 if 'log_directory' not in settings or settings['log_directory'] is None: print 'Missing required config parameter log_directory.' sys.exit(1) if os.path.exists(settings['log_directory']): if not os.access(settings['log_directory'], os.W_OK): print 'Insufficient permissions to write to log directory %s' % settings['log_directory'] sys.exit(1) else: try: os.makedirs(settings['log_directory']) except: print 'Unable to create log directory %s' % settings['log_directory'] sys.exit(1) # logging configuration LOG_SETTINGS = { 'version': 1, 'handlers': { settings['filename'] + '-js': { 'class': 'logging.handlers.RotatingFileHandler', 'level': 'INFO', 'formatter': 'xdata', 'filename': os.path.join(settings['log_directory'], settings['filename'] + '-js.log'), 'mode': 'a', 'maxBytes': 100e6, 'backupCount': 10, }, # Deprecated settings['filename'] + '-v2': { 'class': 'logging.handlers.RotatingFileHandler', 'level': 'INFO', 'formatter': 'xdata', 'filename': os.path.join(settings['log_directory'], settings['filename'] + '-v2.log'), 'mode': 'a', 'maxBytes': 100e6, 'backupCount': 10, }, settings['filename'] + '-v3': { 'class': 'logging.handlers.RotatingFileHandler', 'level': 'INFO', 'formatter': 'xdata', 'filename': os.path.join(settings['log_directory'], settings['filename'] + '-v3.log'), 'mode': 'a', 'maxBytes': 100e6, 'backupCount': 10, }, settings['filename'] + '-error': { 'class': 'logging.handlers.RotatingFileHandler', 'level': 'INFO', 'formatter': 'detailed', 'filename': os.path.join(settings['log_directory'], settings['filename'] + '-error.log'), 'mode': 'a', 'maxBytes': 100e6, 'backupCount': 10, }, }, 'formatters': { 'xdata': { 'format': '%(message)s', }, 'detailed': { 'format': '%(asctime)s %(module)-17s line:%(lineno)-4d ' \ '%(levelname)-8s %(message)s', }, 'email': { 'format': 'Timestamp: %(asctime)s\nModule: %(module)s\n' \ 'Line: %(lineno)d\nMessage: %(message)s', }, }, 'loggers': { settings['filename'] + '-js': { 'level':'DEBUG', 'handlers': [settings['filename'] + '-js',] }, settings['filename'] + '-v2': { 'level':'DEBUG', 'handlers': [settings['filename'] + '-v2',] }, settings['filename'] + '-v3': { 'level':'DEBUG', 'handlers': [settings['filename'] + '-v3',] }, settings['filename'] + '-error': { 'level':'DEBUG', 'handlers': [settings['filename'] + '-error',] }, } } config.dictConfig(LOG_SETTINGS) logger_js = logging.getLogger(settings['filename'] + '-js') logger = logging.getLogger(settings['filename'] + '-v2') loggerv3 = logging.getLogger(settings['filename'] + '-v3') logger_err = logging.getLogger(settings['filename'] + '-error') wf_dict = { 0: 'WF_OTHER', 1: 'WF_DEFINE', 2: 'WF_GETDATA', 3: 'WF_EXPLORE', 4: 'WF_CREATE', 5: 'WF_ENRICH', 6: 'WF_TRANSFORM' } def get_allow_origin(request): if 'allow_origin' not in settings or settings['allow_origin'] is None: return '*' elif isinstance(settings['allow_origin'], list): origin = request.getHeader('Origin') return 'null' if origin not in settings['allow_origin'] else origin else: return settings['allow_origin'] def log_json(data): if ('useraleVersion' in data) and (data ['useraleVersion'].split('.')[0] == '4'): logger_js.info(simplejson.dumps(data)) elif ('useraleVersion' in data) and (data['useraleVersion'].split('.')[0] == '3'): loggerv3.info(simplejson.dumps(data)) elif ('parms' in data) and ('wf_state' in data['parms']): data['wf_state_longname'] = wf_dict[data['parms']['wf_state']] logger.info(simplejson.dumps(data)) class Logger(Resource): def render_OPTIONS(self, request): request.setHeader('Access-Control-Allow-Origin', get_allow_origin(request)) request.setHeader('Access-Control-Allow-Methods', 'POST') request.setHeader('Access-Control-Allow-Headers', 'x-prototype-version,x-requested-with,Content-Type') request.setHeader('Access-Control-Max-Age', 2520) # 42 hours return '' def render_POST(self, request): request.setHeader('Access-Control-Allow-Origin', get_allow_origin(request)) request.setHeader('Access-Control-Allow-Methods', 'POST') request.setHeader('Access-Control-Allow-Headers', 'x-prototype-version,x-requested-with,Content-Type') request.setHeader('Access-Control-Max-Age', 2520) # 42 hours data = simplejson.loads(request.content.getvalue()) try: if isinstance(data, list): for datum in data: log_json(datum) else: log_json(data) except Exception as e: logger_err.error(e) return '' root = Resource() root.putChild('send_log', Logger()) # create a resource to serve static files tmp_service = internet.TCPServer(settings['port'], Site(root)) application = service.Application('User-ALE') # attach the service to its parent application tmp_service.setServiceParent(application) startApplication(application, 0) reactor.run()
draperlaboratory/user-ale
demo/dashboard/files/twisted_app.py
Python
apache-2.0
7,791
0.005391
#!/usr/bin/env python # -*- coding: utf-8 -*- # # This file is subject to the terms and conditions defined in # file 'LICENSE.md', which is part of this source code package. # import json import yaml from kubernetes_py.utils import is_valid_string class DeleteOptions(object): """ http://kubernetes.io/docs/api-reference/v1/definitions/#_v1_deleteoptions """ def __init__(self): super(DeleteOptions, self).__init__() # TODO(froch): add support for the below. # self._preconditions = None self._kind = "DeleteOptions" self._api_version = "v1" self._grace_period_seconds = 0 self._orphan_dependents = False # ------------------------------------------------------------------------------------- kind @property def kind(self): return self._kind @kind.setter def kind(self, k=0): if not is_valid_string(k): raise SyntaxError("DeleteOptions: kind: [ {0} ] is invalid.".format(k)) self._kind = k # ------------------------------------------------------------------------------------- apiVersion @property def api_version(self): return self._api_version @api_version.setter def api_version(self, v=0): if not is_valid_string(v): raise SyntaxError("DeleteOptions: api_version: [ {0} ] is invalid.".format(v)) self._kind = v # ------------------------------------------------------------------------------------- grace period seconds @property def grace_period_seconds(self): return self._grace_period_seconds @grace_period_seconds.setter def grace_period_seconds(self, secs=0): if not isinstance(secs, int): raise SyntaxError("DeleteOptions: grace_period_seconds: [ {0} ] is invalid.".format(secs)) self._grace_period_seconds = secs # ------------------------------------------------------------------------------------- orphanDependents @property def orphan_dependents(self): return self._orphan_dependents @orphan_dependents.setter def orphan_dependents(self, orphan=False): if not isinstance(orphan, bool): raise SyntaxError("DeleteOptions: orphan_dependents: [ {0} ] is invalid.".format(orphan)) self._orphan_dependents = orphan # ------------------------------------------------------------------------------------- serialize def serialize(self): data = {} if self.kind is not None: data["kind"] = self.kind if self.api_version is not None: data["apiVersion"] = self.api_version if self.grace_period_seconds is not None: data["gracePeriodSeconds"] = self.grace_period_seconds if self.orphan_dependents is not None: data["orphanDependents"] = self.orphan_dependents return data def as_json(self): data = self.serialize() j = json.dumps(data, indent=4) return j def as_yaml(self): data = self.serialize() y = yaml.dump(data, default_flow_style=False) return y
mnubo/kubernetes-py
kubernetes_py/models/v1/DeleteOptions.py
Python
apache-2.0
3,140
0.002866
from reportlab.lib import styles from reportlab.lib import colors from reportlab.lib.units import cm from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT, TA_JUSTIFY from reportlab.platypus import Preformatted, Paragraph, Frame, \ Image, Table, TableStyle, Spacer def getParagraphStyles(): """Returns a dictionary of styles to get you started. We will provide a way to specify a module of these. Note that this just includes TableStyles as well as ParagraphStyles for any tables you wish to use. """ stylesheet = {} ParagraphStyle = styles.ParagraphStyle para = ParagraphStyle('Normal', None) #the ancestor of all para.fontName = 'Times-Roman' para.fontSize = 24 para.leading = 28 stylesheet['Normal'] = para #This one is spaced out a bit... para = ParagraphStyle('BodyText', stylesheet['Normal']) para.spaceBefore = 12 stylesheet['BodyText'] = para #Indented, for lists para = ParagraphStyle('Indent', stylesheet['Normal']) para.leftIndent = 36 para.firstLineIndent = 0 stylesheet['Indent'] = para para = ParagraphStyle('Centered', stylesheet['Normal']) para.alignment = TA_CENTER stylesheet['Centered'] = para para = ParagraphStyle('BigCentered', stylesheet['Normal']) para.spaceBefore = 12 para.alignment = TA_CENTER stylesheet['BigCentered'] = para para = ParagraphStyle('Italic', stylesheet['BodyText']) para.fontName = 'Times-Italic' stylesheet['Italic'] = para para = ParagraphStyle('Title', stylesheet['Normal']) para.fontName = 'Times-Roman' para.fontSize = 48 para.leading = 58 para.alignment = TA_CENTER stylesheet['Title'] = para para = ParagraphStyle('Heading1', stylesheet['Normal']) para.fontName = 'Times-Bold' para.fontSize = 36 para.leading = 44 para.alignment = TA_CENTER stylesheet['Heading1'] = para para = ParagraphStyle('Heading2', stylesheet['Normal']) para.fontName = 'Times-Bold' para.fontSize = 28 para.leading = 34 para.spaceBefore = 24 stylesheet['Heading2'] = para para = ParagraphStyle('Heading3', stylesheet['Normal']) para.fontName = 'Times-BoldItalic' para.spaceBefore = 24 stylesheet['Heading3'] = para para = ParagraphStyle('Heading4', stylesheet['Normal']) para.fontName = 'Times-BoldItalic' para.spaceBefore = 6 stylesheet['Heading4'] = para para = ParagraphStyle('Bullet', stylesheet['Normal']) para.firstLineIndent = 0 para.leftIndent = 56 para.spaceBefore = 6 para.bulletFontName = 'Symbol' para.bulletFontSize = 24 para.bulletIndent = 20 stylesheet['Bullet'] = para para = ParagraphStyle('Definition', stylesheet['Normal']) #use this for definition lists para.firstLineIndent = 0 para.leftIndent = 72 para.bulletIndent = 0 para.spaceBefore = 12 para.bulletFontName = 'Helvetica-BoldOblique' para.bulletFontSize = 24 stylesheet['Definition'] = para para = ParagraphStyle('Code', stylesheet['Normal']) para.fontName = 'Courier' para.fontSize = 16 para.leading = 18 para.leftIndent = 36 stylesheet['Code'] = para para = ParagraphStyle('PythonCode', stylesheet['Normal']) para.fontName = 'Courier' para.fontSize = 16 para.leading = 18 para.leftIndent = 36 stylesheet['PythonCode'] = para para = ParagraphStyle('Small', stylesheet['Normal']) para.fontSize = 12 para.leading = 14 stylesheet['Small'] = para #now for a table ts = TableStyle([ ('FONT', (0,0), (-1,-1), 'Times-Roman', 24), ('LINEABOVE', (0,0), (-1,0), 2, colors.green), ('LINEABOVE', (0,1), (-1,-1), 0.25, colors.black), ('LINEBELOW', (0,-1), (-1,-1), 2, colors.green), ('LINEBEFORE', (-1,0), (-1,-1), 2, colors.black), ('ALIGN', (1,1), (-1,-1), 'RIGHT'), #all numeric cells right aligned ('TEXTCOLOR', (0,1), (0,-1), colors.red), ('BACKGROUND', (0,0), (-1,0), colors.Color(0,0.7,0.7)) ]) stylesheet['table1'] = ts return stylesheet
nickpack/reportlab
tools/pythonpoint/styles/standard.py
Python
bsd-3-clause
4,262
0.005631
# This file is part of the MapProxy project. # Copyright (C) 2011-2013 Omniscale <http://omniscale.de> # 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 hashlib import logging import os import re import sqlite3 import threading from mapproxy.cache.base import TileCacheBase, tile_buffer, REMOVE_ON_UNLOCK from mapproxy.compat import BytesIO, PY2, itertools from mapproxy.image import ImageSource from mapproxy.srs import get_epsg_num from mapproxy.util.fs import ensure_directory from mapproxy.util.lock import FileLock log = logging.getLogger(__name__) class GeopackageCache(TileCacheBase): supports_timestamp = False def __init__(self, geopackage_file, tile_grid, table_name, with_timestamps=False, timeout=30, wal=False): self.tile_grid = tile_grid self.table_name = self._check_table_name(table_name) self.lock_cache_id = 'gpkg' + hashlib.md5(geopackage_file.encode('utf-8')).hexdigest() self.geopackage_file = geopackage_file # XXX timestamps not implemented self.supports_timestamp = with_timestamps self.timeout = timeout self.wal = wal self.ensure_gpkg() self._db_conn_cache = threading.local() @property def db(self): if not getattr(self._db_conn_cache, 'db', None): self.ensure_gpkg() self._db_conn_cache.db = sqlite3.connect(self.geopackage_file, timeout=self.timeout) return self._db_conn_cache.db def cleanup(self): """ Close all open connection and remove them from cache. """ if getattr(self._db_conn_cache, 'db', None): self._db_conn_cache.db.close() self._db_conn_cache.db = None @staticmethod def _check_table_name(table_name): """ >>> GeopackageCache._check_table_name("test") 'test' >>> GeopackageCache._check_table_name("test_2") 'test_2' >>> GeopackageCache._check_table_name("test-2") 'test-2' >>> GeopackageCache._check_table_name("test3;") Traceback (most recent call last): ... ValueError: The table_name test3; contains unsupported characters. >>> GeopackageCache._check_table_name("table name") Traceback (most recent call last): ... ValueError: The table_name table name contains unsupported characters. @param table_name: A desired name for an geopackage table. @return: The name of the table if it is good, otherwise an exception. """ # Regex string indicating table names which will be accepted. regex_str = '^[a-zA-Z0-9_-]+$' if re.match(regex_str, table_name): return table_name else: msg = ("The table name may only contain alphanumeric characters, an underscore, " "or a dash: {}".format(regex_str)) log.info(msg) raise ValueError("The table_name {0} contains unsupported characters.".format(table_name)) def ensure_gpkg(self): if not os.path.isfile(self.geopackage_file): with FileLock(self.geopackage_file + '.init.lck', remove_on_unlock=REMOVE_ON_UNLOCK): ensure_directory(self.geopackage_file) self._initialize_gpkg() else: if not self.check_gpkg(): ensure_directory(self.geopackage_file) self._initialize_gpkg() def check_gpkg(self): if not self._verify_table(): return False if not self._verify_gpkg_contents(): return False if not self._verify_tile_size(): return False return True def _verify_table(self): with sqlite3.connect(self.geopackage_file) as db: cur = db.execute("""SELECT name FROM sqlite_master WHERE type='table' AND name=?""", (self.table_name,)) content = cur.fetchone() if not content: # Table doesn't exist _initialize_gpkg will create a new one. return False return True def _verify_gpkg_contents(self): with sqlite3.connect(self.geopackage_file) as db: cur = db.execute("""SELECT * FROM gpkg_contents WHERE table_name = ?""" , (self.table_name,)) results = cur.fetchone() if not results: # Table doesn't exist in gpkg_contents _initialize_gpkg will add it. return False gpkg_data_type = results[1] gpkg_srs_id = results[9] cur = db.execute("""SELECT * FROM gpkg_spatial_ref_sys WHERE srs_id = ?""" , (gpkg_srs_id,)) gpkg_coordsys_id = cur.fetchone()[3] if gpkg_data_type.lower() != "tiles": log.info("The geopackage table name already exists for a data type other than tiles.") raise ValueError("table_name is improperly configured.") if gpkg_coordsys_id != get_epsg_num(self.tile_grid.srs.srs_code): log.info( "The geopackage {0} table name {1} already exists and has an SRS of {2}, which does not match the configured" \ " Mapproxy SRS of {3}.".format(self.geopackage_file, self.table_name, gpkg_coordsys_id, get_epsg_num(self.tile_grid.srs.srs_code))) raise ValueError("srs is improperly configured.") return True def _verify_tile_size(self): with sqlite3.connect(self.geopackage_file) as db: cur = db.execute( """SELECT * FROM gpkg_tile_matrix WHERE table_name = ?""", (self.table_name,)) results = cur.fetchall() results = results[0] tile_size = self.tile_grid.tile_size if not results: # There is no tile conflict. Return to allow the creation of new tiles. return True gpkg_table_name, gpkg_zoom_level, gpkg_matrix_width, gpkg_matrix_height, gpkg_tile_width, gpkg_tile_height, \ gpkg_pixel_x_size, gpkg_pixel_y_size = results resolution = self.tile_grid.resolution(gpkg_zoom_level) if gpkg_tile_width != tile_size[0] or gpkg_tile_height != tile_size[1]: log.info( "The geopackage {0} table name {1} already exists and has tile sizes of ({2},{3})" " which is different than the configure tile sizes of ({4},{5}).".format(self.geopackage_file, self.table_name, gpkg_tile_width, gpkg_tile_height, tile_size[0], tile_size[1])) log.info("The current mapproxy configuration is invalid for this geopackage.") raise ValueError("tile_size is improperly configured.") if not is_close(gpkg_pixel_x_size, resolution) or not is_close(gpkg_pixel_y_size, resolution): log.info( "The geopackage {0} table name {1} already exists and level {2} a resolution of ({3:.13f},{4:.13f})" " which is different than the configured resolution of ({5:.13f},{6:.13f}).".format(self.geopackage_file, self.table_name, gpkg_zoom_level, gpkg_pixel_x_size, gpkg_pixel_y_size, resolution, resolution)) log.info("The current mapproxy configuration is invalid for this geopackage.") raise ValueError("res is improperly configured.") return True def _initialize_gpkg(self): log.info('initializing Geopackage file %s', self.geopackage_file) db = sqlite3.connect(self.geopackage_file) if self.wal: db.execute('PRAGMA journal_mode=wal') proj = get_epsg_num(self.tile_grid.srs.srs_code) stmts = [""" CREATE TABLE IF NOT EXISTS gpkg_contents (table_name TEXT NOT NULL PRIMARY KEY, -- The name of the tiles, or feature table data_type TEXT NOT NULL, -- Type of data stored in the table: "features" per clause Features (http://www.geopackage.org/spec/#features), "tiles" per clause Tiles (http://www.geopackage.org/spec/#tiles), or an implementer-defined value for other data tables per clause in an Extended GeoPackage identifier TEXT UNIQUE, -- A human-readable identifier (e.g. short name) for the table_name content description TEXT DEFAULT '', -- A human-readable description for the table_name content last_change DATETIME NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')), -- Timestamp value in ISO 8601 format as defined by the strftime function %Y-%m-%dT%H:%M:%fZ format string applied to the current time min_x DOUBLE, -- Bounding box minimum easting or longitude for all content in table_name min_y DOUBLE, -- Bounding box minimum northing or latitude for all content in table_name max_x DOUBLE, -- Bounding box maximum easting or longitude for all content in table_name max_y DOUBLE, -- Bounding box maximum northing or latitude for all content in table_name srs_id INTEGER, -- Spatial Reference System ID: gpkg_spatial_ref_sys.srs_id; when data_type is features, SHALL also match gpkg_geometry_columns.srs_id; When data_type is tiles, SHALL also match gpkg_tile_matrix_set.srs.id CONSTRAINT fk_gc_r_srs_id FOREIGN KEY (srs_id) REFERENCES gpkg_spatial_ref_sys(srs_id)) """, """ CREATE TABLE IF NOT EXISTS gpkg_spatial_ref_sys (srs_name TEXT NOT NULL, -- Human readable name of this SRS (Spatial Reference System) srs_id INTEGER NOT NULL PRIMARY KEY, -- Unique identifier for each Spatial Reference System within a GeoPackage organization TEXT NOT NULL, -- Case-insensitive name of the defining organization e.g. EPSG or epsg organization_coordsys_id INTEGER NOT NULL, -- Numeric ID of the Spatial Reference System assigned by the organization definition TEXT NOT NULL, -- Well-known Text representation of the Spatial Reference System description TEXT) """, """ CREATE TABLE IF NOT EXISTS gpkg_tile_matrix (table_name TEXT NOT NULL, -- Tile Pyramid User Data Table Name zoom_level INTEGER NOT NULL, -- 0 <= zoom_level <= max_level for table_name matrix_width INTEGER NOT NULL, -- Number of columns (>= 1) in tile matrix at this zoom level matrix_height INTEGER NOT NULL, -- Number of rows (>= 1) in tile matrix at this zoom level tile_width INTEGER NOT NULL, -- Tile width in pixels (>= 1) for this zoom level tile_height INTEGER NOT NULL, -- Tile height in pixels (>= 1) for this zoom level pixel_x_size DOUBLE NOT NULL, -- In t_table_name srid units or default meters for srid 0 (>0) pixel_y_size DOUBLE NOT NULL, -- In t_table_name srid units or default meters for srid 0 (>0) CONSTRAINT pk_ttm PRIMARY KEY (table_name, zoom_level), CONSTRAINT fk_tmm_table_name FOREIGN KEY (table_name) REFERENCES gpkg_contents(table_name)) """, """ CREATE TABLE IF NOT EXISTS gpkg_tile_matrix_set (table_name TEXT NOT NULL PRIMARY KEY, -- Tile Pyramid User Data Table Name srs_id INTEGER NOT NULL, -- Spatial Reference System ID: gpkg_spatial_ref_sys.srs_id min_x DOUBLE NOT NULL, -- Bounding box minimum easting or longitude for all content in table_name min_y DOUBLE NOT NULL, -- Bounding box minimum northing or latitude for all content in table_name max_x DOUBLE NOT NULL, -- Bounding box maximum easting or longitude for all content in table_name max_y DOUBLE NOT NULL, -- Bounding box maximum northing or latitude for all content in table_name CONSTRAINT fk_gtms_table_name FOREIGN KEY (table_name) REFERENCES gpkg_contents(table_name), CONSTRAINT fk_gtms_srs FOREIGN KEY (srs_id) REFERENCES gpkg_spatial_ref_sys (srs_id)) """, """ CREATE TABLE IF NOT EXISTS [{0}] (id INTEGER PRIMARY KEY AUTOINCREMENT, -- Autoincrement primary key zoom_level INTEGER NOT NULL, -- min(zoom_level) <= zoom_level <= max(zoom_level) for t_table_name tile_column INTEGER NOT NULL, -- 0 to tile_matrix matrix_width - 1 tile_row INTEGER NOT NULL, -- 0 to tile_matrix matrix_height - 1 tile_data BLOB NOT NULL, -- Of an image MIME type specified in clauses Tile Encoding PNG, Tile Encoding JPEG, Tile Encoding WEBP UNIQUE (zoom_level, tile_column, tile_row)) """.format(self.table_name) ] for stmt in stmts: db.execute(stmt) db.execute("PRAGMA foreign_keys = 1;") # List of WKT execute statements and data.(""" wkt_statement = """ INSERT OR REPLACE INTO gpkg_spatial_ref_sys ( srs_id, organization, organization_coordsys_id, srs_name, definition) VALUES (?, ?, ?, ?, ?) """ wkt_entries = [(3857, 'epsg', 3857, 'WGS 84 / Pseudo-Mercator', """ PROJCS["WGS 84 / Pseudo-Mercator",GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,\ AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],\ UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","9122"]]AUTHORITY["EPSG","4326"]],\ PROJECTION["Mercator_1SP"],PARAMETER["central_meridian",0],PARAMETER["scale_factor",1],PARAMETER["false_easting",0],\ PARAMETER["false_northing",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["X",EAST],AXIS["Y",NORTH]\ """ ), (4326, 'epsg', 4326, 'WGS 84', """ GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],\ AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,\ AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]]\ """ ), (-1, 'NONE', -1, ' ', 'undefined'), (0, 'NONE', 0, ' ', 'undefined') ] if get_epsg_num(self.tile_grid.srs.srs_code) not in [4326, 3857]: wkt_entries.append((proj, 'epsg', proj, 'Not provided', "Added via Mapproxy.")) db.commit() # Add geopackage version to the header (1.0) db.execute("PRAGMA application_id = 1196437808;") db.commit() for wkt_entry in wkt_entries: try: db.execute(wkt_statement, (wkt_entry[0], wkt_entry[1], wkt_entry[2], wkt_entry[3], wkt_entry[4])) except sqlite3.IntegrityError: log.info("srs_id already exists.".format(wkt_entry[0])) db.commit() # Ensure that tile table exists here, don't overwrite a valid entry. try: db.execute(""" INSERT INTO gpkg_contents ( table_name, data_type, identifier, description, min_x, max_x, min_y, max_y, srs_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?); """, (self.table_name, "tiles", self.table_name, "Created with Mapproxy.", self.tile_grid.bbox[0], self.tile_grid.bbox[2], self.tile_grid.bbox[1], self.tile_grid.bbox[3], proj)) except sqlite3.IntegrityError: pass db.commit() # Ensure that tile set exists here, don't overwrite a valid entry. try: db.execute(""" INSERT INTO gpkg_tile_matrix_set (table_name, srs_id, min_x, max_x, min_y, max_y) VALUES (?, ?, ?, ?, ?, ?); """, ( self.table_name, proj, self.tile_grid.bbox[0], self.tile_grid.bbox[2], self.tile_grid.bbox[1], self.tile_grid.bbox[3])) except sqlite3.IntegrityError: pass db.commit() tile_size = self.tile_grid.tile_size for grid, resolution, level in zip(self.tile_grid.grid_sizes, self.tile_grid.resolutions, range(20)): db.execute("""INSERT OR REPLACE INTO gpkg_tile_matrix (table_name, zoom_level, matrix_width, matrix_height, tile_width, tile_height, pixel_x_size, pixel_y_size) VALUES(?, ?, ?, ?, ?, ?, ?, ?) """, (self.table_name, level, grid[0], grid[1], tile_size[0], tile_size[1], resolution, resolution)) db.commit() db.close() def is_cached(self, tile): if tile.coord is None: return True if tile.source: return True return self.load_tile(tile) def store_tile(self, tile): if tile.stored: return True return self._store_bulk([tile]) def store_tiles(self, tiles): tiles = [t for t in tiles if not t.stored] return self._store_bulk(tiles) def _store_bulk(self, tiles): records = [] # tile_buffer (as_buffer) will encode the tile to the target format # we collect all tiles before, to avoid having the db transaction # open during this slow encoding for tile in tiles: with tile_buffer(tile) as buf: if PY2: content = buffer(buf.read()) else: content = buf.read() x, y, level = tile.coord records.append((level, x, y, content)) cursor = self.db.cursor() try: stmt = "INSERT OR REPLACE INTO [{0}] (zoom_level, tile_column, tile_row, tile_data) VALUES (?,?,?,?)".format( self.table_name) cursor.executemany(stmt, records) self.db.commit() except sqlite3.OperationalError as ex: log.warn('unable to store tile: %s', ex) return False return True def load_tile(self, tile, with_metadata=False): if tile.source or tile.coord is None: return True cur = self.db.cursor() cur.execute("""SELECT tile_data FROM [{0}] WHERE tile_column = ? AND tile_row = ? AND zoom_level = ?""".format(self.table_name), tile.coord) content = cur.fetchone() if content: tile.source = ImageSource(BytesIO(content[0])) return True else: return False def load_tiles(self, tiles, with_metadata=False): # associate the right tiles with the cursor tile_dict = {} coords = [] for tile in tiles: if tile.source or tile.coord is None: continue x, y, level = tile.coord coords.append(x) coords.append(y) coords.append(level) tile_dict[(x, y)] = tile if not tile_dict: # all tiles loaded or coords are None return True stmt_base = "SELECT tile_column, tile_row, tile_data FROM [{0}] WHERE ".format(self.table_name) loaded_tiles = 0 # SQLite is limited to 1000 args -> split into multiple requests if more arguments are needed while coords: cur_coords = coords[:999] stmt = stmt_base + ' OR '.join( ['(tile_column = ? AND tile_row = ? AND zoom_level = ?)'] * (len(cur_coords) // 3)) cursor = self.db.cursor() cursor.execute(stmt, cur_coords) for row in cursor: loaded_tiles += 1 tile = tile_dict[(row[0], row[1])] data = row[2] tile.size = len(data) tile.source = ImageSource(BytesIO(data)) cursor.close() coords = coords[999:] return loaded_tiles == len(tile_dict) def remove_tile(self, tile): cursor = self.db.cursor() cursor.execute( "DELETE FROM [{0}] WHERE (tile_column = ? AND tile_row = ? AND zoom_level = ?)".format(self.table_name), tile.coord) self.db.commit() if cursor.rowcount: return True return False def remove_level_tiles_before(self, level, timestamp): if timestamp == 0: cursor = self.db.cursor() cursor.execute( "DELETE FROM [{0}] WHERE (zoom_level = ?)".format(self.table_name), (level,)) self.db.commit() log.info("Cursor rowcount = {0}".format(cursor.rowcount)) if cursor.rowcount: return True return False def load_tile_metadata(self, tile): self.load_tile(tile) class GeopackageLevelCache(TileCacheBase): def __init__(self, geopackage_dir, tile_grid, table_name, timeout=30, wal=False): self.lock_cache_id = 'gpkg-' + hashlib.md5(geopackage_dir.encode('utf-8')).hexdigest() self.cache_dir = geopackage_dir self.tile_grid = tile_grid self.table_name = table_name self.timeout = timeout self.wal = wal self._geopackage = {} self._geopackage_lock = threading.Lock() def _get_level(self, level): if level in self._geopackage: return self._geopackage[level] with self._geopackage_lock: if level not in self._geopackage: geopackage_filename = os.path.join(self.cache_dir, '%s.gpkg' % level) self._geopackage[level] = GeopackageCache( geopackage_filename, self.tile_grid, self.table_name, with_timestamps=True, timeout=self.timeout, wal=self.wal, ) return self._geopackage[level] def cleanup(self): """ Close all open connection and remove them from cache. """ with self._geopackage_lock: for gp in self._geopackage.values(): gp.cleanup() def is_cached(self, tile): if tile.coord is None: return True if tile.source: return True return self._get_level(tile.coord[2]).is_cached(tile) def store_tile(self, tile): if tile.stored: return True return self._get_level(tile.coord[2]).store_tile(tile) def store_tiles(self, tiles): failed = False for level, tiles in itertools.groupby(tiles, key=lambda t: t.coord[2]): tiles = [t for t in tiles if not t.stored] res = self._get_level(level).store_tiles(tiles) if not res: failed = True return failed def load_tile(self, tile, with_metadata=False): if tile.source or tile.coord is None: return True return self._get_level(tile.coord[2]).load_tile(tile, with_metadata=with_metadata) def load_tiles(self, tiles, with_metadata=False): level = None for tile in tiles: if tile.source or tile.coord is None: continue level = tile.coord[2] break if not level: return True return self._get_level(level).load_tiles(tiles, with_metadata=with_metadata) def remove_tile(self, tile): if tile.coord is None: return True return self._get_level(tile.coord[2]).remove_tile(tile) def remove_level_tiles_before(self, level, timestamp): level_cache = self._get_level(level) if timestamp == 0: level_cache.cleanup() os.unlink(level_cache.geopackage_file) return True else: return level_cache.remove_level_tiles_before(level, timestamp) def is_close(a, b, rel_tol=1e-09, abs_tol=0.0): """ See PEP 485, added here for legacy versions. >>> is_close(0.0, 0.0) True >>> is_close(1, 1.0) True >>> is_close(0.01, 0.001) False >>> is_close(0.0001001, 0.0001, rel_tol=1e-02) True >>> is_close(0.0001001, 0.0001) False @param a: An int or float. @param b: An int or float. @param rel_tol: Relative tolerance - maximumed allow difference between two numbers. @param abs_tol: Absolute tolerance - minimum absolute tolerance. @return: True if the values a and b are close. """ return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
olt/mapproxy
mapproxy/cache/geopackage.py
Python
apache-2.0
27,948
0.003936
# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # 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. """ Starting point for routing EC2 requests. """ import hashlib from oslo_config import cfg from oslo_serialization import jsonutils from oslo_utils import importutils from oslo_utils import netutils from oslo_utils import timeutils import requests import six import webob import webob.dec import webob.exc from nova.api.ec2 import apirequest from nova.api.ec2 import ec2utils from nova.api.ec2 import faults from nova.api import validator from nova import context from nova import exception from nova.i18n import _ from nova.i18n import _LE from nova.i18n import _LW from nova.openstack.common import context as common_context from nova.openstack.common import log as logging from nova.openstack.common import memorycache from nova import wsgi LOG = logging.getLogger(__name__) ec2_opts = [ cfg.IntOpt('lockout_attempts', default=5, help='Number of failed auths before lockout.'), cfg.IntOpt('lockout_minutes', default=15, help='Number of minutes to lockout if triggered.'), cfg.IntOpt('lockout_window', default=15, help='Number of minutes for lockout window.'), cfg.StrOpt('keystone_ec2_url', default='http://localhost:5000/v2.0/ec2tokens', help='URL to get token from ec2 request.'), cfg.BoolOpt('ec2_private_dns_show_ip', default=False, help='Return the IP address as private dns hostname in ' 'describe instances'), cfg.BoolOpt('ec2_strict_validation', default=True, help='Validate security group names' ' according to EC2 specification'), cfg.IntOpt('ec2_timestamp_expiry', default=300, help='Time in seconds before ec2 timestamp expires'), cfg.BoolOpt('keystone_ec2_insecure', default=False, help='Disable SSL ' 'certificate verification.'), ] CONF = cfg.CONF CONF.register_opts(ec2_opts) CONF.import_opt('use_forwarded_for', 'nova.api.auth') CONF.import_group('ssl', 'nova.openstack.common.sslutils') # Fault Wrapper around all EC2 requests class FaultWrapper(wsgi.Middleware): """Calls the middleware stack, captures any exceptions into faults.""" @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): try: return req.get_response(self.application) except Exception as ex: LOG.exception(_LE("FaultWrapper: %s"), ex) return faults.Fault(webob.exc.HTTPInternalServerError()) class RequestLogging(wsgi.Middleware): """Access-Log akin logging for all EC2 API requests.""" @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): start = timeutils.utcnow() rv = req.get_response(self.application) self.log_request_completion(rv, req, start) return rv def log_request_completion(self, response, request, start): apireq = request.environ.get('ec2.request', None) if apireq: controller = apireq.controller action = apireq.action else: controller = None action = None ctxt = request.environ.get('nova.context', None) delta = timeutils.utcnow() - start seconds = delta.seconds microseconds = delta.microseconds LOG.info( "%s.%ss %s %s %s %s:%s %s [%s] %s %s", seconds, microseconds, request.remote_addr, request.method, "%s%s" % (request.script_name, request.path_info), controller, action, response.status_int, request.user_agent, request.content_type, response.content_type, context=ctxt) # noqa class Lockout(wsgi.Middleware): """Lockout for x minutes on y failed auths in a z minute period. x = lockout_timeout flag y = lockout_window flag z = lockout_attempts flag Uses memcached if lockout_memcached_servers flag is set, otherwise it uses a very simple in-process cache. Due to the simplicity of the implementation, the timeout window is started with the first failed request, so it will block if there are x failed logins within that period. There is a possible race condition where simultaneous requests could sneak in before the lockout hits, but this is extremely rare and would only result in a couple of extra failed attempts. """ def __init__(self, application): """middleware can use fake for testing.""" self.mc = memorycache.get_client() super(Lockout, self).__init__(application) @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): access_key = str(req.params['AWSAccessKeyId']) failures_key = "authfailures-%s" % access_key failures = int(self.mc.get(failures_key) or 0) if failures >= CONF.lockout_attempts: detail = _("Too many failed authentications.") raise webob.exc.HTTPForbidden(explanation=detail) res = req.get_response(self.application) if res.status_int == 403: failures = self.mc.incr(failures_key) if failures is None: # NOTE(vish): To use incr, failures has to be a string. self.mc.set(failures_key, '1', time=CONF.lockout_window * 60) elif failures >= CONF.lockout_attempts: LOG.warning(_LW('Access key %(access_key)s has had ' '%(failures)d failed authentications and ' 'will be locked out for %(lock_mins)d ' 'minutes.'), {'access_key': access_key, 'failures': failures, 'lock_mins': CONF.lockout_minutes}) self.mc.set(failures_key, str(failures), time=CONF.lockout_minutes * 60) return res class EC2KeystoneAuth(wsgi.Middleware): """Authenticate an EC2 request with keystone and convert to context.""" def _get_signature(self, req): """Extract the signature from the request. This can be a get/post variable or for version 4 also in a header called 'Authorization'. - params['Signature'] == version 0,1,2,3 - params['X-Amz-Signature'] == version 4 - header 'Authorization' == version 4 """ sig = req.params.get('Signature') or req.params.get('X-Amz-Signature') if sig is None and 'Authorization' in req.headers: auth_str = req.headers['Authorization'] sig = auth_str.partition("Signature=")[2].split(',')[0] return sig def _get_access(self, req): """Extract the access key identifier. For version 0/1/2/3 this is passed as the AccessKeyId parameter, for version 4 it is either an X-Amz-Credential parameter or a Credential= field in the 'Authorization' header string. """ access = req.params.get('AWSAccessKeyId') if access is None: cred_param = req.params.get('X-Amz-Credential') if cred_param: access = cred_param.split("/")[0] if access is None and 'Authorization' in req.headers: auth_str = req.headers['Authorization'] cred_str = auth_str.partition("Credential=")[2].split(',')[0] access = cred_str.split("/")[0] return access @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): # NOTE(alevine) We need to calculate the hash here because # subsequent access to request modifies the req.body so the hash # calculation will yield invalid results. body_hash = hashlib.sha256(req.body).hexdigest() request_id = common_context.generate_request_id() signature = self._get_signature(req) if not signature: msg = _("Signature not provided") return faults.ec2_error_response(request_id, "AuthFailure", msg, status=400) access = self._get_access(req) if not access: msg = _("Access key not provided") return faults.ec2_error_response(request_id, "AuthFailure", msg, status=400) if 'X-Amz-Signature' in req.params or 'Authorization' in req.headers: auth_params = {} else: # Make a copy of args for authentication and signature verification auth_params = dict(req.params) # Not part of authentication args auth_params.pop('Signature', None) cred_dict = { 'access': access, 'signature': signature, 'host': req.host, 'verb': req.method, 'path': req.path, 'params': auth_params, 'headers': req.headers, 'body_hash': body_hash } if "ec2" in CONF.keystone_ec2_url: creds = {'ec2Credentials': cred_dict} else: creds = {'auth': {'OS-KSEC2:ec2Credentials': cred_dict}} creds_json = jsonutils.dumps(creds) headers = {'Content-Type': 'application/json'} verify = not CONF.keystone_ec2_insecure if verify and CONF.ssl.ca_file: verify = CONF.ssl.ca_file cert = None if CONF.ssl.cert_file and CONF.ssl.key_file: cert = (CONF.ssl.cert_file, CONF.ssl.key_file) elif CONF.ssl.cert_file: cert = CONF.ssl.cert_file response = requests.request('POST', CONF.keystone_ec2_url, data=creds_json, headers=headers, verify=verify, cert=cert) status_code = response.status_code if status_code != 200: msg = response.reason return faults.ec2_error_response(request_id, "AuthFailure", msg, status=status_code) result = response.json() try: token_id = result['access']['token']['id'] user_id = result['access']['user']['id'] project_id = result['access']['token']['tenant']['id'] user_name = result['access']['user'].get('name') project_name = result['access']['token']['tenant'].get('name') roles = [role['name'] for role in result['access']['user']['roles']] except (AttributeError, KeyError) as e: LOG.error(_LE("Keystone failure: %s"), e) msg = _("Failure parsing response from keystone: %s") % e return faults.ec2_error_response(request_id, "AuthFailure", msg, status=400) remote_address = req.remote_addr if CONF.use_forwarded_for: remote_address = req.headers.get('X-Forwarded-For', remote_address) catalog = result['access']['serviceCatalog'] ctxt = context.RequestContext(user_id, project_id, user_name=user_name, project_name=project_name, roles=roles, auth_token=token_id, remote_address=remote_address, service_catalog=catalog) req.environ['nova.context'] = ctxt return self.application class NoAuth(wsgi.Middleware): """Add user:project as 'nova.context' to WSGI environ.""" @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): if 'AWSAccessKeyId' not in req.params: raise webob.exc.HTTPBadRequest() user_id, _sep, project_id = req.params['AWSAccessKeyId'].partition(':') project_id = project_id or user_id remote_address = req.remote_addr if CONF.use_forwarded_for: remote_address = req.headers.get('X-Forwarded-For', remote_address) ctx = context.RequestContext(user_id, project_id, is_admin=True, remote_address=remote_address) req.environ['nova.context'] = ctx return self.application class Requestify(wsgi.Middleware): def __init__(self, app, controller): super(Requestify, self).__init__(app) self.controller = importutils.import_object(controller) @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): # Not all arguments are mandatory with v4 signatures, as some data is # passed in the header, not query arguments. required_args = ['Action', 'Version'] non_args = ['Action', 'Signature', 'AWSAccessKeyId', 'SignatureMethod', 'SignatureVersion', 'Version', 'Timestamp'] args = dict(req.params) try: expired = ec2utils.is_ec2_timestamp_expired(req.params, expires=CONF.ec2_timestamp_expiry) if expired: msg = _("Timestamp failed validation.") LOG.debug("Timestamp failed validation") raise webob.exc.HTTPForbidden(explanation=msg) # Raise KeyError if omitted action = req.params['Action'] # Fix bug lp:720157 for older (version 1) clients # If not present assume v4 version = req.params.get('SignatureVersion', 4) if int(version) == 1: non_args.remove('SignatureMethod') if 'SignatureMethod' in args: args.pop('SignatureMethod') for non_arg in non_args: if non_arg in required_args: # Remove, but raise KeyError if omitted args.pop(non_arg) else: args.pop(non_arg, None) except KeyError: raise webob.exc.HTTPBadRequest() except exception.InvalidRequest as err: raise webob.exc.HTTPBadRequest(explanation=six.text_type(err)) LOG.debug('action: %s', action) for key, value in args.items(): LOG.debug('arg: %(key)s\t\tval: %(value)s', {'key': key, 'value': value}) # Success! api_request = apirequest.APIRequest(self.controller, action, req.params['Version'], args) req.environ['ec2.request'] = api_request return self.application class Authorizer(wsgi.Middleware): """Authorize an EC2 API request. Return a 401 if ec2.controller and ec2.action in WSGI environ may not be executed in nova.context. """ def __init__(self, application): super(Authorizer, self).__init__(application) self.action_roles = { 'CloudController': { 'DescribeAvailabilityZones': ['all'], 'DescribeRegions': ['all'], 'DescribeSnapshots': ['all'], 'DescribeKeyPairs': ['all'], 'CreateKeyPair': ['all'], 'DeleteKeyPair': ['all'], 'DescribeSecurityGroups': ['all'], 'ImportKeyPair': ['all'], 'AuthorizeSecurityGroupIngress': ['netadmin'], 'RevokeSecurityGroupIngress': ['netadmin'], 'CreateSecurityGroup': ['netadmin'], 'DeleteSecurityGroup': ['netadmin'], 'GetConsoleOutput': ['projectmanager', 'sysadmin'], 'DescribeVolumes': ['projectmanager', 'sysadmin'], 'CreateVolume': ['projectmanager', 'sysadmin'], 'AttachVolume': ['projectmanager', 'sysadmin'], 'DetachVolume': ['projectmanager', 'sysadmin'], 'DescribeInstances': ['all'], 'DescribeAddresses': ['all'], 'AllocateAddress': ['netadmin'], 'ReleaseAddress': ['netadmin'], 'AssociateAddress': ['netadmin'], 'DisassociateAddress': ['netadmin'], 'RunInstances': ['projectmanager', 'sysadmin'], 'TerminateInstances': ['projectmanager', 'sysadmin'], 'RebootInstances': ['projectmanager', 'sysadmin'], 'UpdateInstance': ['projectmanager', 'sysadmin'], 'StartInstances': ['projectmanager', 'sysadmin'], 'StopInstances': ['projectmanager', 'sysadmin'], 'DeleteVolume': ['projectmanager', 'sysadmin'], 'DescribeImages': ['all'], 'DeregisterImage': ['projectmanager', 'sysadmin'], 'RegisterImage': ['projectmanager', 'sysadmin'], 'DescribeImageAttribute': ['all'], 'ModifyImageAttribute': ['projectmanager', 'sysadmin'], 'UpdateImage': ['projectmanager', 'sysadmin'], 'CreateImage': ['projectmanager', 'sysadmin'], }, 'AdminController': { # All actions have the same permission: ['none'] (the default) # superusers will be allowed to run them # all others will get HTTPUnauthorized. }, } @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): context = req.environ['nova.context'] controller = req.environ['ec2.request'].controller.__class__.__name__ action = req.environ['ec2.request'].action allowed_roles = self.action_roles[controller].get(action, ['none']) if self._matches_any_role(context, allowed_roles): return self.application else: LOG.audit(_('Unauthorized request for controller=%(controller)s ' 'and action=%(action)s'), {'controller': controller, 'action': action}, context=context) raise webob.exc.HTTPUnauthorized() def _matches_any_role(self, context, roles): """Return True if any role in roles is allowed in context.""" if context.is_admin: return True if 'all' in roles: return True if 'none' in roles: return False return any(role in context.roles for role in roles) class Validator(wsgi.Middleware): def validate_ec2_id(val): if not validator.validate_str()(val): return False try: ec2utils.ec2_id_to_id(val) except exception.InvalidEc2Id: return False return True validator.validate_ec2_id = validate_ec2_id validator.DEFAULT_VALIDATOR = { 'instance_id': validator.validate_ec2_id, 'volume_id': validator.validate_ec2_id, 'image_id': validator.validate_ec2_id, 'attribute': validator.validate_str(), 'image_location': validator.validate_image_path, 'public_ip': netutils.is_valid_ipv4, 'region_name': validator.validate_str(), 'group_name': validator.validate_str(max_length=255), 'group_description': validator.validate_str(max_length=255), 'size': validator.validate_int(), 'user_data': validator.validate_user_data } def __init__(self, application): super(Validator, self).__init__(application) @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): if validator.validate(req.environ['ec2.request'].args, validator.DEFAULT_VALIDATOR): return self.application else: raise webob.exc.HTTPBadRequest() def exception_to_ec2code(ex): """Helper to extract EC2 error code from exception. For other than EC2 exceptions (those without ec2_code attribute), use exception name. """ if hasattr(ex, 'ec2_code'): code = ex.ec2_code else: code = type(ex).__name__ return code def ec2_error_ex(ex, req, code=None, message=None, unexpected=False): """Return an EC2 error response based on passed exception and log the exception on an appropriate log level: * DEBUG: expected errors * ERROR: unexpected errors All expected errors are treated as client errors and 4xx HTTP status codes are always returned for them. Unexpected 5xx errors may contain sensitive information, suppress their messages for security. """ if not code: code = exception_to_ec2code(ex) status = getattr(ex, 'code', None) if not status: status = 500 if unexpected: log_fun = LOG.error log_msg = _LE("Unexpected %(ex_name)s raised: %(ex_str)s") else: log_fun = LOG.debug log_msg = "%(ex_name)s raised: %(ex_str)s" # NOTE(jruzicka): For compatibility with EC2 API, treat expected # exceptions as client (4xx) errors. The exception error code is 500 # by default and most exceptions inherit this from NovaException even # though they are actually client errors in most cases. if status >= 500: status = 400 context = req.environ['nova.context'] request_id = context.request_id log_msg_args = { 'ex_name': type(ex).__name__, 'ex_str': ex } log_fun(log_msg, log_msg_args, context=context) if ex.args and not message and (not unexpected or status < 500): message = unicode(ex.args[0]) if unexpected: # Log filtered environment for unexpected errors. env = req.environ.copy() for k in env.keys(): if not isinstance(env[k], six.string_types): env.pop(k) log_fun(_LE('Environment: %s'), jsonutils.dumps(env)) if not message: message = _('Unknown error occurred.') return faults.ec2_error_response(request_id, code, message, status=status) class Executor(wsgi.Application): """Execute an EC2 API request. Executes 'ec2.action' upon 'ec2.controller', passing 'nova.context' and 'ec2.action_args' (all variables in WSGI environ.) Returns an XML response, or a 400 upon failure. """ @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): context = req.environ['nova.context'] api_request = req.environ['ec2.request'] try: result = api_request.invoke(context) except exception.InstanceNotFound as ex: ec2_id = ec2utils.id_to_ec2_inst_id(ex.kwargs['instance_id']) message = ex.msg_fmt % {'instance_id': ec2_id} return ec2_error_ex(ex, req, message=message) except exception.VolumeNotFound as ex: ec2_id = ec2utils.id_to_ec2_vol_id(ex.kwargs['volume_id']) message = ex.msg_fmt % {'volume_id': ec2_id} return ec2_error_ex(ex, req, message=message) except exception.SnapshotNotFound as ex: ec2_id = ec2utils.id_to_ec2_snap_id(ex.kwargs['snapshot_id']) message = ex.msg_fmt % {'snapshot_id': ec2_id} return ec2_error_ex(ex, req, message=message) except (exception.CannotDisassociateAutoAssignedFloatingIP, exception.FloatingIpAssociated, exception.FloatingIpNotFound, exception.ImageNotActive, exception.InvalidInstanceIDMalformed, exception.InvalidVolumeIDMalformed, exception.InvalidKeypair, exception.InvalidParameterValue, exception.InvalidPortRange, exception.InvalidVolume, exception.KeyPairExists, exception.KeypairNotFound, exception.MissingParameter, exception.NoFloatingIpInterface, exception.NoMoreFixedIps, exception.Forbidden, exception.QuotaError, exception.SecurityGroupExists, exception.SecurityGroupLimitExceeded, exception.SecurityGroupRuleExists, exception.VolumeUnattached, # Following aren't translated to valid EC2 errors. exception.ImageNotFound, exception.ImageNotFoundEC2, exception.InvalidAttribute, exception.InvalidRequest, exception.NotFound) as ex: return ec2_error_ex(ex, req) except Exception as ex: return ec2_error_ex(ex, req, unexpected=True) else: resp = webob.Response() resp.status = 200 resp.headers['Content-Type'] = 'text/xml' resp.body = str(result) return resp
orbitfp7/nova
nova/api/ec2/__init__.py
Python
apache-2.0
25,652
0.000039
# Copyright 2017 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. # ============================================================================== """Tests for image ops.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import colorsys import math import numpy as np from six.moves import xrange # pylint: disable=redefined-builtin from tensorflow.compiler.tests import xla_test from tensorflow.python.framework import dtypes from tensorflow.python.framework import ops from tensorflow.python.ops import array_ops from tensorflow.python.ops import gen_image_ops from tensorflow.python.ops import image_ops from tensorflow.python.platform import test def GenerateNumpyRandomRGB(shape): # Only generate floating points that are fractions like n / 256, since they # are RGB pixels. Some low-precision floating point types in this test can't # handle arbitrary precision floating points well. return np.random.randint(0, 256, shape) / 256. class RGBToHSVTest(xla_test.XLATestCase): def testBatch(self): # Build an arbitrary RGB image np.random.seed(7) batch_size = 5 shape = (batch_size, 2, 7, 3) for nptype in self.float_types: inp = GenerateNumpyRandomRGB(shape).astype(nptype) # Convert to HSV and back, as a batch and individually with self.cached_session() as sess: batch0 = array_ops.placeholder(nptype, shape=shape) with self.test_scope(): batch1 = image_ops.rgb_to_hsv(batch0) batch2 = image_ops.hsv_to_rgb(batch1) split0 = array_ops.unstack(batch0) with self.test_scope(): split1 = list(map(image_ops.rgb_to_hsv, split0)) split2 = list(map(image_ops.hsv_to_rgb, split1)) join1 = array_ops.stack(split1) join2 = array_ops.stack(split2) batch1, batch2, join1, join2 = sess.run([batch1, batch2, join1, join2], {batch0: inp}) # Verify that processing batch elements together is the same as separate self.assertAllClose(batch1, join1) self.assertAllClose(batch2, join2) self.assertAllCloseAccordingToType( batch2, inp, bfloat16_atol=0.03, half_rtol=0.02) def testRGBToHSVRoundTrip(self): data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] for nptype in self.float_types: rgb_np = np.array(data, dtype=nptype).reshape([2, 2, 3]) / 255. with self.cached_session(): placeholder = array_ops.placeholder(nptype) with self.test_scope(): hsv = image_ops.rgb_to_hsv(placeholder) rgb = image_ops.hsv_to_rgb(hsv) rgb_tf = rgb.eval(feed_dict={placeholder: rgb_np}) self.assertAllCloseAccordingToType(rgb_tf, rgb_np, bfloat16_atol=0.03) def testRGBToHSVNumpy(self): """Tests the RGB to HSV conversion matches a reference implementation.""" for nptype in self.float_types: rgb_flat = GenerateNumpyRandomRGB((64, 3)).astype(nptype) rgb_np = rgb_flat.reshape(4, 4, 4, 3) hsv_np = np.array([ colorsys.rgb_to_hsv( r.astype(np.float64), g.astype(np.float64), b.astype(np.float64)) for r, g, b in rgb_flat ]) hsv_np = hsv_np.reshape(4, 4, 4, 3) with self.cached_session(): placeholder = array_ops.placeholder(nptype) with self.test_scope(): hsv_op = image_ops.rgb_to_hsv(placeholder) hsv_tf = hsv_op.eval(feed_dict={placeholder: rgb_np}) self.assertAllCloseAccordingToType(hsv_tf, hsv_np) class AdjustContrastTest(xla_test.XLATestCase): def _testContrast(self, x_np, y_np, contrast_factor): with self.cached_session(): x = array_ops.placeholder(x_np.dtype, shape=x_np.shape) flt_x = image_ops.convert_image_dtype(x, dtypes.float32) with self.test_scope(): y = image_ops.adjust_contrast(flt_x, contrast_factor) y = image_ops.convert_image_dtype(y, x.dtype, saturate=True) y_tf = y.eval({x: x_np}) self.assertAllClose(y_tf, y_np, 1e-6) def testFloatContrast(self): x_shape = [1, 2, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] x_np = np.array(x_data, dtype=np.float32).reshape(x_shape) / 255. y_data = [ -45.25, -90.75, -92.5, 62.75, 169.25, 333.5, 28.75, -84.75, 349.5, 134.75, 409.25, -116.5 ] y_np = np.array(y_data, dtype=np.float32).reshape(x_shape) / 255. self._testContrast(x_np, y_np, contrast_factor=2.0) def testBatchContrast(self): x_shape = [2, 1, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) y_data = [0, 0, 0, 81, 200, 255, 10, 0, 255, 116, 255, 0] y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape) self._testContrast(x_np, y_np, contrast_factor=2.0) def _adjustContrastNp(self, x_np, contrast_factor): mean = np.mean(x_np, (1, 2), keepdims=True) y_np = mean + contrast_factor * (x_np - mean) return y_np def _adjustContrastTf(self, x_np, contrast_factor): with self.cached_session(): x = array_ops.placeholder(np.float32) with self.test_scope(): y = image_ops.adjust_contrast(x, contrast_factor) y_tf = y.eval({x: x_np}) return y_tf def testRandomContrast(self): x_shapes = [ [1, 2, 2, 3], [2, 1, 2, 3], [1, 2, 2, 3], [2, 5, 5, 3], [2, 1, 1, 3], ] for x_shape in x_shapes: x_np = np.random.rand(*x_shape) * 255. contrast_factor = np.random.rand() * 2.0 + 0.1 y_np = self._adjustContrastNp(x_np, contrast_factor) y_tf = self._adjustContrastTf(x_np, contrast_factor) self.assertAllClose(y_tf, y_np, rtol=1e-5, atol=1e-5) class AdjustHueTest(xla_test.XLATestCase): def testAdjustNegativeHue(self): x_shape = [2, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) delta = -0.25 y_data = [0, 13, 1, 54, 226, 59, 8, 234, 150, 255, 39, 1] y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape) with self.cached_session(): x = array_ops.placeholder(x_np.dtype, shape=x_shape) flt_x = image_ops.convert_image_dtype(x, dtypes.float32) with self.test_scope(): y = gen_image_ops.adjust_hue(flt_x, delta) y = image_ops.convert_image_dtype(y, x.dtype, saturate=True) y_tf = y.eval({x: x_np}) self.assertAllEqual(y_tf, y_np) def testAdjustPositiveHue(self): x_shape = [2, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) delta = 0.25 y_data = [13, 0, 11, 226, 54, 221, 234, 8, 92, 1, 217, 255] y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape) with self.cached_session(): x = array_ops.placeholder(x_np.dtype, shape=x_shape) flt_x = image_ops.convert_image_dtype(x, dtypes.float32) with self.test_scope(): y = gen_image_ops.adjust_hue(flt_x, delta) y = image_ops.convert_image_dtype(y, x.dtype, saturate=True) y_tf = y.eval({x: x_np}) self.assertAllEqual(y_tf, y_np) def testBatchAdjustHue(self): x_shape = [2, 1, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) delta = 0.25 y_data = [13, 0, 11, 226, 54, 221, 234, 8, 92, 1, 217, 255] y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape) with self.cached_session(): x = array_ops.placeholder(x_np.dtype, shape=x_shape) flt_x = image_ops.convert_image_dtype(x, dtypes.float32) with self.test_scope(): y = gen_image_ops.adjust_hue(flt_x, delta) y = image_ops.convert_image_dtype(y, x.dtype, saturate=True) y_tf = y.eval({x: x_np}) self.assertAllEqual(y_tf, y_np) def _adjustHueNp(self, x_np, delta_h): self.assertEqual(x_np.shape[-1], 3) x_v = x_np.reshape([-1, 3]) y_v = np.ndarray(x_v.shape, dtype=x_v.dtype) channel_count = x_v.shape[0] for i in xrange(channel_count): r = x_v[i][0] g = x_v[i][1] b = x_v[i][2] h, s, v = colorsys.rgb_to_hsv(r, g, b) h += delta_h h = math.fmod(h + 10.0, 1.0) r, g, b = colorsys.hsv_to_rgb(h, s, v) y_v[i][0] = r y_v[i][1] = g y_v[i][2] = b return y_v.reshape(x_np.shape) def _adjustHueTf(self, x_np, delta_h): with self.cached_session(): x = array_ops.placeholder(dtypes.float32) with self.test_scope(): y = gen_image_ops.adjust_hue(x, delta_h) y_tf = y.eval({x: x_np}) return y_tf def testAdjustRandomHue(self): x_shapes = [ [2, 2, 3], [4, 2, 3], [2, 4, 3], [2, 5, 3], [1000, 1, 3], ] test_styles = [ "all_random", "rg_same", "rb_same", "gb_same", "rgb_same", ] for x_shape in x_shapes: for test_style in test_styles: x_np = np.random.rand(*x_shape) * 255. delta_h = np.random.rand() * 2.0 - 1.0 if test_style == "all_random": pass elif test_style == "rg_same": x_np[..., 1] = x_np[..., 0] elif test_style == "rb_same": x_np[..., 2] = x_np[..., 0] elif test_style == "gb_same": x_np[..., 2] = x_np[..., 1] elif test_style == "rgb_same": x_np[..., 1] = x_np[..., 0] x_np[..., 2] = x_np[..., 0] else: raise AssertionError("Invalid test style: %s" % (test_style)) y_np = self._adjustHueNp(x_np, delta_h) y_tf = self._adjustHueTf(x_np, delta_h) self.assertAllClose(y_tf, y_np, rtol=2e-5, atol=1e-4) def testInvalidShapes(self): fused = False if not fused: # The tests are known to pass with the fused adjust_hue. We will enable # them when the fused implementation is the default. return x_np = np.random.rand(2, 3) * 255. delta_h = np.random.rand() * 2.0 - 1.0 fused = False with self.assertRaisesRegexp(ValueError, "Shape must be at least rank 3"): self._adjustHueTf(x_np, delta_h) x_np = np.random.rand(4, 2, 4) * 255. delta_h = np.random.rand() * 2.0 - 1.0 with self.assertRaisesOpError("input must have 3 channels"): self._adjustHueTf(x_np, delta_h) class AdjustSaturationTest(xla_test.XLATestCase): def _adjust_saturation(self, image, saturation_factor): image = ops.convert_to_tensor(image, name="image") orig_dtype = image.dtype flt_image = image_ops.convert_image_dtype(image, dtypes.float32) with self.test_scope(): saturation_adjusted_image = gen_image_ops.adjust_saturation( flt_image, saturation_factor) return image_ops.convert_image_dtype(saturation_adjusted_image, orig_dtype) def testHalfSaturation(self): x_shape = [2, 2, 3] x_rgb_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] x_np = np.array(x_rgb_data, dtype=np.uint8).reshape(x_shape) saturation_factor = 0.5 y_rgb_data = [6, 9, 13, 140, 180, 226, 135, 121, 234, 172, 255, 128] y_np = np.array(y_rgb_data, dtype=np.uint8).reshape(x_shape) with self.cached_session(): x = array_ops.placeholder(x_np.dtype, shape=x_shape) y = self._adjust_saturation(x, saturation_factor) y_tf = y.eval({x: x_np}) self.assertAllEqual(y_tf, y_np) def testTwiceSaturation(self): x_shape = [2, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) saturation_factor = 2.0 y_data = [0, 5, 13, 0, 106, 226, 30, 0, 234, 89, 255, 0] y_np = np.array(y_data, dtype=np.uint8).reshape(x_shape) with self.cached_session(): x = array_ops.placeholder(x_np.dtype, shape=x_shape) y = self._adjust_saturation(x, saturation_factor) y_tf = y.eval({x: x_np}) self.assertAllEqual(y_tf, y_np) def _adjustSaturationNp(self, x_np, scale): self.assertEqual(x_np.shape[-1], 3) x_v = x_np.reshape([-1, 3]) y_v = np.ndarray(x_v.shape, dtype=x_v.dtype) channel_count = x_v.shape[0] for i in xrange(channel_count): r = x_v[i][0] g = x_v[i][1] b = x_v[i][2] h, s, v = colorsys.rgb_to_hsv(r, g, b) s *= scale s = min(1.0, max(0.0, s)) r, g, b = colorsys.hsv_to_rgb(h, s, v) y_v[i][0] = r y_v[i][1] = g y_v[i][2] = b return y_v.reshape(x_np.shape) def testAdjustRandomSaturation(self): x_shapes = [ [2, 2, 3], [4, 2, 3], [2, 4, 3], [2, 5, 3], [1000, 1, 3], ] test_styles = [ "all_random", "rg_same", "rb_same", "gb_same", "rgb_same", ] with self.cached_session(): for x_shape in x_shapes: for test_style in test_styles: x_np = np.random.rand(*x_shape) * 255. scale = np.random.rand() if test_style == "all_random": pass elif test_style == "rg_same": x_np[..., 1] = x_np[..., 0] elif test_style == "rb_same": x_np[..., 2] = x_np[..., 0] elif test_style == "gb_same": x_np[..., 2] = x_np[..., 1] elif test_style == "rgb_same": x_np[..., 1] = x_np[..., 0] x_np[..., 2] = x_np[..., 0] else: raise AssertionError("Invalid test style: %s" % (test_style)) y_baseline = self._adjustSaturationNp(x_np, scale) x = array_ops.placeholder(dtypes.float32, shape=x_shape) with self.test_scope(): y_fused = self._adjust_saturation(x, scale).eval(feed_dict={x: x_np}) self.assertAllClose(y_fused, y_baseline, rtol=2e-5, atol=1e-5) class ResizeNearestNeighborTest(xla_test.XLATestCase): # TODO(ilch): Wrap each test with `for dtype in self.float_types:` # Some work to understand how that should be done was presented here: # cl/227850213 def _assertForwardOpMatchesExpected(self, image_np, target_shape, expected=None, large_tolerance=False, align_corners=True): if expected is None: self.fail("expected must be specified") with self.cached_session() as sess, self.test_scope(): image = array_ops.placeholder(image_np.dtype) resized = gen_image_ops.resize_nearest_neighbor( image, target_shape, align_corners=align_corners) out = sess.run(resized, {image: image_np[np.newaxis, :, :, np.newaxis]}) if large_tolerance: self.assertAllClose( expected[np.newaxis, :, :, np.newaxis], out, rtol=0.03, atol=0.1) else: self.assertAllClose(expected[np.newaxis, :, :, np.newaxis], out) def testAlignCorners2x2To1x1(self): self._assertForwardOpMatchesExpected( np.array([[1, 2], [3, 4]], dtype=np.float32), [1, 1], expected=np.array([[1]], dtype=np.float32)) def testAlignCorners1x1To2x2(self): self._assertForwardOpMatchesExpected( np.array([[1]], dtype=np.float32), [2, 2], expected=np.array([[1, 1], [1, 1]], dtype=np.float32)) def testAlignCorners1x1To3x3(self): self._assertForwardOpMatchesExpected( np.array([[1]], dtype=np.float32), [3, 3], expected=np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]], dtype=np.float32)) def testAlignCorners2x2To3x3(self): self._assertForwardOpMatchesExpected( np.array([[1, 2], [3, 4]], dtype=np.float32), [3, 3], expected=np.array([[1, 2, 2], [3, 4, 4], [3, 4, 4]], dtype=np.float32)) def testAlignCorners2x2To4x4(self): self._assertForwardOpMatchesExpected( np.array([[1, 2], [3, 4]], dtype=np.float32), [4, 4], expected=np.array( [[1, 1, 2, 2], [1, 1, 2, 2], [3, 3, 4, 4], [3, 3, 4, 4]], dtype=np.float32)) def testAlignCorners3x3To2x2(self): self._assertForwardOpMatchesExpected( np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32), [2, 2], expected=np.array([[1, 3], [7, 9]], dtype=np.float32)) def testAlignCorners4x4To3x3(self): self._assertForwardOpMatchesExpected( np.array( [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], dtype=np.float32), [3, 3], expected=np.array([[1, 3, 4], [9, 11, 12], [13, 15, 16]], dtype=np.float32)) def testAlignCorners3x3To4x4(self): self._assertForwardOpMatchesExpected( np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32), [4, 4], expected=np.array( [[1, 2, 2, 3], [4, 5, 5, 6], [4, 5, 5, 6], [7, 8, 8, 9]], dtype=np.float32)) def testAlignCorners3x3To6x6(self): self._assertForwardOpMatchesExpected( np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32), [6, 6], expected=np.array( [[1, 1, 2, 2, 3, 3], [1, 1, 2, 2, 3, 3], [4, 4, 5, 5, 6, 6], [4, 4, 5, 5, 6, 6], [7, 7, 8, 8, 9, 9], [7, 7, 8, 8, 9, 9]], dtype=np.float32)) def testAlignCorners3x3To9x9(self): # The expected matrix might look uneven in terms of how many of each number # there is, but this is an artifact of doing the dilation and convolution # iteratively. The behavior is less esoteric in the 3x3To12x12 case below. self._assertForwardOpMatchesExpected( np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32), [9, 9], expected=np.array( [[1, 2, 2, 2, 2, 3, 3, 3, 3], [4, 5, 5, 5, 5, 6, 6, 6, 6], [4, 5, 5, 5, 5, 6, 6, 6, 6], [4, 5, 5, 5, 5, 6, 6, 6, 6], [4, 5, 5, 5, 5, 6, 6, 6, 6], [7, 8, 8, 8, 8, 9, 9, 9, 9], [7, 8, 8, 8, 8, 9, 9, 9, 9], [7, 8, 8, 8, 8, 9, 9, 9, 9], [7, 8, 8, 8, 8, 9, 9, 9, 9]], dtype=np.float32)) def testAlignCorners3x3To12x12(self): self._assertForwardOpMatchesExpected( np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32), [12, 12], expected=np.array([[1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3], [1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3], [1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3], [4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6], [4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6], [4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6], [4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6], [4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6], [4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6], [7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9], [7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9], [7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9]], dtype=np.float32)) class ResizeBilinearTest(xla_test.XLATestCase): def _assertForwardOpMatchesExpected(self, image_np, target_shape, expected=None, large_tolerance=False, align_corners=True): if expected is None: self.fail("expected must be specified") with self.cached_session() as sess, self.test_scope(): image = array_ops.placeholder(image_np.dtype) resized = gen_image_ops.resize_bilinear( image, target_shape, align_corners=align_corners) out = sess.run(resized, {image: image_np[np.newaxis, :, :, np.newaxis]}) if large_tolerance: self.assertAllClose( expected[np.newaxis, :, :, np.newaxis], out, rtol=0.03, atol=0.1) else: self.assertAllClose(expected[np.newaxis, :, :, np.newaxis], out) def _assertBackwardOpMatchesExpected(self, grads_np, input_shape=None, dtype=None, expected=None): if input_shape is None: self.fail("input_shape must be specified") if expected is None: self.fail("expected must be specified") with self.cached_session() as sess, self.test_scope(): dtype = dtype or np.float32 grads = array_ops.placeholder(np.float32) resized = gen_image_ops.resize_bilinear_grad( grads, np.zeros([1, input_shape[0], input_shape[1], 1], dtype=dtype), align_corners=True) out = sess.run(resized, {grads: grads_np[np.newaxis, :, :, np.newaxis]}) self.assertAllCloseAccordingToType(expected[np.newaxis, :, :, np.newaxis], out) def testAlignCorners1x2To3x3(self): for dtype in self.float_types: self._assertForwardOpMatchesExpected( np.array([[1, 2]], dtype=dtype), [3, 3], expected=np.array([[1, 1.5, 2], [1, 1.5, 2], [1, 1.5, 2]], dtype=np.float32)) def testAlignCorners1x2To3x3Grad(self): for dtype in self.float_types: self._assertBackwardOpMatchesExpected( np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32), input_shape=[1, 2], dtype=dtype, expected=np.array([[9, 12]], dtype=np.float32)) def testAlignCorners2x2To1x1(self): for dtype in self.float_types: self._assertForwardOpMatchesExpected( np.array([[1, 2], [3, 4]], dtype=dtype), [1, 1], expected=np.array([[1]], dtype=np.float32)) def testAlignCorners2x2To1x1Grad(self): for dtype in self.float_types: self._assertBackwardOpMatchesExpected( np.array([[7]], dtype=np.float32), input_shape=[2, 2], dtype=dtype, expected=np.array([[7, 0], [0, 0]], dtype=np.float32)) def testAlignCorners2x2To3x3(self): for dtype in self.float_types: self._assertForwardOpMatchesExpected( np.array([[1, 2], [3, 4]], dtype=dtype), [3, 3], expected=np.array([[1, 1.5, 2], [2, 2.5, 3], [3, 3.5, 4]], dtype=np.float32)) def testAlignCorners2x2To3x3Grad(self): self._assertBackwardOpMatchesExpected( np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32), input_shape=[2, 2], expected=np.array([[5.25, 8.25], [14.25, 17.25]], dtype=np.float32)) def testAlignCorners3x3To2x2(self): for dtype in self.float_types: self._assertForwardOpMatchesExpected( np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=dtype), [2, 2], expected=np.array([[1, 3], [7, 9]], dtype=np.float32)) def testAlignCorners3x3To2x2Grad(self): for dtype in self.float_types: self._assertBackwardOpMatchesExpected( np.array([[7, 13], [22, 4]], dtype=np.float32), input_shape=[3, 3], dtype=dtype, expected=np.array([[7, 0, 13], [0, 0, 0], [22, 0, 4]], dtype=np.float32)) def testAlignCorners4x4To3x3(self): for dtype in self.float_types: self._assertForwardOpMatchesExpected( np.array( [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], dtype=dtype), [3, 3], expected=np.array([[1, 2.5, 4], [7, 8.5, 10], [13, 14.5, 16]], dtype=np.float32)) def testAlignCorners4x4To3x3Grad(self): for dtype in self.float_types: self._assertBackwardOpMatchesExpected( np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32), input_shape=[4, 4], dtype=dtype, expected=np.array([[1, 1, 1, 3], [2, 1.25, 1.25, 3], [2, 1.25, 1.25, 3], [7, 4, 4, 9]], dtype=np.float32)) def testAlignCorners3x3To9x9(self): for dtype in self.float_types: self._assertForwardOpMatchesExpected( np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=dtype), [9, 9], expected=np.array( [[1.0, 1.25, 1.50, 1.75, 2.00, 2.25, 2.50, 2.75, 3.00], [1.75, 2.00, 2.25, 2.50, 2.75, 3.00, 3.25, 3.50, 3.75], [2.50, 2.75, 3.00, 3.25, 3.50, 3.75, 4.00, 4.25, 4.50], [3.25, 3.50, 3.75, 4.00, 4.25, 4.50, 4.75, 5.00, 5.25], [4.00, 4.25, 4.50, 4.75, 5.00, 5.25, 5.50, 5.75, 6.00], [4.75, 5.00, 5.25, 5.50, 5.75, 6.00, 6.25, 6.50, 6.75], [5.50, 5.75, 6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50], [6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25], [7.00, 7.25, 7.50, 7.75, 8.00, 8.25, 8.50, 8.75, 9.00]], dtype=np.float32)) def testAlignCorners3x3To9x9Grad(self): for dtype in self.float_types: self._assertBackwardOpMatchesExpected( np.array([[1.00, 1.25, 1.50, 1.75, 2.00, 2.25, 2.50, 2.75, 3.00], [1.75, 2.00, 2.25, 2.50, 2.75, 3.00, 3.25, 3.50, 3.75], [2.50, 2.75, 3.00, 3.25, 3.50, 3.75, 4.00, 4.25, 4.50], [3.25, 3.50, 3.75, 4.00, 4.25, 4.50, 4.75, 5.00, 5.25], [4.00, 4.25, 4.50, 4.75, 5.00, 5.25, 5.50, 5.75, 6.00], [4.75, 5.00, 5.25, 5.50, 5.75, 6.00, 6.25, 6.50, 6.75], [5.50, 5.75, 6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50], [6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25], [7.00, 7.25, 7.50, 7.75, 8.00, 8.25, 8.50, 8.75, 9.00]], dtype=np.float32), input_shape=[3, 3], dtype=dtype, expected=np.array( [[12.5, 27.5, 21.875], [42.5, 80.0, 57.5], [40.625, 72.5, 50]], dtype=np.float32)) def testAlignCorners4x4To8x8(self): self._assertForwardOpMatchesExpected( (np.array([[0, 1, 2, 3]], dtype=np.float32) + np.array( [[0], [1], [2], [3]], dtype=np.float32)) * 7.0, [8, 8], expected=3 * (np.array([[0, 1, 2, 3, 4, 5, 6, 7]], dtype=np.float32) + np.array( [[0], [1], [2], [3], [4], [5], [6], [7]], dtype=np.float32)), large_tolerance=True) def testAlignCorners8x8To16x16(self): self._assertForwardOpMatchesExpected( (np.array([[0, 1, 2, 3, 4, 5, 6, 7]], dtype=np.float32) + np.array( [[0], [1], [2], [3], [4], [5], [6], [7]], dtype=np.float32)) * 15.0, [16, 16], expected=7 * (np.array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]], dtype=np.float32) + np.array([[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15]], dtype=np.float32)), large_tolerance=True) def testNonAlignCorners3x2To6x4(self): input_data = [[64, 32], [32, 64], [50, 100]] expected_data = [[64.0, 48.0, 32.0, 32.0], [48.0, 48.0, 48.0, 48.0], [32.0, 48.0, 64.0, 64.0], [41.0, 61.5, 82.0, 82.0], [50.0, 75.0, 100.0, 100.0], [50.0, 75.0, 100.0, 100.0]] for dtype in self.float_types: self._assertForwardOpMatchesExpected( np.array(input_data, dtype=dtype), [6, 4], expected=np.array(expected_data, dtype=np.float32), align_corners=False) def testNonAlignCorners6x4To3x2(self): input_data = [[127, 127, 64, 64], [127, 127, 64, 64], [64, 64, 127, 127], [64, 64, 127, 127], [50, 50, 100, 100], [50, 50, 100, 100]] expected_data = [[127, 64], [64, 127], [50, 100]] for dtype in self.float_types: self._assertForwardOpMatchesExpected( np.array(input_data, dtype=dtype), [3, 2], expected=np.array(expected_data, dtype=dtype), align_corners=False) def testNonAlignCorners3x2To6x4Batch2(self): input_data = [[[64, 32], [32, 64], [50, 100]], [[32, 16], [16, 32], [25, 50]]] expected_data = [[[64.0, 48.0, 32.0, 32.0], [48.0, 48.0, 48.0, 48.0], [32.0, 48.0, 64.0, 64.0], [41.0, 61.5, 82.0, 82.0], [50.0, 75.0, 100.0, 100.0], [50.0, 75.0, 100.0, 100.0]], [[32.0, 24.0, 16.0, 16.0], [24.0, 24.0, 24.0, 24.0], [16.0, 24.0, 32.0, 32.0], [20.5, 30.75, 41.0, 41.0], [25.0, 37.5, 50.0, 50.0], [25.0, 37.5, 50.0, 50.0]]] for dtype in self.float_types: input_image = np.array(input_data, dtype=dtype) expected = np.array(expected_data, dtype=dtype) with self.cached_session() as sess, self.test_scope(): image = array_ops.placeholder(input_image.dtype) resized = gen_image_ops.resize_bilinear( image, [6, 4], align_corners=False) out = sess.run(resized, {image: input_image[:, :, :, np.newaxis]}) self.assertAllClose(expected[:, :, :, np.newaxis], out) class NonMaxSuppressionTest(xla_test.XLATestCase): def testNMS128From1024(self): num_boxes = 1024 boxes_np = np.random.normal(50, 10, (num_boxes, 4)).astype("f4") scores_np = np.random.normal(0.5, 0.1, (num_boxes,)).astype("f4") max_output_size = 128 iou_threshold_np = np.array(0.5, dtype=np.float32) score_threshold_np = np.array(0.0, dtype=np.float32) with self.cached_session() as sess: boxes = array_ops.placeholder(boxes_np.dtype, shape=boxes_np.shape) scores = array_ops.placeholder(scores_np.dtype, shape=scores_np.shape) iou_threshold = array_ops.placeholder(iou_threshold_np.dtype, iou_threshold_np.shape) score_threshold = array_ops.placeholder(score_threshold_np.dtype, score_threshold_np.shape) with self.test_scope(): selected_indices = image_ops.non_max_suppression_padded( boxes=boxes, scores=scores, max_output_size=max_output_size, iou_threshold=iou_threshold, score_threshold=score_threshold, pad_to_max_output_size=True) inputs_feed = { boxes: boxes_np, scores: scores_np, score_threshold: score_threshold_np, iou_threshold: iou_threshold_np } (indices_tf, _) = sess.run(selected_indices, feed_dict=inputs_feed) self.assertEqual(indices_tf.size, max_output_size) def testNMS3From6Boxes(self): # Three boxes are selected based on IOU. boxes_data = [[0, 0, 1, 1], [0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9], [0, 10, 1, 11], [0, 10.1, 1, 11.1], [0, 100, 1, 101]] boxes_np = np.array(boxes_data, dtype=np.float32) scores_data = [0.9, 0.75, 0.6, 0.95, 0.5, 0.3] scores_np = np.array(scores_data, dtype=np.float32) max_output_size = 3 iou_threshold_np = np.array(0.5, dtype=np.float32) score_threshold_np = np.array(0.0, dtype=np.float32) with self.cached_session() as sess: boxes = array_ops.placeholder(boxes_np.dtype, shape=boxes_np.shape) scores = array_ops.placeholder(scores_np.dtype, shape=scores_np.shape) iou_threshold = array_ops.placeholder(iou_threshold_np.dtype, iou_threshold_np.shape) score_threshold = array_ops.placeholder(score_threshold_np.dtype, score_threshold_np.shape) with self.test_scope(): selected_indices = image_ops.non_max_suppression_padded( boxes=boxes, scores=scores, max_output_size=max_output_size, iou_threshold=iou_threshold, score_threshold=score_threshold, pad_to_max_output_size=True) inputs_feed = { boxes: boxes_np, scores: scores_np, score_threshold: score_threshold_np, iou_threshold: iou_threshold_np } (indices_tf, num_valid) = sess.run( selected_indices, feed_dict=inputs_feed) self.assertEqual(indices_tf.size, max_output_size) self.assertEqual(num_valid, 3) self.assertAllClose(indices_tf[:num_valid], [3, 0, 5]) def testNMS3Then2WithScoreThresh(self): # Three boxes are selected based on IOU. # One is filtered out by score threshold. boxes_data = [[0, 0, 1, 1], [0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9], [0, 10, 1, 11], [0, 10.1, 1, 11.1], [0, 100, 1, 101]] boxes_np = np.array(boxes_data, dtype=np.float32) scores_data = [0.9, 0.75, 0.6, 0.95, 0.5, 0.3] scores_np = np.array(scores_data, dtype=np.float32) max_output_size = 3 iou_threshold_np = np.array(0.5, dtype=np.float32) score_threshold_np = np.array(0.4, dtype=np.float32) with self.cached_session() as sess: boxes = array_ops.placeholder(boxes_np.dtype, shape=boxes_np.shape) scores = array_ops.placeholder(scores_np.dtype, shape=scores_np.shape) iou_threshold = array_ops.placeholder(iou_threshold_np.dtype, iou_threshold_np.shape) score_threshold = array_ops.placeholder(score_threshold_np.dtype, score_threshold_np.shape) with self.test_scope(): selected_indices = image_ops.non_max_suppression_padded( boxes=boxes, scores=scores, max_output_size=max_output_size, iou_threshold=iou_threshold, score_threshold=score_threshold, pad_to_max_output_size=True) inputs_feed = { boxes: boxes_np, scores: scores_np, iou_threshold: iou_threshold_np, score_threshold: score_threshold_np } (indices_tf, num_valid) = sess.run( selected_indices, feed_dict=inputs_feed) self.assertEqual(indices_tf.size, max_output_size) self.assertEqual(num_valid, 2) self.assertAllClose(indices_tf[:num_valid], [3, 0]) def testNMS3Then1WithScoreMaxThresh(self): # Three boxes are selected based on IOU. # One is filtered out by score threshold. # One is filtered out by max_output_size. boxes_data = [[0, 0, 1, 1], [0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9], [0, 10, 1, 11], [0, 10.1, 1, 11.1], [0, 100, 1, 101]] boxes_np = np.array(boxes_data, dtype=np.float32) scores_data = [0.9, 0.75, 0.6, 0.95, 0.5, 0.3] scores_np = np.array(scores_data, dtype=np.float32) max_output_size = 1 iou_threshold_np = np.array(0.5, dtype=np.float32) score_threshold_np = np.array(0.4, dtype=np.float32) with self.cached_session() as sess: boxes = array_ops.placeholder(boxes_np.dtype, shape=boxes_np.shape) scores = array_ops.placeholder(scores_np.dtype, shape=scores_np.shape) iou_threshold = array_ops.placeholder(iou_threshold_np.dtype, iou_threshold_np.shape) score_threshold = array_ops.placeholder(score_threshold_np.dtype, score_threshold_np.shape) with self.test_scope(): selected_indices = image_ops.non_max_suppression_padded( boxes=boxes, scores=scores, max_output_size=max_output_size, iou_threshold=iou_threshold, score_threshold=score_threshold, pad_to_max_output_size=True) inputs_feed = { boxes: boxes_np, scores: scores_np, iou_threshold: iou_threshold_np, score_threshold: score_threshold_np } (indices_tf, num_valid) = sess.run( selected_indices, feed_dict=inputs_feed) self.assertEqual(indices_tf.size, max_output_size) self.assertEqual(num_valid, 1) self.assertAllClose(indices_tf[:num_valid], [3]) def testSelectFromContinuousOverLap(self): # Tests that a suppressed box does not itself suppress other boxes. boxes_data = [[0, 0, 1, 1], [0, 0.2, 1, 1.2], [0, 0.4, 1, 1.4], [0, 0.6, 1, 1.6], [0, 0.8, 1, 1.8], [0, 2, 1, 3]] boxes_np = np.array(boxes_data, dtype=np.float32) scores_data = [0.9, 0.75, 0.6, 0.5, 0.4, 0.3] scores_np = np.array(scores_data, dtype=np.float32) max_output_size = 3 iou_threshold_np = np.array(0.5, dtype=np.float32) score_threshold_np = np.array(0.1, dtype=np.float32) with self.cached_session() as sess: boxes = array_ops.placeholder(boxes_np.dtype, shape=boxes_np.shape) scores = array_ops.placeholder(scores_np.dtype, shape=scores_np.shape) iou_threshold = array_ops.placeholder(iou_threshold_np.dtype, iou_threshold_np.shape) score_threshold = array_ops.placeholder(score_threshold_np.dtype, score_threshold_np.shape) with self.test_scope(): selected_indices = image_ops.non_max_suppression_padded( boxes=boxes, scores=scores, max_output_size=max_output_size, iou_threshold=iou_threshold, score_threshold=score_threshold, pad_to_max_output_size=True) inputs_feed = { boxes: boxes_np, scores: scores_np, iou_threshold: iou_threshold_np, score_threshold: score_threshold_np } (indices_tf, num_valid) = sess.run( selected_indices, feed_dict=inputs_feed) self.assertEqual(indices_tf.size, max_output_size) self.assertEqual(num_valid, 3) self.assertAllClose(indices_tf[:num_valid], [0, 2, 4]) if __name__ == "__main__": test.main()
apark263/tensorflow
tensorflow/compiler/tests/image_ops_test.py
Python
apache-2.0
38,279
0.006923
# -*- coding: 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 field 'ArtistMedia.is_default_image' db.delete_column(u'artist_artistmedia', 'is_default_image') # Deleting field 'ArtistMedia.name' db.delete_column(u'artist_artistmedia', 'name') # Deleting field 'ArtistMedia.video_link' db.delete_column(u'artist_artistmedia', 'video_link') # Deleting field 'ArtistMedia.full_res_image' db.delete_column(u'artist_artistmedia', 'full_res_image') # Deleting field 'ArtistMedia.image' db.delete_column(u'artist_artistmedia', 'image') # Deleting field 'ArtistMedia.id' db.delete_column(u'artist_artistmedia', u'id') # Deleting field 'ArtistMedia.thumbnail' db.delete_column(u'artist_artistmedia', 'thumbnail') # Adding field 'ArtistMedia.frontmedia_ptr' db.add_column(u'artist_artistmedia', u'frontmedia_ptr', self.gf('django.db.models.fields.related.OneToOneField')(default=-1, to=orm['front_material.FrontMedia'], unique=True, primary_key=True), keep_default=False) def backwards(self, orm): # Adding field 'ArtistMedia.is_default_image' db.add_column(u'artist_artistmedia', 'is_default_image', self.gf('django.db.models.fields.BooleanField')(default=False), keep_default=False) # Adding field 'ArtistMedia.name' db.add_column(u'artist_artistmedia', 'name', self.gf('django.db.models.fields.CharField')(default='', max_length=100), keep_default=False) # Adding field 'ArtistMedia.video_link' db.add_column(u'artist_artistmedia', 'video_link', self.gf('django.db.models.fields.CharField')(default='', max_length=255, null=True, blank=True), keep_default=False) # Adding field 'ArtistMedia.full_res_image' db.add_column(u'artist_artistmedia', 'full_res_image', self.gf('django.db.models.fields.files.ImageField')(default='', max_length=100, null=True, blank=True), keep_default=False) # Adding field 'ArtistMedia.image' db.add_column(u'artist_artistmedia', 'image', self.gf('django.db.models.fields.files.ImageField')(default='', max_length=100, null=True, blank=True), keep_default=False) # Adding field 'ArtistMedia.id' db.add_column(u'artist_artistmedia', u'id', self.gf('django.db.models.fields.AutoField')(default=1, primary_key=True), keep_default=False) # Adding field 'ArtistMedia.thumbnail' db.add_column(u'artist_artistmedia', 'thumbnail', self.gf('django.db.models.fields.files.ImageField')(default='', max_length=100, null=True, blank=True), keep_default=False) # Deleting field 'ArtistMedia.frontmedia_ptr' db.delete_column(u'artist_artistmedia', u'frontmedia_ptr_id') models = { u'artist.artist': { 'Meta': {'object_name': 'Artist'}, 'artist_statement': ('django.db.models.fields.TextField', [], {'default': "''", 'null': 'True', 'blank': 'True'}), 'bio': ('django.db.models.fields.TextField', [], {'default': "''", 'null': 'True', 'blank': 'True'}), u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '100'}), 'slug': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '100', 'null': 'True', 'blank': 'True'}), 'user': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"}) }, u'artist.artistmedia': { 'Meta': {'object_name': 'ArtistMedia', '_ormbases': [u'front_material.FrontMedia']}, 'artist': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['artist.Artist']"}), u'frontmedia_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['front_material.FrontMedia']", 'unique': 'True', 'primary_key': 'True'}) }, u'auth.group': { 'Meta': {'object_name': 'Group'}, u'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': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}) }, u'auth.permission': { 'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'}, 'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}), 'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}), u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}) }, u'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': u"orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}), u'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': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}), 'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'}) }, u'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'}), u'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'}) }, u'front_material.frontmedia': { 'Meta': {'object_name': 'FrontMedia'}, 'full_res_image': ('django.db.models.fields.files.ImageField', [], {'default': "''", 'max_length': '100', 'null': 'True', 'blank': 'True'}), u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'image': ('django.db.models.fields.files.ImageField', [], {'default': "''", 'max_length': '100', 'null': 'True', 'blank': 'True'}), 'is_default_image': ('django.db.models.fields.BooleanField', [], {'default': 'False'}), 'name': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '100'}), 'thumbnail': ('django.db.models.fields.files.ImageField', [], {'default': "''", 'max_length': '100', 'null': 'True', 'blank': 'True'}), 'video_link': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '255', 'null': 'True', 'blank': 'True'}) } } complete_apps = ['artist']
hcwiley/the-front
the_front/the_front/artist/migrations/0005_auto__del_field_artistmedia_is_default_image__del_field_artistmedia_na.py
Python
gpl-2.0
8,560
0.006075
import unittest import os import numpy from rmgpy.tools.canteraModel import findIgnitionDelay, CanteraCondition, Cantera from rmgpy.quantity import Quantity import rmgpy class CanteraTest(unittest.TestCase): def testIgnitionDelay(self): """ Test that findIgnitionDelay() works. """ t = numpy.arange(0,5,0.5) P = numpy.array([0,0.33,0.5,0.9,2,4,15,16,16.1,16.2]) OH = numpy.array([0,0.33,0.5,0.9,2,4,15,16,7,2]) CO = OH*0.9 t_ign = findIgnitionDelay(t,P) self.assertEqual(t_ign,2.75) t_ign = findIgnitionDelay(t,OH,'maxHalfConcentration') self.assertEqual(t_ign,3) t_ign = findIgnitionDelay(t,[OH,CO], 'maxSpeciesConcentrations') self.assertEqual(t_ign,3.5) def testRepr(self): """ Test that the repr function for a CanteraCondition object can reconstitute the same object """ reactorType='IdealGasReactor' molFrac={'CC': 0.05, '[Ar]': 0.95} P=(3,'atm') T=(1500,'K') terminationTime=(5e-5,'s') condition = CanteraCondition(reactorType, terminationTime, molFrac, T0=T, P0=P) reprCondition=eval(condition.__repr__()) self.assertEqual(reprCondition.T0.value_si,Quantity(T).value_si) self.assertEqual(reprCondition.P0.value_si,Quantity(P).value_si) self.assertEqual(reprCondition.V0,None) self.assertEqual(reprCondition.molFrac,molFrac) class RMGToCanteraTest(unittest.TestCase): """ Contains unit tests for the conversion of RMG species and reaction objects to Cantera objects. """ def setUp(self): """ A function run before each unit test in this class. """ from rmgpy.chemkin import loadChemkinFile folder = os.path.join(os.path.dirname(rmgpy.__file__),'tools/data/various_kinetics') chemkinPath = os.path.join(folder, 'chem_annotated.inp') dictionaryPath = os.path.join(folder, 'species_dictionary.txt') transportPath = os.path.join(folder, 'tran.dat') species, reactions = loadChemkinFile(chemkinPath, dictionaryPath,transportPath) self.rmg_ctSpecies = [spec.toCantera() for spec in species] self.rmg_ctReactions = [] for rxn in reactions: convertedReactions = rxn.toCantera(species) if isinstance(convertedReactions,list): self.rmg_ctReactions.extend(convertedReactions) else: self.rmg_ctReactions.append(convertedReactions) job = Cantera() job.loadChemkinModel(chemkinPath, transportFile=transportPath,quiet=True) self.ctSpecies = job.model.species() self.ctReactions = job.model.reactions() def testSpeciesConversion(self): """ Test that species objects convert properly """ from rmgpy.tools.canteraModel import checkEquivalentCanteraSpecies for i in range(len(self.ctSpecies)): self.assertTrue(checkEquivalentCanteraSpecies(self.ctSpecies[i],self.rmg_ctSpecies[i])) def testReactionConversion(self): """ Test that species objects convert properly """ from rmgpy.tools.canteraModel import checkEquivalentCanteraReaction for i in range(len(self.ctReactions)): self.assertTrue(checkEquivalentCanteraReaction(self.ctReactions[i],self.rmg_ctReactions[i]))
chatelak/RMG-Py
rmgpy/tools/canteraTest.py
Python
mit
3,597
0.020573
from django.db import models from django.utils.encoding import python_2_unicode_compatible from elasticsearch import Elasticsearch @python_2_unicode_compatible class ElasticCluster(models.Model): class Meta: db_table = 'cluster_elastic_cluster' # cluster name name = models.CharField(max_length=128) host = models.CharField(max_length=256) port = models.IntegerField() def __str__(self): return '{name} {host}:{port}'.format(name=self.name, host=self.host, port=self.port) def address(self): return '{host}:{port}'.format(host=self.host, port=self.port) def client(self, timeout=30): return Elasticsearch(self.address(), timeout=timeout) def info(self): info = self.client().info() ret = { 'cluster_name': info['cluster_name'], 'elasticsearch_version': info['version']['number'], 'lucene_version': info['version']['lucene_version'], } return ret def health(self): es = self.client() return es.cluster.health() def pending_tasks(self): es = self.client() tasks = es.cluster.pending_tasks() return len(tasks), tasks
InterestingLab/elasticmanager
cluster/models.py
Python
mit
1,207
0.000829
#!/usr/bin/env python import sys from twisted.protocols import amp from twisted.internet import reactor from twisted.internet.protocol import ServerFactory from twisted.python import usage from twisted.cred.checkers import FilePasswordDB from twisted.cred.portal import Portal from twisted.cred import credentials from Realm import Realm, IAvatar import commands default_port = 65432 class Options(usage.Options): optParameters = [ ["port", "p", default_port, "server port"], ] class ChatProtocol(amp.AMP): @commands.Login.responder def login(self, username, password): """Attempt to login.""" if username in self.factory.username_to_protocol: raise commands.LoginError("User '%s' already logged in" % username) creds = credentials.UsernamePassword(username, password) deferred = self.factory.portal.login(creds, None, IAvatar) deferred.addCallback(self.login_succeeded) deferred.addErrback(self.login_failed) return deferred def login_succeeded(self, (avatar_interface, avatar, logout)): name = avatar.name self.username = name self.factory.username_to_protocol[name] = self # Tell all users about this user for protocol in self.factory.username_to_protocol.itervalues(): protocol.callRemote(commands.AddUser, user=name) # Tell this user about all other users for username in self.factory.username_to_protocol: if username != name: self.callRemote(commands.AddUser, user=username) return {} def login_failed(self, failure): raise commands.LoginError("Incorrect username or password") @commands.SendToUsers.responder def send_to_users(self, message, usernames): for username in usernames: protocol = self.factory.username_to_protocol.get(username) if protocol: protocol.callRemote(commands.Send, message=message, sender=self.username) # Also show it to the sender if self.username not in usernames: self.callRemote(commands.Send, message=message, sender=self.username) return {} @commands.SendToAll.responder def send_to_all(self, message): for protocol in self.factory.username_to_protocol.itervalues(): protocol.callRemote(commands.Send, message=message, sender=self.username) return {} def connectionLost(self, unused): try: del self.factory.username_to_protocol[self.username] except KeyError: pass for protocol in self.factory.username_to_protocol.itervalues(): protocol.callRemote(commands.DelUser, user=self.username) class ChatFactory(ServerFactory): protocol = ChatProtocol def __init__(self, portal): self.portal = portal self.username_to_protocol = {} def main(): options = Options() try: options.parseOptions() except usage.UsageError, err: print "%s: %s" % (sys.argv[0], err) print "%s: Try --help for usage details" % sys.argv[0] sys.exit(1) port = int(options["port"]) realm = Realm() checker = FilePasswordDB("passwd.txt") portal = Portal(realm, [checker]) factory = ChatFactory(portal) reactor.listenTCP(port, factory) reactor.run() if __name__ == "__main__": main()
dripton/ampchat
chatserver.py
Python
mit
3,458
0.001446
#!/usr/bin/python # -*- coding: utf-8 -*- ''' Schedulers determine how worker's queues get filled. They control which locations get scanned, in what order, at what time. This allows further optimizations to be easily added, without having to modify the existing overseer and worker thread code. Schedulers will recieve: queues - A list of queues for the workers they control. For now, this is a list containing a single queue. status - A list of status dicts for the workers. Schedulers can use this information to make more intelligent scheduling decisions. Useful values include: - last_scan_date: unix timestamp of when the last scan was completed - location: [lat,lng,alt] of the last scan args - The configuration arguments. This may not include all of the arguments, just ones that are relevant to this scheduler instance (eg. if multiple locations become supported, the args passed to the scheduler will only contain the parameters for the location it handles) Schedulers must fill the queues with items to search. Queue items are a list containing: [step, (latitude, longitude, altitude), appears_seconds, disappears_seconds)] Where: - step is the step number. Used only for display purposes. - (latitude, longitude, altitude) is the location to be scanned. - appears_seconds is the unix timestamp of when the pokemon next appears - disappears_seconds is the unix timestamp of when the pokemon next disappears appears_seconds and disappears_seconds are used to skip scans that are too late, and wait for scans the worker is early for. If a scheduler doesn't have a specific time a location needs to be scanned, it should set both to 0. If implementing a new scheduler, place it before SchedulerFactory, and add it to __scheduler_classes ''' import itertools import logging import math import geopy import json import time import sys from timeit import default_timer from threading import Lock from copy import deepcopy import traceback from collections import Counter from queue import Empty from operator import itemgetter from datetime import datetime, timedelta from .transform import get_new_coords from .models import (hex_bounds, Pokemon, SpawnPoint, ScannedLocation, ScanSpawnPoint) from .utils import now, cur_sec, cellid, date_secs, equi_rect_distance from .altitude import get_altitude log = logging.getLogger(__name__) # Simple base class that all other schedulers inherit from. # Most of these functions should be overridden in the actual scheduler classes. # Not all scheduler methods will need to use all of the functions. class BaseScheduler(object): def __init__(self, queues, status, args): self.queues = queues self.status = status self.args = args self.scan_location = False self.size = None self.ready = False # Schedule function fills the queues with data. def schedule(self): log.warning('BaseScheduler does not schedule any items') # location_changed function is called whenever the location being # scanned changes. # scan_location = (lat, lng, alt) def location_changed(self, scan_location, dbq): self.scan_location = scan_location self.empty_queues() # scanning_pause function is called when scanning is paused from the UI. # The default function will empty all the queues. # Note: This function is called repeatedly while scanning is paused! def scanning_paused(self): self.empty_queues() def getsize(self): return self.size def get_overseer_message(self): nextitem = self.queues[0].queue[0] message = 'Processing search queue, next item is {:6f},{:6f}'.format( nextitem[1][0], nextitem[1][1]) # If times are specified, print the time of the next queue item, and # how many seconds ahead/behind realtime if nextitem[2]: message += ' @ {}'.format( time.strftime('%H:%M:%S', time.localtime(nextitem[2]))) if nextitem[2] > now(): message += ' ({}s ahead)'.format(nextitem[2] - now()) else: message += ' ({}s behind)'.format(now() - nextitem[2]) return message # check if time to refresh queue def time_to_refresh_queue(self): return self.queues[0].empty() def task_done(self, *args): return self.queues[0].task_done() # Return the next item in the queue def next_item(self, search_items_queue): step, step_location, appears, leaves = self.queues[0].get() remain = appears - now() + 10 messages = { 'wait': 'Waiting for item from queue.', 'early': 'Early for {:6f},{:6f}; waiting {}s...'.format( step_location[0], step_location[1], remain), 'late': 'Too late for location {:6f},{:6f}; skipping.'.format( step_location[0], step_location[1]), 'search': 'Searching at {:6f},{:6f},{:6f}.'.format( step_location[0], step_location[1], step_location[2]), 'invalid': ('Invalid response at {:6f},{:6f}, ' + 'abandoning location.').format(step_location[0], step_location[1]) } return step, step_location, appears, leaves, messages # How long to delay since last action def delay(self, *args): return self.args.scan_delay # always scan delay time # Function to empty all queues in the queues list def empty_queues(self): self.ready = False for queue in self.queues: if not queue.empty(): try: while True: queue.get_nowait() except Empty: pass # Hex Search is the classic search method, with the pokepath modification, # searching in a hex grid around the center location. class HexSearch(BaseScheduler): # Call base initialization, set step_distance. def __init__(self, queues, status, args): BaseScheduler.__init__(self, queues, status, args) # If we are only scanning for pokestops/gyms, the scan radius can be # 450m. Otherwise 70m. if self.args.no_pokemon: self.step_distance = 0.450 else: self.step_distance = 0.070 self.step_limit = args.step_limit # This will hold the list of locations to scan so it can be reused, # instead of recalculating on each loop. self.locations = False # On location change, empty the current queue and the locations list def location_changed(self, scan_location, dbq): self.scan_location = scan_location self.empty_queues() self.locations = False # Generates the list of locations to scan. def _generate_locations(self): NORTH = 0 EAST = 90 SOUTH = 180 WEST = 270 # Dist between column centers. xdist = math.sqrt(3) * self.step_distance ydist = 3 * (self.step_distance / 2) # Dist between row centers. results = [] results.append((self.scan_location[0], self.scan_location[1], 0)) if self.step_limit > 1: loc = self.scan_location # Upper part. ring = 1 while ring < self.step_limit: loc = get_new_coords( loc, xdist, WEST if ring % 2 == 1 else EAST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist, NORTH) loc = get_new_coords( loc, xdist / 2, EAST if ring % 2 == 1 else WEST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords( loc, xdist, EAST if ring % 2 == 1 else WEST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist, SOUTH) loc = get_new_coords( loc, xdist / 2, EAST if ring % 2 == 1 else WEST) results.append((loc[0], loc[1], 0)) ring += 1 # Lower part. ring = self.step_limit - 1 loc = get_new_coords(loc, ydist, SOUTH) loc = get_new_coords( loc, xdist / 2, WEST if ring % 2 == 1 else EAST) results.append((loc[0], loc[1], 0)) while ring > 0: if ring == 1: loc = get_new_coords(loc, xdist, WEST) results.append((loc[0], loc[1], 0)) else: for i in range(ring - 1): loc = get_new_coords(loc, ydist, SOUTH) loc = get_new_coords( loc, xdist / 2, WEST if ring % 2 == 1 else EAST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords( loc, xdist, WEST if ring % 2 == 1 else EAST) results.append((loc[0], loc[1], 0)) for i in range(ring - 1): loc = get_new_coords(loc, ydist, NORTH) loc = get_new_coords( loc, xdist / 2, WEST if ring % 2 == 1 else EAST) results.append((loc[0], loc[1], 0)) loc = get_new_coords( loc, xdist, EAST if ring % 2 == 1 else WEST) results.append((loc[0], loc[1], 0)) ring -= 1 # This will pull the last few steps back to the front of the list, # so you get a "center nugget" at the beginning of the scan, instead # of the entire nothern area before the scan spots 70m to the south. if self.step_limit >= 3: if self.step_limit == 3: results = results[-2:] + results[:-2] else: results = results[-7:] + results[:-7] # Add the required appear and disappear times. locationsZeroed = [] for step, location in enumerate(results, 1): altitude = get_altitude(self.args, location) locationsZeroed.append( (step, (location[0], location[1], altitude), 0, 0)) return locationsZeroed # Schedule the work to be done. def schedule(self): if not self.scan_location: log.warning( 'Cannot schedule work until scan location has been set') return # Only generate the list of locations if we don't have it already # calculated. if not self.locations: self.locations = self._generate_locations() for location in self.locations: # FUTURE IMPROVEMENT - For now, queues is assumed to have a single # queue. self.queues[0].put(location) log.debug("Added location {}".format(location)) self.size = len(self.locations) self.ready = True # Spawn Only Hex Search works like Hex Search, but skips locations that # have no known spawnpoints. class HexSearchSpawnpoint(HexSearch): def _any_spawnpoints_in_range(self, coords, spawnpoints): return any( geopy.distance.distance(coords, x).meters <= 70 for x in spawnpoints) # Extend the generate_locations function to remove locations with no # spawnpoints. def _generate_locations(self): n, e, s, w = hex_bounds(self.scan_location, self.step_limit) spawnpoints = set((d['latitude'], d['longitude']) for d in Pokemon.get_spawnpoints(s, w, n, e)) if len(spawnpoints) == 0: log.warning('No spawnpoints found in the specified area! (Did ' + 'you forget to run a normal scan in this area first?)') # Call the original _generate_locations. locations = super(HexSearchSpawnpoint, self)._generate_locations() # Remove items with no spawnpoints in range. locations = [ coords for coords in locations if self._any_spawnpoints_in_range(coords[1], spawnpoints)] return locations # Spawn Scan searches known spawnpoints at the specific time they spawn. class SpawnScan(BaseScheduler): def __init__(self, queues, status, args): BaseScheduler.__init__(self, queues, status, args) # On the first scan, we want to search the last 15 minutes worth of # spawns to get existing pokemon onto the map. self.firstscan = True # If we are only scanning for pokestops/gyms, the scan radius can be # 450m. Otherwise 70m. if self.args.no_pokemon: self.step_distance = 0.450 else: self.step_distance = 0.070 self.step_limit = args.step_limit self.locations = False # Generate locations is called when the locations list is cleared - the # first time it scans or after a location change. def _generate_locations(self): # Attempt to load spawns from file. if self.args.spawnpoint_scanning != 'nofile': log.debug('Loading spawn points from json file @ %s', self.args.spawnpoint_scanning) try: with open(self.args.spawnpoint_scanning) as file: self.locations = json.load(file) except ValueError as e: log.error('JSON error: %s; will fallback to database', repr(e)) except IOError as e: log.error( 'Error opening json file: %s; will fallback to database', repr(e)) # No locations yet? Try the database! if not self.locations: log.debug('Loading spawn points from database') self.locations = Pokemon.get_spawnpoints_in_hex( self.scan_location, self.args.step_limit) # Well shit... # if not self.locations: # raise Exception('No availabe spawn points!') # locations[]: # {"lat": 37.53079079414139, "lng": -122.28811690874117, # "spawnpoint_id": "808f9f1601d", "time": 511 log.info('Total of %d spawns to track', len(self.locations)) # locations.sort(key=itemgetter('time')) if self.args.very_verbose: for i in self.locations: sec = i['time'] % 60 minute = (i['time'] / 60) % 60 m = 'Scan [{:02}:{:02}] ({}) @ {},{}'.format( minute, sec, i['time'], i['lat'], i['lng']) log.debug(m) # 'time' from json and db alike has been munged to appearance time as # seconds after the hour. # Here we'll convert that to a real timestamp. for location in self.locations: # For a scan which should cover all CURRENT pokemon, we can offset # the comparison time by 15 minutes so that the "appears" time # won't be rolled over to the next hour. # TODO: Make it work. The original logic (commented out) was # producing bogus results if your first scan was in the last # 15 minute of the hour. Wrapping my head around this isn't # work right now, so I'll just drop the feature for the time # being. It does need to come back so that # repositioning/pausing works more nicely, but we can live # without it too. # if sps_scan_current: # cursec = (location['time'] + 900) % 3600 # else: cursec = location['time'] if cursec > cur_sec(): # Hasn't spawn in the current hour. from_now = location['time'] - cur_sec() appears = now() + from_now else: # Won't spawn till next hour. late_by = cur_sec() - location['time'] appears = now() + 3600 - late_by location['appears'] = appears location['leaves'] = appears + 900 # Put the spawn points in order of next appearance time. self.locations.sort(key=itemgetter('appears')) # Match expected structure: # locations = [((lat, lng, alt), ts_appears, ts_leaves),...] retset = [] for step, location in enumerate(self.locations, 1): altitude = get_altitude(self.args, [location['lat'], location['lng']]) retset.append((step, (location['lat'], location['lng'], altitude), location['appears'], location['leaves'])) return retset # Schedule the work to be done. def schedule(self): if not self.scan_location: log.warning( 'Cannot schedule work until scan location has been set') return # SpawnScan needs to calculate the list every time, since the times # will change. self.locations = self._generate_locations() for location in self.locations: # FUTURE IMPROVEMENT - For now, queues is assumed to have a single # queue. self.queues[0].put(location) log.debug("Added location {}".format(location)) # Clear the locations list so it gets regenerated next cycle. self.size = len(self.locations) self.locations = None self.ready = True # SpeedScan is a complete search method that initially does a spawnpoint # search in each scan location by scanning five two-minute bands within # an hour and ten minute intervals between bands. # After finishing the spawnpoint search or if timing isn't right for any of # the remaining search bands, workers will search the nearest scan location # that has a new spawn. class SpeedScan(HexSearch): # Call base initialization, set step_distance def __init__(self, queues, status, args): super(SpeedScan, self).__init__(queues, status, args) self.refresh_date = datetime.utcnow() - timedelta(days=1) self.next_band_date = self.refresh_date self.queues = [[]] self.ready = False self.spawns_found = 0 self.spawns_missed_delay = {} self.scans_done = 0 self.scans_missed = 0 self.scans_missed_list = [] # Minutes between queue refreshes. Should be less than 10 to allow for # new bands during Initial scan self.minutes = 5 self.found_percent = [] self.scan_percent = [] self.spawn_percent = [] self.status_message = [] self.tth_found = 0 # Initiate special types. self._stat_init() self._locks_init() def _stat_init(self): self.spawns_found = 0 self.spawns_missed_delay = {} self.scans_done = 0 self.scans_missed = 0 self.scans_missed_list = [] def _locks_init(self): self.lock_next_item = Lock() # On location change, empty the current queue and the locations list def location_changed(self, scan_location, db_update_queue): super(SpeedScan, self).location_changed(scan_location, db_update_queue) self.locations = self._generate_locations() scans = {} initial = {} all_scans = {} for sl in ScannedLocation.select_in_hex(self.scan_location, self.args.step_limit): all_scans[cellid((sl['latitude'], sl['longitude']))] = sl for i, e in enumerate(self.locations): cell = cellid(e[1]) scans[cell] = {'loc': e[1], # Lat/long pair 'step': e[0]} initial[cell] = all_scans[cell] if cell in all_scans.keys( ) else ScannedLocation.new_loc(e[1]) self.scans = scans db_update_queue.put((ScannedLocation, initial)) log.info('%d steps created', len(scans)) self.band_spacing = int(10 * 60 / len(scans)) self.band_status() spawnpoints = SpawnPoint.select_in_hex( self.scan_location, self.args.step_limit) if not spawnpoints: log.info('No spawnpoints in hex found in SpawnPoint table. ' + 'Doing initial scan.') log.info('Found %d spawn points within hex', len(spawnpoints)) log.info('Doing %s distance calcs to assign spawn points to scans', "{:,}".format(len(spawnpoints) * len(scans))) scan_spawn_point = {} ScannedLocation.link_spawn_points(scans, initial, spawnpoints, self.step_distance, scan_spawn_point, force=True) if len(scan_spawn_point): log.info('%d relations found between the spawn points and steps', len(scan_spawn_point)) db_update_queue.put((ScanSpawnPoint, scan_spawn_point)) else: log.info('Spawn points assigned') # Generates the list of locations to scan # Created a new function, because speed scan requires fixed locations, # even when increasing -st. With HexSearch locations, the location of # inner rings would change if -st was increased requiring rescanning # since it didn't recognize the location in the ScannedLocation table def _generate_locations(self): NORTH = 0 EAST = 90 SOUTH = 180 WEST = 270 # dist between column centers xdist = math.sqrt(3) * self.step_distance ydist = 3 * (self.step_distance / 2) # dist between row centers results = [] loc = self.scan_location results.append((loc[0], loc[1], 0)) # upper part for ring in range(1, self.step_limit): for i in range(max(ring - 1, 1)): if ring > 1: loc = get_new_coords(loc, ydist, NORTH) loc = get_new_coords(loc, xdist / (1 + (ring > 1)), WEST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist, NORTH) loc = get_new_coords(loc, xdist / 2, EAST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, xdist, EAST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist, SOUTH) loc = get_new_coords(loc, xdist / 2, EAST) results.append((loc[0], loc[1], 0)) for i in range(ring): loc = get_new_coords(loc, ydist, SOUTH) loc = get_new_coords(loc, xdist / 2, WEST) results.append((loc[0], loc[1], 0)) for i in range(ring + (ring + 1 < self.step_limit)): loc = get_new_coords(loc, xdist, WEST) results.append((loc[0], loc[1], 0)) generated_locations = [] for step, location in enumerate(results): altitude = get_altitude(self.args, location) generated_locations.append( (step, (location[0], location[1], altitude), 0, 0)) return generated_locations def getsize(self): return len(self.queues[0]) def get_overseer_message(self): n = 0 ms = (datetime.utcnow() - self.refresh_date).total_seconds() + \ self.refresh_ms counter = { 'TTH': 0, 'spawn': 0, 'band': 0, } for item in self.queues[0]: if item.get('done', False): continue if ms > item['end']: continue if ms < item['start']: break n += 1 counter[item['kind']] += 1 message = ('Scanning status: {} total waiting, {} initial bands, ' + '{} TTH searches, and {} new spawns').format( n, counter['band'], counter['TTH'], counter['spawn']) if self.status_message: message += '\n' + self.status_message return message # Refresh queue every 5 minutes # the first band of a scan is done def time_to_refresh_queue(self): return ((datetime.utcnow() - self.refresh_date).total_seconds() > self.minutes * 60 or self.queues == [[]]) # Function to empty all queues in the queues list def empty_queues(self): self.queues = [[]] # How long to delay since last action def delay(self, last_scan_date): return max( ((last_scan_date - datetime.utcnow()).total_seconds() + self.args.scan_delay), 2) def band_status(self): try: bands_total = len(self.locations) * 5 bands_filled = ScannedLocation.get_bands_filled_by_cellids( self.scans.keys()) percent = bands_filled * 100.0 / bands_total if bands_total == bands_filled: log.info('Initial spawnpoint scan is complete') else: log.info('Initial spawnpoint scan, %d of %d bands are done ' + 'or %.1f%% complete', bands_filled, bands_total, percent) return percent except Exception as e: log.error( 'Exception in band_status: Exception message: {}'.format( repr(e))) # Update the queue, and provide a report on performance of last minutes def schedule(self): log.info('Refreshing queue') self.ready = False now_date = datetime.utcnow() self.refresh_date = now_date self.refresh_ms = now_date.minute * 60 + now_date.second old_q = deepcopy(self.queues[0]) queue = [] # Measure the time it takes to refresh the queue start = time.time() # prefetch all scanned locations scanned_locations = ScannedLocation.get_by_cellids(self.scans.keys()) # extract all spawnpoints into a dict with spawnpoint # id -> spawnpoint for easy access later cell_to_linked_spawn_points = ( ScannedLocation.get_cell_to_linked_spawn_points(self.scans.keys())) sp_by_id = {} for sps in cell_to_linked_spawn_points.itervalues(): for sp in sps: sp_by_id[sp['id']] = sp for cell, scan in self.scans.iteritems(): queue += ScannedLocation.get_times(scan, now_date, scanned_locations) queue += SpawnPoint.get_times(cell, scan, now_date, self.args.spawn_delay, cell_to_linked_spawn_points, sp_by_id) end = time.time() queue.sort(key=itemgetter('start')) self.queues[0] = queue self.ready = True log.info('New queue created with %d entries in %f seconds', len(queue), (end - start)) if old_q: # Enclosing in try: to avoid divide by zero exceptions from # killing overseer try: # Possible 'done' values are 'Missed', 'Scanned', None, or # number Not_none_list = filter(lambda e: e.get( 'done', None) is not None, old_q) Missed_list = filter(lambda e: e.get( 'done', None) == 'Missed', Not_none_list) Scanned_list = filter(lambda e: e.get( 'done', None) == 'Scanned', Not_none_list) Timed_list = filter(lambda e: type( e['done']) is not str, Not_none_list) spawns_timed_list = filter( lambda e: e['kind'] == 'spawn', Timed_list) spawns_timed = len(spawns_timed_list) bands_timed = len( filter(lambda e: e['kind'] == 'band', Timed_list)) spawns_all = spawns_timed + \ len(filter(lambda e: e['kind'] == 'spawn', Scanned_list)) spawns_missed = len( filter(lambda e: e['kind'] == 'spawn', Missed_list)) band_percent = self.band_status() kinds = {} tth_ranges = {} self.tth_found = 0 self.active_sp = 0 found_percent = 100.0 good_percent = 100.0 spawns_reached = 100.0 spawnpoints = SpawnPoint.select_in_hex( self.scan_location, self.args.step_limit) for sp in spawnpoints: if sp['missed_count'] > 5: continue self.active_sp += 1 self.tth_found += (sp['earliest_unseen'] == sp['latest_seen']) kind = sp['kind'] kinds[kind] = kinds.get(kind, 0) + 1 tth_range = str(int(round( ((sp['earliest_unseen'] - sp['latest_seen']) % 3600) / 60.0))) tth_ranges[tth_range] = tth_ranges.get(tth_range, 0) + 1 tth_ranges['0'] = tth_ranges.get('0', 0) - self.tth_found len_spawnpoints = len(spawnpoints) + (not len(spawnpoints)) log.info('Total Spawn Points found in hex: %d', len(spawnpoints)) log.info('Inactive Spawn Points found in hex: %d or %.1f%%', len(spawnpoints) - self.active_sp, (len(spawnpoints) - self.active_sp) * 100.0 / len_spawnpoints) log.info('Active Spawn Points found in hex: %d or %.1f%%', self.active_sp, self.active_sp * 100.0 / len_spawnpoints) self.active_sp += self.active_sp == 0 for k in sorted(kinds.keys()): log.info('%s kind spawns: %d or %.1f%%', k, kinds[k], kinds[k] * 100.0 / self.active_sp) log.info('Spawns with found TTH: %d or %.1f%% [%d missing]', self.tth_found, self.tth_found * 100.0 / self.active_sp, self.active_sp - self.tth_found) for k in sorted(tth_ranges.keys(), key=int): log.info('Spawnpoints with a %sm range to find TTH: %d', k, tth_ranges[k]) log.info('Over last %d minutes: %d new bands, %d Pokemon ' + 'found', self.minutes, bands_timed, spawns_all) log.info('Of the %d total spawns, %d were targeted, and %d ' + 'found scanning for others', spawns_all, spawns_timed, spawns_all - spawns_timed) scan_total = spawns_timed + bands_timed spm = scan_total / self.minutes seconds_per_scan = self.minutes * 60 * \ self.args.workers / scan_total if scan_total else 0 log.info('%d scans over %d minutes, %d scans per minute, %d ' + 'secs per scan per worker', scan_total, self.minutes, spm, seconds_per_scan) sum = spawns_all + spawns_missed if sum: spawns_reached = spawns_all * 100.0 / \ (spawns_all + spawns_missed) log.info('%d Pokemon found, and %d were not reached in ' + 'time for %.1f%% found', spawns_all, spawns_missed, spawns_reached) if spawns_timed: average = reduce( lambda x, y: x + y['done'], spawns_timed_list, 0) / spawns_timed log.info('%d Pokemon found, %d were targeted, with an ' + 'average delay of %d sec', spawns_all, spawns_timed, average) spawns_missed = reduce( lambda x, y: x + len(y), self.spawns_missed_delay.values(), 0) sum = spawns_missed + self.spawns_found found_percent = ( self.spawns_found * 100.0 / sum if sum else 0) log.info('%d spawns scanned and %d spawns were not ' + 'there when expected for %.1f%%', self.spawns_found, spawns_missed, found_percent) self.spawn_percent.append(round(found_percent, 1)) if self.spawns_missed_delay: log.warning('Missed spawn IDs with times after spawn:') log.warning(self.spawns_missed_delay) log.info('History: %s', str( self.spawn_percent).strip('[]')) sum = self.scans_done + len(self.scans_missed_list) good_percent = self.scans_done * 100.0 / sum if sum else 0 log.info( '%d scans successful and %d scans missed for %.1f%% found', self.scans_done, len(self.scans_missed_list), good_percent) self.scan_percent.append(round(good_percent, 1)) if self.scans_missed_list: log.warning('Missed scans: %s', Counter( self.scans_missed_list).most_common(3)) log.info('History: %s', str(self.scan_percent).strip('[]')) self.status_message = ('Initial scan: {:.2f}%, TTH found: ' + '{:.2f}% [{} missing], ').format( band_percent, self.tth_found * 100.0 / self.active_sp, self.active_sp - self.tth_found) self.status_message += ('Spawns reached: {:.2f}%, Spawns ' + 'found: {:.2f}%, Good scans ' + '{:.2f}%').format(spawns_reached, found_percent, good_percent) self._stat_init() except Exception as e: log.error( 'Performance statistics had an Exception: {}'.format( repr(e))) traceback.print_exc(file=sys.stdout) # Find the best item to scan next def next_item(self, status): # Thread safety: don't let multiple threads get the same "best item". with self.lock_next_item: # Score each item in the queue by # of due spawns or scan time # bands can be filled. while not self.ready: time.sleep(1) now_date = datetime.utcnow() now_time = time.time() n = 0 # count valid scans reviewed q = self.queues[0] ms = ((now_date - self.refresh_date).total_seconds() + self.refresh_ms) best = {'score': 0} cant_reach = False worker_loc = [status['latitude'], status['longitude']] last_action = status['last_scan_date'] # Check all scan locations possible in the queue. for i, item in enumerate(q): # If already claimed by another worker or done, pass. if item.get('done', False): continue # If the item is parked by a different thread (or by a # different account, which should be on that one thread), # pass. our_parked_name = status['username'] if 'parked_name' in item: # We use 'parked_last_update' to determine when the # last time was since the thread passed the item with the # same thread name & username. If it's been too long, unset # the park so another worker can pick it up. now = default_timer() max_parking_idle_seconds = 3 * 60 if (now - item.get('parked_last_update', now) > max_parking_idle_seconds): # Unpark & don't skip it. item.pop('parked_name', None) item.pop('parked_last_update', None) else: # Still parked and not our item. Skip it. if item.get('parked_name') != our_parked_name: continue # If already timed out, mark it as Missed and check next. if ms > item['end']: item['done'] = 'Missed' if not item.get( 'done', False) else item['done'] continue # If we just did a fresh band recently, wait a few seconds to # space out the band scans. if now_date < self.next_band_date: continue # If the start time isn't yet, don't bother looking further, # since queue sorted by start time. if ms < item['start']: break loc = item['loc'] distance = equi_rect_distance(loc, worker_loc) secs_to_arrival = distance / self.args.kph * 3600 # If we can't make it there before it disappears, don't bother # trying. if ms + secs_to_arrival > item['end']: cant_reach = True continue n += 1 # Bands are top priority to find new spawns first score = 1e12 if item['kind'] == 'band' else ( 1e6 if item['kind'] == 'TTH' else 1) # For spawns, score is purely based on how close they are to # last worker position score = score / (distance + .01) if score > best['score']: best = {'score': score, 'i': i} best.update(item) prefix = 'Calc %.2f for %d scans:' % (time.time() - now_time, n) loc = best.get('loc', []) step = best.get('step', 0) i = best.get('i', 0) messages = { 'wait': 'Nothing to scan.', 'early': 'Early for step {}; waiting a few seconds...'.format( step), 'late': ('API response on step {} delayed by {} seconds. ' + 'Possible causes: slow proxies, internet, or ' + 'Niantic servers.').format( step, int((now_date - last_action).total_seconds())), 'search': 'Searching at step {}.'.format(step), 'invalid': ('Invalid response at step {}, abandoning ' + 'location.').format(step) } try: item = q[i] except IndexError: messages['wait'] = ('Search aborting.' + ' Overseer refreshing queue.') return -1, 0, 0, 0, messages if best['score'] == 0: if cant_reach: messages['wait'] = ('Not able to reach any scan' + ' under the speed limit.') return -1, 0, 0, 0, messages distance = equi_rect_distance(loc, worker_loc) if (distance > (now_date - last_action).total_seconds() * self.args.kph / 3600): # Flag item as "parked" by a specific thread, because # we're waiting for it. This will avoid all threads "walking" # to the same item. our_parked_name = status['username'] item['parked_name'] = our_parked_name # CTRL+F 'parked_last_update' in this file for more info. item['parked_last_update'] = default_timer() messages['wait'] = 'Moving {}m to step {} for a {}.'.format( int(distance * 1000), step, best['kind']) return -1, 0, 0, 0, messages prefix += ' Step %d,' % (step) # Check again if another worker heading there. # TODO: Check if this is still necessary. I believe this was # originally a failed attempt at thread safety, which still # resulted in a race condition (multiple workers heading to the # same spot). A thread Lock has since been added. if item.get('done', False): messages['wait'] = ('Skipping step {}. Other worker already ' + 'scanned.').format(step) return -1, 0, 0, 0, messages if not self.ready: messages['wait'] = ('Search aborting.' + ' Overseer refreshing queue.') return -1, 0, 0, 0, messages # If a new band, set the date to wait until for the next band. if best['kind'] == 'band' and best['end'] - best['start'] > 5 * 60: self.next_band_date = datetime.utcnow() + timedelta( seconds=self.band_spacing) # Mark scanned item['done'] = 'Scanned' status['index_of_queue_item'] = i messages['search'] = 'Scanning step {} for a {}.'.format( best['step'], best['kind']) return best['step'], best['loc'], 0, 0, messages def task_done(self, status, parsed=False): if parsed: # Record delay between spawn time and scanning for statistics now_secs = date_secs(datetime.utcnow()) item = self.queues[0][status['index_of_queue_item']] seconds_within_band = ( int((datetime.utcnow() - self.refresh_date).total_seconds()) + self.refresh_ms) enforced_delay = (self.args.spawn_delay if item['kind'] == 'spawn' else 0) start_delay = seconds_within_band - item['start'] + enforced_delay safety_buffer = item['end'] - seconds_within_band if safety_buffer < 0: log.warning('Too late by %d sec for a %s at step %d', - safety_buffer, item['kind'], item['step']) # If we had a 0/0/0 scan, then unmark as done so we can retry, and # save for Statistics elif parsed['bad_scan']: self.scans_missed_list.append(cellid(item['loc'])) # Only try for a set amount of times (BAD_SCAN_RETRY) if self.args.bad_scan_retry > 0 and ( self.scans_missed_list.count(cellid(item['loc'])) > self.args.bad_scan_retry): log.info('Step %d failed scan for %d times! Giving up...', item['step'], self.args.bad_scan_retry + 1) else: item['done'] = None log.info('Putting back step %d in queue', item['step']) else: # Scan returned data self.scans_done += 1 item['done'] = start_delay # Were we looking for spawn? if item['kind'] == 'spawn': sp_id = item['sp'] # Did we find the spawn? if sp_id in parsed['sp_id_list']: self.spawns_found += 1 elif start_delay > 0: # not sure why this could be # negative, but sometimes it is # if not, record ID and put back in queue self.spawns_missed_delay[ sp_id] = self.spawns_missed_delay.get(sp_id, []) self.spawns_missed_delay[sp_id].append(start_delay) item['done'] = 'Scanned' # For existing spawn points, if in any other queue items, mark # 'scanned' for sp_id in parsed['sp_id_list']: for item in self.queues[0]: if (sp_id == item.get('sp', None) and item.get('done', None) is None and now_secs > item['start'] and now_secs < item['end']): item['done'] = 'Scanned' # The SchedulerFactory returns an instance of the correct type of scheduler. class SchedulerFactory(): __schedule_classes = { "hexsearch": HexSearch, "hexsearchspawnpoint": HexSearchSpawnpoint, "spawnscan": SpawnScan, "speedscan": SpeedScan, } @staticmethod def get_scheduler(name, *args, **kwargs): scheduler_class = SchedulerFactory.__schedule_classes.get( name.lower(), None) if scheduler_class: return scheduler_class(*args, **kwargs) raise NotImplementedError( "The requested scheduler has not been implemented") # The KeyScheduler returns a scheduler that cycles through the given hash # server keys. class KeyScheduler(object): def __init__(self, keys): self.keys = {} for key in keys: self.keys[key] = { 'remaining': 0, 'maximum': 0, 'peak': 0 } self.key_cycle = itertools.cycle(keys) self.curr_key = '' def keys(self): return self.keys def current(self): return self.curr_key def next(self): self.curr_key = self.key_cycle.next() return self.curr_key
slgphantom/RocketMap
pogom/schedulers.py
Python
agpl-3.0
46,757
0.000021
#! /usr/bin/python # -*- coding: UTF-8 -*- # Copyright 2018-2019 Luiko Czub, TestLink-API-Python-client developers # # 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 os.path import pytest from testlink import TestlinkAPIClient, TestlinkAPIGeneric, TestLinkHelper # example text file attachment = this python file # why not using os.path.realpath(__file__) # -> cause __file__ could be compiled python file *.pyc, if the test run is # repeated without changing the test code ATTACHMENT_EXAMPLE_TEXT= os.path.join(os.path.dirname(__file__), os.path.basename(__file__)) #attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, 'r') @pytest.fixture() def attachmentFile(): ''' open readonly attachment sample before test and close it afterwards ''' aFile = open(ATTACHMENT_EXAMPLE_TEXT, 'r') yield aFile aFile.close() @pytest.fixture(scope='session') def api_helper_class(): return TestLinkHelper @pytest.fixture(scope='session') def api_generic_client(api_helper_class): ''' Init TestlinkAPIGeneric Client with connection parameters defined in environment variables TESTLINK_API_PYTHON_DEVKEY and TESTLINK_API_PYTHON_DEVKEY ''' return api_helper_class().connect(TestlinkAPIGeneric) @pytest.fixture(scope='session') def api_general_client(api_helper_class): ''' Init TestlinkAPIClient Client with connection parameters defined in environment variables TESTLINK_API_PYTHON_DEVKEY and TESTLINK_API_PYTHON_DEVKEY ''' return api_helper_class().connect(TestlinkAPIClient) @pytest.fixture(scope='session', params=[TestlinkAPIGeneric, TestlinkAPIClient]) def api_client_class(request): ''' all variations of Testlink API Client classes ''' return request.param @pytest.fixture(scope='session') def api_client(api_client_class, api_helper_class): ''' Init Testlink API Client class defined in fixtures api_client_class with connection parameters defined in environment variables TESTLINK_API_PYTHON_DEVKEY and TESTLINK_API_PYTHON_DEVKEY Tests will be call for each Testlink API Client class, defined in fixtures parameter list ''' return api_helper_class().connect(api_client_class)
lczub/TestLink-API-Python-client
test/conftest.py
Python
apache-2.0
2,865
0.008028
from __future__ import absolute_import from __future__ import division from __future__ import print_function import json import os import sys import getpass from os.path import expanduser import stat import shutil import bit.git as git structure="\n\ /file_system_a\n\ |\n\ '- data\n\ |\n\ '- projects\n\ |\n\ |- Company_A\n\ | |\n\ | |- CA_project_y\n\ | |\n\ | '- CA_project_x\n\ | |\n\ | |- results\n\ | |- models\n\ | |- scripts\n\ | |- tmp\n\ | |- slurm_logs\n\ | '- wiki\n\ |\n\ '- Company_B\n\ |\n\ '- CB_project_n\n\n\ absolute path to projects = /file_system_a/data/projects/" requirements=["owncloud_address","owncloud_upload_folder",\ "owncloud_download_folder","owncloud_user",\ "owncloud_pass","github_address",\ "github_organization","github_user",\ "github_pass","local_path", "user_group" ] special_reqs=["owncloud_user","owncloud_pass",\ "github_user","github_pass"] start_reqs=["github_address","github_organization",\ "github_user","github_pass","local_path"] def get_owncloud_address(): owncloud_address=str(input("Please give in your ownCloud address (eg. http://domain.tld/owncloud): ")) or None return owncloud_address def get_owncloud_upload_folder(): owncloud_upload_folder=str(input("Please give in the folder in your ownCloud that will be used to deliver data to users.\nYou can share this folder with your colleagues so that everybody delivers data through the same folder. (default: DELIVERY_SERVICE):")) or "DELIVERY_SERVICE" return owncloud_upload_folder def get_owncloud_download_folder(): owncloud_download_folder=str(input("Please give in the folder in your ownCloud that will be used to retrieve data from users.\nYou can share this folder with your colleagues so that everybody retrieves data through the same folder. (default: DROPBOX):")) or "DROPBOX" return owncloud_download_folder def get_owncloud_user(config_file=None): if config_file: owncloud_user=str(input("Please give in your ownCloud user name or press Enter if you do not want to save this information on the config file: ")) or None else: owncloud_user=str(input("Please give in your ownCloud user name: ")) or None return owncloud_user def get_owncloud_pass(config_file=None): if config_file: owncloud_pass=str(getpass.getpass(prompt="Please give in your ownCloud password or press Enter if you do not want to save this information on the config file: ")) or None else: owncloud_pass=str(getpass.getpass(prompt="Please give in your ownCloud password: ")) or None return owncloud_pass def get_github_address(): github_address=str(input("Github server address (default: https://github.com): ") or "https://github.com") return github_address def get_github_organization(): github_organization=str(input("Your GitHub organization name (eg. mpg-age-bioinformatics for https://github.com/mpg-age-bioinformatics): ")) or None return github_organization def get_github_user(config_file=None,gitssh=None): if not gitssh: if config_file: github_user=str(input("Please give in your user name for your github server or press Enter if you do not want to save this information on the config file: ")) or None else: github_user=str(input("Please give in your user name for your github server: ")) or None else: github_user=None return github_user def get_github_pass(config_file=None,gitssh=None): if not gitssh: if config_file: github_pass=str(getpass.getpass(prompt="Please give in your password or access token (infos on: https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/) for your github server or press Enter if you do not want to save this information on the config file: ")) or None else: github_pass=str(getpass.getpass(prompt="Please give in your password or access token for your github server: ")) or None else: github_pass=None return github_pass def get_local_path(structure=structure): local_path=str(input("The bermuda information triangle works on the basis that all your projects are located in the same path and have a parent subpath in your local machine ie. %s\n Please give in the absolute path to your projects folder: " %structure ) ) or None return local_path def get_user_group(): user_group=str(input("If you are using ACLs to give your group members access to this project please give in the users that will have read write access to every projects top folders. eg. userA,userB,userC -- DO NOT forger to give in your own user name: ")) or None if user_group: user_group=user_group.split(",") return user_group def get_github_api(github_address): if "github.com" in github_address: github_api="https://api.github.com/orgs/" else: github_api=github_address+"/api/v3/orgs/" return github_api def make_bitconfig(require_func=requirements,special_reqs=special_reqs): configdic={} configdic=check_reqs(require_func,configdic,config_file=True, gitssh=None) uhome=expanduser("~")+"/" configfile=open(uhome+".bit_config","w+") with open(uhome+".bit_config", 'w') as configfile: json.dump(configdic, configfile) os.chmod(uhome+".bit_config", stat.S_IRWXU ) print("Your bit config file as been generated:") for c in configdic: if "pass" not in c: print( c, configdic.get(c) ) sys.stdout.flush() elif configdic.get(c) == None: print(c, configdic.get(c) ) sys.stdout.flush() else: print(c, "*") sys.stdout.flush() def read_bitconfig(showit=None,bit_config=".bit_config"): uhome=expanduser("~")+"/" with open(uhome+bit_config, 'r') as configfile: configdic=json.load(configfile) if showit: for c in configdic: if "pass" not in c: print(c, configdic.get(c)) sys.stdout.flush() elif configdic.get(c) == None: print(c, configdic.get(c)) sys.stdout.flush() else: print(c, "*") sys.stdout.flush() return configdic def check_reqs(requirements,configdic,config_file=None, gitssh=None): if "owncloud_address" in requirements: configdic["owncloud_address"]=get_owncloud_address() if "owncloud_upload_folder" in requirements: configdic["owncloud_upload_folder"]=get_owncloud_upload_folder() if "owncloud_download_folder" in requirements: configdic["owncloud_download_folder"]=get_owncloud_download_folder() if "owncloud_user" in requirements: configdic["owncloud_user"]=get_owncloud_user(config_file=config_file) if "owncloud_pass" in requirements: configdic["owncloud_pass"]=get_owncloud_pass(config_file=config_file) if "github_address" in requirements: configdic["github_address"]=get_github_address() if "github_organization" in requirements: configdic["github_organization"]=get_github_organization() if "github_user" in requirements: configdic["github_user"]=get_github_user(config_file=config_file,gitssh=gitssh ) if "github_pass" in requirements: configdic["github_pass"]=get_github_pass(config_file=config_file,gitssh=gitssh ) if "local_path" in requirements: configdic["local_path"]=get_local_path() if "user_group" in requirements: configdic["user_group"]=get_user_group() return configdic def init_user(path_to_project,github_address,github_organization,github_repo,github_user=None,github_pass=None,gitssh=None): user_name=getpass.getuser() if not os.path.exists(path_to_project): os.makedirs(path_to_project) response=git.git_clone(path_to_project+"/scripts."+user_name , github_address, github_organization, github_repo, github_user=github_user, github_pass=github_pass, gitssh=gitssh) response=git.git_clone(path_to_project+"/wiki."+user_name , github_address, github_organization, github_repo+".wiki", github_user=github_user, github_pass=github_pass, gitssh=gitssh) if response == 1: input("\n\n*************\n\nThe wiki for this project has not yet been created.\n\n Please go to %s/%s/%s/wiki and click on 'Create the first page' and then 'Save Page'.\n\nPress Enter once you have saved the first wiki page.\n\nOtherwise press enter to skip wiki creation.\n\n*************\n\n" %(github_address,github_organization,github_repo) ) response=git.git_clone(path_to_project+"/wiki."+user_name ,github_address,github_organization,github_repo+".wiki",github_user=github_user,github_pass=github_pass,gitssh=gitssh) if response == 1: shutil.rmtree(path_to_project+"/wiki."+user_name, ignore_errors=True) print("Skipping wiki creation.") sys.stdout.flush() print("User initialized.") sys.stdout.flush()
mpg-age-bioinformatics/bit
bit/config.py
Python
mit
9,252
0.016105
#!/usr/bin/env python3 """ This module runs all the tests of the auxi package at once. """ import unittest from auxi.core.objects_test import ObjectUnitTester from auxi.core.objects_test import NamedObjectUnitTester from auxi.core.time_test import ClockUnitTester from auxi.tools.chemistry.stoichiometry_test import StoichFunctionTester from auxi.tools.chemistry.thermochemistry_test import ThermoFunctionTester from auxi.tools.materialphysicalproperties.core_test import DataSetTester from auxi.tools.materialphysicalproperties.idealgas_test \ import BetaTTester, RhoTTester, RhoTPTester, RhoTPxTester from auxi.tools.materialphysicalproperties.polynomial_test \ import PolynomialModelTTester from auxi.tools.transportphenomena.heattransfer.naturalconvection_test \ import IsothermalFlatSurface_RegionTester, IsothermalFlatSurfaceTester from auxi.tools.transportphenomena.dimensionlessquantities_test \ import DimensionlessQiantitiesTester from auxi.modelling.process.materials.chem_test \ import ChemMaterialUnitTester, ChemMaterialPackageUnitTester from auxi.modelling.process.materials.thermo_test \ import ThermoMaterialUnitTester # from auxi.modelling.process.materials.thermo_test \ # import ThermoMaterialPackageUnitTester from auxi.modelling.process.materials.psd_test \ import PsdMaterialUnitTester, PsdMaterialPackageUnitTester from auxi.modelling.process.materials.slurry_test \ import SlurryMaterialUnitTester, SlurryMaterialPackageUnitTester # MODELLING.FINANCIAL from auxi.modelling.financial.des_test import GeneralLedgerAccountUnitTester from auxi.modelling.financial.des_test import TransactionUnitTester from auxi.modelling.financial.des_test import TransactionTemplateUnitTester from auxi.modelling.financial.des_test import GeneralLedgerStructureUnitTester from auxi.modelling.financial.des_test import GeneralLedgerUnitTester from auxi.modelling.financial.reporting_test import GeneralLedgerStructureUnitTester from auxi.modelling.financial.reporting_test import TransactionListUnitTester # MODELLING.BUSINESS from auxi.modelling.business.structure_test import ActivityUnitTester from auxi.modelling.business.structure_test import ComponentUnitTester from auxi.modelling.business.structure_test import EntityUnitTester from auxi.modelling.business.basic_test import BasicActivityUnitTester from auxi.modelling.business.basic_test import BasicLoanActivityUnitTester from auxi.modelling.business.models_test import TimeBasedModelUnitTester __version__ = '0.3.2' __license__ = 'LGPL v3' __copyright__ = 'Copyright 2016, Ex Mente Technologies (Pty) Ltd' __author__ = 'Christoff Kok, Johan Zietsman' __credits__ = ['Christoff Kok', 'Johan Zietsman'] __maintainer__ = 'Christoff Kok' __email__ = 'christoff.kok@ex-mente.co.za' __status__ = 'Planning' if __name__ == '__main__': unittest.main()
christoffkok/auxi.0
src/tests.py
Python
lgpl-3.0
2,865
0.000349
import itertools import json import re import flask from flask import request from web.cache import cache import rethinkdb as r import web.api.api_util as api_util import db import util api = flask.Blueprint("api", __name__, url_prefix="/api") r_conn = db.util.r_conn def _should_skip_get_plugins_cache(): """Whether the current request to /api/plugins should not be cached.""" page = int(request.args.get('page', 1)) search = request.args.get('query', '') # Only cache empty searches for now. # TODO(david): Also cache simple category and tag searches. May also want # to actually use a proper cache backend like Redis so we can # arbitrarily cache (right now we use an in-memory cache). should_cache = search == '' and (1 <= page <= 10) return not should_cache def _make_get_plugins_cache_key(): """Get a cache key for the /api/plugins route. By default this is just request.path which ignores query params. """ page = int(request.args.get('page', 1)) search = request.args.get('query', '') return '%s_%s_%s' % (request.path, page, search) # TODO(david): Consider saving categories just as special tags. Would make # search implementation simpler but determining which category a plugin # belongs to harder. See discussion on # http://phabricator.benalpert.com/D171 def _apply_category_filters(results, tokens): """Consumes and applies category filters (e.g. "cat:other") to results. Arguments: results: List of search result plugins. tokens: Remaining search text tokens that have not been consumed. Returns: (results, tokens): Results that match the given category, and tokens that have not been consumed. """ category_filter = lambda t: t.startswith('cat:') category_tokens = filter(category_filter, tokens) tokens = list(itertools.ifilterfalse(category_filter, tokens)) if category_tokens: category_ids = set(t[len('cat:'):] for t in category_tokens) results = filter(lambda plugin: plugin['category'] in category_ids, results) return results, tokens def _apply_tag_filters(results, tokens): """Consumes and applies tag filters (e.g. "tag:python") to search results. Arguments: results: List of search result plugins. tokens: Remaining search text tokens that have not been consumed. Returns: (results, tokens): Results that match the given tag, and tokens that have not been consumed. """ tag_filter = lambda t: t.startswith('tag:') tag_tokens = filter(tag_filter, tokens) tokens = list(itertools.ifilterfalse(tag_filter, tokens)) if tag_tokens: required_tags = set(t[len('tag:'):] for t in tag_tokens) results = filter(lambda plugin: required_tags <= set(plugin['tags']), results) return results, tokens def _apply_keyword_filters(results, tokens): """Filters results that match the given keywords (tokens). Arguments: results: List of search result plugins. tokens: Keywords to filter results on. Returns: List of plugins that match the given keywords. """ if tokens: # Create a regex that matches a string S iff for each keyword K in # `search` there is a corresponding word in S that begins with K. tokens_regex = (r'\b%s' % re.escape(t) for t in tokens) search_regex = re.compile('.*'.join(tokens_regex)) # Surprisingly, regex matching like this is slightly faster than # prefix-matching two sorted lists of tokens. results = filter(lambda plugin: search_regex.search(plugin['keywords']), results) return results @api.route('/plugins', methods=['GET']) @cache.cached(timeout=60 * 60 * 25, key_prefix=_make_get_plugins_cache_key, unless=_should_skip_get_plugins_cache) def get_plugins(): RESULTS_PER_PAGE = 20 page = int(request.args.get('page', 1)) search = request.args.get('query', '') results = get_search_index_cached() if search: tokens = [t.lower() for t in sorted(search.split())] results, tokens = _apply_category_filters(results, tokens) results, tokens = _apply_tag_filters(results, tokens) results = _apply_keyword_filters(results, tokens) count = len(results) total_pages = (count + RESULTS_PER_PAGE - 1) / RESULTS_PER_PAGE # ceil results = results[((page - 1) * RESULTS_PER_PAGE): (page * RESULTS_PER_PAGE)] return api_util.jsonify({ 'plugins': results, 'total_pages': total_pages, 'total_results': count, 'results_per_page': RESULTS_PER_PAGE, }) @api.route('/plugins/<slug>', methods=['GET']) def get_plugin(slug): plugin = r.table('plugins').get(slug).run(r_conn()) if plugin: return api_util.jsonify(db.plugins.to_json(plugin)) else: return api_util.api_not_found('No plugin with slug %s' % slug) # TODO(david): Make it not so easy for an attacker to completely obliterate all # of our tags, or at least be able to recover from it. @api.route('/plugins/<slug>/tags', methods=['POST', 'PUT']) def update_plugin_tags(slug): data = json.loads(flask.request.data) plugin = r.table('plugins').get(slug).run(r_conn()) if not plugin: return api_util.api_not_found('No plugin with slug %s' % slug) db.plugins.update_tags(plugin, data['tags']) r.table('plugins').update(plugin).run(r_conn()) return api_util.jsonify({ 'tags': plugin['tags'] }) @api.route('/tags', methods=['GET']) @cache.cached(timeout=60 * 60) def get_tags(): tags = r.table('tags').filter({}).run(r_conn()) return api_util.jsonify(list(tags)) @api.route('/categories', methods=['GET']) @cache.cached(timeout=60 * 60) def get_categories(): return api_util.jsonify(get_all_categories_cached()) @api.route('/plugins/<slug>/category/<category>', methods=['PUT']) def update_plugin_category(slug, category): plugin = r.table('plugins').get(slug).run(r_conn()) if not plugin: return api_util.api_not_found('No plugin with slug %s' % slug) if category not in (c['id'] for c in get_all_categories_cached()): return api_util.api_bad_request('No such category %s' % category) # TODO(david): Also update search index (stale cache) plugin['category'] = category r.table('plugins').update(plugin).run(r_conn()) return api_util.jsonify({ 'category': plugin['category'] }) @api.route('/submit', methods=['POST']) def submit_plugin(): plugin_data = flask.request.form.to_dict() plugin_data['tags'] = json.loads(plugin_data['tags']) db.submitted_plugins.insert(plugin_data) plugin_markdown = "```\n%s\n```" % json.dumps(plugin_data, indent=4) util.log_to_gitter("Someone just submitted a plugin!\n%s" % plugin_markdown) return flask.redirect('/thanks-for-submitting') @cache.cached(timeout=60 * 60 * 26, key_prefix='search_index') def get_search_index_cached(): return db.plugins.get_search_index() @cache.cached(timeout=60 * 60 * 27, key_prefix='all_categories') def get_all_categories_cached(): return db.categories.get_all()
vim-awesome/vim-awesome
web/api/api.py
Python
mit
7,261
0.001102
#!/usr/bin/env python # Copyright (c) 2012 The Native Client Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Makes sure that files include headers from allowed directories. Checks DEPS files in the source tree for rules, and applies those rules to "#include" commands in source files. Any source file including something not permitted by the DEPS files will fail. The format of the deps file: First you have the normal module-level deps. These are the ones used by gclient. An example would be: deps = { "base":"http://foo.bar/trunk/base" } DEPS files not in the top-level of a module won't need this. Then you have any additional include rules. You can add (using "+") or subtract (using "-") from the previously specified rules (including module-level deps). include_rules = { # Code should be able to use base (it's specified in the module-level # deps above), but nothing in "base/evil" because it's evil. "-base/evil", # But this one subdirectory of evil is OK. "+base/evil/not", # And it can include files from this other directory even though there is # no deps rule for it. "+tools/crime_fighter" } DEPS files may be placed anywhere in the tree. Each one applies to all subdirectories, where there may be more DEPS files that provide additions or subtractions for their own sub-trees. There is an implicit rule for the current directory (where the DEPS file lives) and all of its subdirectories. This prevents you from having to explicitly allow the current directory everywhere. This implicit rule is applied first, so you can modify or remove it using the normal include rules. The rules are processed in order. This means you can explicitly allow a higher directory and then take away permissions from sub-parts, or the reverse. Note that all directory separators must be slashes (Unix-style) and not backslashes. All directories should be relative to the source root and use only lowercase. """ from __future__ import print_function import os import optparse import pipes import re import sys import copy # Variable name used in the DEPS file to add or subtract include files from # the module-level deps. INCLUDE_RULES_VAR_NAME = "include_rules" # Optionally present in the DEPS file to list subdirectories which should not # be checked. This allows us to skip third party code, for example. SKIP_SUBDIRS_VAR_NAME = "skip_child_includes" # The maximum number of non-include lines we can see before giving up. MAX_UNINTERESTING_LINES = 50 # The maximum line length, this is to be efficient in the case of very long # lines (which can't be #includes). MAX_LINE_LENGTH = 128 # Set to true for more output. This is set by the command line options. VERBOSE = False # This regular expression will be used to extract filenames from include # statements. EXTRACT_INCLUDE_PATH = re.compile('[ \t]*#[ \t]*(?:include|import)[ \t]+"(.*)"') # In lowercase, using forward slashes as directory separators, ending in a # forward slash. Set by the command line options. BASE_DIRECTORY = "" # The directories which contain the sources managed by git. GIT_SOURCE_DIRECTORY = set() # Specifies a single rule for an include, which can be either allow or disallow. class Rule(object): def __init__(self, allow, dir, source): self._allow = allow self._dir = dir self._source = source def __str__(self): if (self._allow): return '"+%s" from %s.' % (self._dir, self._source) return '"-%s" from %s.' % (self._dir, self._source) def ParentOrMatch(self, other): """Returns true if the input string is an exact match or is a parent of the current rule. For example, the input "foo" would match "foo/bar".""" return self._dir == other or self._dir.startswith(other + "/") def ChildOrMatch(self, other): """Returns true if the input string would be covered by this rule. For example, the input "foo/bar" would match the rule "foo".""" return self._dir == other or other.startswith(self._dir + "/") def ParseRuleString(rule_string, source): """Returns a tuple of a boolean indicating whether the directory is an allow rule, and a string holding the directory name. """ if len(rule_string) < 1: raise Exception('The rule string "%s" is too short\nin %s' % (rule_string, source)) if rule_string[0] == "+": return (True, rule_string[1:]) if rule_string[0] == "-": return (False, rule_string[1:]) raise Exception('The rule string "%s" does not begin with a "+" or a "-"' % rule_string) class Rules: def __init__(self): """Initializes the current rules with an empty rule list.""" self._rules = [] def __str__(self): ret = "Rules = [\n" ret += "\n".join([" %s" % x for x in self._rules]) ret += "]\n" return ret def AddRule(self, rule_string, source): """Adds a rule for the given rule string. Args: rule_string: The include_rule string read from the DEPS file to apply. source: A string representing the location of that string (filename, etc.) so that we can give meaningful errors. """ (add_rule, rule_dir) = ParseRuleString(rule_string, source) # Remove any existing rules or sub-rules that apply. For example, if we're # passed "foo", we should remove "foo", "foo/bar", but not "foobar". self._rules = [x for x in self._rules if not x.ParentOrMatch(rule_dir)] self._rules.insert(0, Rule(add_rule, rule_dir, source)) def DirAllowed(self, allowed_dir): """Returns a tuple (success, message), where success indicates if the given directory is allowed given the current set of rules, and the message tells why if the comparison failed.""" for rule in self._rules: if rule.ChildOrMatch(allowed_dir): # This rule applies. if rule._allow: return (True, "") return (False, rule.__str__()) # No rules apply, fail. return (False, "no rule applying") def ApplyRules(existing_rules, includes, cur_dir): """Applies the given include rules, returning the new rules. Args: existing_rules: A set of existing rules that will be combined. include: The list of rules from the "include_rules" section of DEPS. cur_dir: The current directory. We will create an implicit rule that allows inclusion from this directory. Returns: A new set of rules combining the existing_rules with the other arguments. """ rules = copy.copy(existing_rules) # First apply the implicit "allow" rule for the current directory. if cur_dir.lower().startswith(BASE_DIRECTORY): relative_dir = cur_dir[len(BASE_DIRECTORY) + 1:] # Normalize path separators to slashes. relative_dir = relative_dir.replace("\\", "/") source = relative_dir if len(source) == 0: source = "top level" # Make the help string a little more meaningful. rules.AddRule("+" + relative_dir, "Default rule for " + source) else: raise Exception("Internal error: base directory is not at the beginning" + " for\n %s and base dir\n %s" % (cur_dir, BASE_DIRECTORY)) # Last, apply the additional explicit rules. for (index, rule_str) in enumerate(includes): if not len(relative_dir): rule_description = "the top level include_rules" else: rule_description = relative_dir + "'s include_rules" rules.AddRule(rule_str, rule_description) return rules def ApplyDirectoryRules(existing_rules, dir_name): """Combines rules from the existing rules and the new directory. Any directory can contain a DEPS file. Toplevel DEPS files can contain module dependencies which are used by gclient. We use these, along with additional include rules and implicit rules for the given directory, to come up with a combined set of rules to apply for the directory. Args: existing_rules: The rules for the parent directory. We'll add-on to these. dir_name: The directory name that the deps file may live in (if it exists). This will also be used to generate the implicit rules. Returns: A tuple containing: (1) the combined set of rules to apply to the sub-tree, and (2) a list of all subdirectories that should NOT be checked, as specified in the DEPS file (if any). """ # Check for a .svn directory in this directory or check this directory is # contained in git source direcotries. This will tell us if it's a source # directory and should be checked. if not (os.path.exists(os.path.join(dir_name, ".svn")) or (dir_name.lower() in GIT_SOURCE_DIRECTORY)): return (None, []) # Check the DEPS file in this directory. if VERBOSE: print("Applying rules from", dir_name) def FromImpl(unused, unused2): pass # NOP function so "From" doesn't fail. def FileImpl(unused): pass # NOP function so "File" doesn't fail. class _VarImpl: def __init__(self, local_scope): self._local_scope = local_scope def Lookup(self, var_name): """Implements the Var syntax.""" if var_name in self._local_scope.get("vars", {}): return self._local_scope["vars"][var_name] raise Error("Var is not defined: %s" % var_name) local_scope = {} global_scope = { "File": FileImpl, "From": FromImpl, "Var": _VarImpl(local_scope).Lookup, } deps_file = os.path.join(dir_name, "DEPS") if os.path.isfile(deps_file): execfile(deps_file, global_scope, local_scope) elif VERBOSE: print(" No deps file found in", dir_name) # Even if a DEPS file does not exist we still invoke ApplyRules # to apply the implicit "allow" rule for the current directory include_rules = local_scope.get(INCLUDE_RULES_VAR_NAME, []) skip_subdirs = local_scope.get(SKIP_SUBDIRS_VAR_NAME, []) return (ApplyRules(existing_rules, include_rules, dir_name), skip_subdirs) def ShouldCheckFile(file_name): """Returns True if the given file is a type we want to check.""" checked_extensions = [ '.c', '.cc', '.h', '.m', '.mm', # These are not the preferred extension in our codebase, # but including them for good measure. # (They do appear in the newlib toolchain + third_party libraries). '.cpp', '.hpp', ] basename, extension = os.path.splitext(file_name) return extension in checked_extensions def CheckLine(rules, line): """Checks the given file with the given rule set. Returns a tuple (is_include, illegal_description). If the line is an #include directive the first value will be True. If it is also an illegal include, the second value will be a string describing the error. Otherwise, it will be None.""" found_item = EXTRACT_INCLUDE_PATH.match(line) if not found_item: return False, None # Not a match include_path = found_item.group(1) # Fix up backslashes in case somebody accidentally used them. include_path.replace("\\", "/") if include_path.find("/") < 0: # Don't fail when no directory is specified. We may want to be more # strict about this in the future. if VERBOSE: print(" WARNING: directory specified with no path: " + include_path) return True, None (allowed, why_failed) = rules.DirAllowed(include_path) if not allowed: if VERBOSE: retval = "\nFor " + rules.__str__() else: retval = "" return True, retval + ('Illegal include: "%s"\n Because of %s' % (include_path, why_failed)) return True, None def CheckFile(rules, file_name): """Checks the given file with the given rule set. Args: rules: The set of rules that apply to files in this directory. file_name: The source file to check. Returns: Either a string describing the error if there was one, or None if the file checked out OK. """ if VERBOSE: print("Checking: " + file_name) ret_val = "" # We'll collect the error messages in here last_include = 0 try: cur_file = open(file_name, "r") in_if0 = 0 for line_num in xrange(sys.maxint): if line_num - last_include > MAX_UNINTERESTING_LINES: break cur_line = cur_file.readline(MAX_LINE_LENGTH) if cur_line == "": break cur_line = cur_line.strip() # Check to see if we're at / inside a #if 0 block if cur_line == '#if 0': in_if0 += 1 continue if in_if0 > 0: if cur_line.startswith('#if'): in_if0 += 1 elif cur_line == '#endif': in_if0 -= 1 continue is_include, line_status = CheckLine(rules, cur_line) if is_include: last_include = line_num if line_status is not None: if len(line_status) > 0: # Add newline to separate messages. line_status += "\n" ret_val += line_status cur_file.close() except IOError: if VERBOSE: print("Unable to open file: " + file_name) cur_file.close() # Map empty string to None for easier checking. if len(ret_val) == 0: return None return ret_val def CheckDirectory(parent_rules, dir_name): (rules, skip_subdirs) = ApplyDirectoryRules(parent_rules, dir_name) if rules == None: return True # Collect a list of all files and directories to check. files_to_check = [] dirs_to_check = [] success = True contents = os.listdir(dir_name) for cur in contents: if cur in skip_subdirs: continue # Don't check children that DEPS has asked us to skip. full_name = os.path.join(dir_name, cur) if os.path.isdir(full_name): dirs_to_check.append(full_name) elif ShouldCheckFile(full_name): files_to_check.append(full_name) # First check all files in this directory. for cur in files_to_check: file_status = CheckFile(rules, cur) if file_status != None: print("ERROR in " + cur + "\n" + file_status) success = False # Next recurse into the subdirectories. for cur in dirs_to_check: if not CheckDirectory(rules, cur): success = False return success def GetGitSourceDirectory(root): """Returns a set of the directories to be checked. Args: root: The repository root where .git directory exists. Returns: A set of directories which contain sources managed by git. """ git_source_directory = set() popen_out = os.popen("cd %s && git ls-files --full-name ." % pipes.quote(root)) for line in popen_out.readlines(): dir_name = os.path.join(root, os.path.dirname(line)) # Add the directory as well as all the parent directories. while dir_name != root: git_source_directory.add(dir_name) dir_name = os.path.dirname(dir_name) git_source_directory.add(root) return git_source_directory def PrintUsage(): print("""Usage: python checkdeps.py [--root <root>] [tocheck] --root Specifies the repository root. This defaults to "../../.." relative to the script file. This will be correct given the normal location of the script in "<root>/tools/checkdeps". tocheck Specifies the directory, relative to root, to check. This defaults to "." so it checks everything. Only one level deep is currently supported, so you can say "chrome" but not "chrome/browser". Examples: python checkdeps.py python checkdeps.py --root c:\\source chrome""") def checkdeps(options, args): global VERBOSE if options.verbose: VERBOSE = True # Optional base directory of the repository. global BASE_DIRECTORY if not options.base_directory: BASE_DIRECTORY = os.path.abspath( os.path.join(os.path.abspath(os.path.dirname(__file__)), "../..")) else: BASE_DIRECTORY = os.path.abspath(options.base_directory) # Figure out which directory we have to check. if len(args) == 0: # No directory to check specified, use the repository root. start_dir = BASE_DIRECTORY elif len(args) == 1: # Directory specified. Start here. It's supposed to be relative to the # base directory. start_dir = os.path.abspath(os.path.join(BASE_DIRECTORY, args[0])) else: # More than one argument, we don't handle this. PrintUsage() return 1 print("Using base directory:", BASE_DIRECTORY) print("Checking:", start_dir) base_rules = Rules() # The base directory should be lower case from here on since it will be used # for substring matching on the includes, and we compile on case-insensitive # systems. Plus, we always use slashes here since the include parsing code # will also normalize to slashes. BASE_DIRECTORY = BASE_DIRECTORY.lower() BASE_DIRECTORY = BASE_DIRECTORY.replace("\\", "/") start_dir = start_dir.replace("\\", "/") if os.path.exists(os.path.join(BASE_DIRECTORY, ".git")): global GIT_SOURCE_DIRECTORY GIT_SOURCE_DIRECTORY = GetGitSourceDirectory(BASE_DIRECTORY) success = CheckDirectory(base_rules, start_dir) if not success: print("\nFAILED\n") return 1 print("\nSUCCESS\n") return 0 def main(): option_parser = optparse.OptionParser() option_parser.add_option("", "--root", default="", dest="base_directory", help='Specifies the repository root. This defaults ' 'to "../../.." relative to the script file, which ' 'will normally be the repository root.') option_parser.add_option("-v", "--verbose", action="store_true", default=False, help="Print debug logging") options, args = option_parser.parse_args() return checkdeps(options, args) if '__main__' == __name__: sys.exit(main())
endlessm/chromium-browser
native_client/tools/checkdeps/checkdeps.py
Python
bsd-3-clause
17,715
0.008863
from typing import Optional from gear.cloud_config import get_azure_config, get_gcp_config, get_global_config from hailtop.aiocloud import aioazure, aiogoogle from hailtop.aiotools.fs import AsyncFS, AsyncFSFactory def get_identity_client(credentials_file: Optional[str] = None): if credentials_file is None: credentials_file = '/gsa-key/key.json' cloud = get_global_config()['cloud'] if cloud == 'azure': scopes = ['https://graph.microsoft.com/.default'] return aioazure.AzureGraphClient( credentials_file=credentials_file, scopes=scopes, ) assert cloud == 'gcp', cloud project = get_gcp_config().project return aiogoogle.GoogleIAmClient(project, credentials_file=credentials_file) def get_compute_client(credentials_file: Optional[str] = None): if credentials_file is None: credentials_file = '/gsa-key/key.json' cloud = get_global_config()['cloud'] if cloud == 'azure': azure_config = get_azure_config() return aioazure.AzureComputeClient(azure_config.subscription_id, azure_config.resource_group) assert cloud == 'gcp', cloud project = get_gcp_config().project return aiogoogle.GoogleComputeClient(project, credentials_file=credentials_file) def get_cloud_async_fs(credentials_file: Optional[str] = None) -> AsyncFS: if credentials_file is None: credentials_file = '/gsa-key/key.json' cloud = get_global_config()['cloud'] if cloud == 'azure': return aioazure.AzureAsyncFS(credential_file=credentials_file) assert cloud == 'gcp', cloud return aiogoogle.GoogleStorageAsyncFS(credentials_file=credentials_file) def get_cloud_async_fs_factory() -> AsyncFSFactory: cloud = get_global_config()['cloud'] if cloud == 'azure': return aioazure.AzureAsyncFSFactory() assert cloud == 'gcp', cloud return aiogoogle.GoogleStorageAsyncFSFactory()
hail-is/hail
gear/gear/clients.py
Python
mit
1,942
0.00206
# This file is part of the sos project: https://github.com/sosreport/sos # # This copyrighted material is made available to anyone wishing to use, # modify, copy, or redistribute it subject to the terms and conditions of # version 2 of the GNU General Public License. # # See the LICENSE file in the source distribution for further information. from sos.plugins import Plugin, RedHatPlugin, DebianPlugin, UbuntuPlugin class Dbus(Plugin, RedHatPlugin, DebianPlugin, UbuntuPlugin): """D-Bus message bus""" plugin_name = "dbus" profiles = ('system',) packages = ('dbus',) def setup(self): self.add_copy_spec([ "/etc/dbus-1", "/var/lib/dbus/machine-id" ]) # vim: set et ts=4 sw=4 :
nijinashok/sos
sos/plugins/dbus.py
Python
gpl-2.0
745
0
# Copyright (c) 2012 Citrix Systems, 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. """The Aggregate admin API extension.""" import datetime from webob import exc from nova.api.openstack import extensions from nova.compute import api as compute_api from nova import exception from nova.openstack.common.gettextutils import _ from nova.openstack.common import log as logging from nova import utils LOG = logging.getLogger(__name__) authorize = extensions.extension_authorizer('compute', 'aggregates') def _get_context(req): return req.environ['nova.context'] def get_host_from_body(fn): """Makes sure that the host exists.""" def wrapped(self, req, id, body, *args, **kwargs): if len(body) == 1 and "host" in body: host = body['host'] else: raise exc.HTTPBadRequest() return fn(self, req, id, host, *args, **kwargs) return wrapped class AggregateController(object): """The Host Aggregates API controller for the OpenStack API.""" def __init__(self): self.api = compute_api.AggregateAPI() def index(self, req): """Returns a list a host aggregate's id, name, availability_zone.""" context = _get_context(req) authorize(context) aggregates = self.api.get_aggregate_list(context) return {'aggregates': [self._marshall_aggregate(a)['aggregate'] for a in aggregates]} def create(self, req, body): """Creates an aggregate, given its name and availability_zone.""" context = _get_context(req) authorize(context) if len(body) != 1: raise exc.HTTPBadRequest() try: host_aggregate = body["aggregate"] name = host_aggregate["name"] avail_zone = host_aggregate["availability_zone"] except KeyError: raise exc.HTTPBadRequest() try: utils.check_string_length(name, "Aggregate name", 1, 255) except exception.InvalidInput as e: raise exc.HTTPBadRequest(explanation=e.format_message()) if len(host_aggregate) != 2: raise exc.HTTPBadRequest() try: aggregate = self.api.create_aggregate(context, name, avail_zone) except exception.AggregateNameExists as e: LOG.info(e) raise exc.HTTPConflict() except exception.InvalidAggregateAction as e: LOG.info(e) raise return self._marshall_aggregate(aggregate) def show(self, req, id): """Shows the details of an aggregate, hosts and metadata included.""" context = _get_context(req) authorize(context) try: aggregate = self.api.get_aggregate(context, id) except exception.AggregateNotFound: LOG.info(_("Cannot show aggregate: %s"), id) raise exc.HTTPNotFound() return self._marshall_aggregate(aggregate) def update(self, req, id, body): """Updates the name and/or availability_zone of given aggregate.""" context = _get_context(req) authorize(context) if len(body) != 1: raise exc.HTTPBadRequest() try: updates = body["aggregate"] except KeyError: raise exc.HTTPBadRequest() if len(updates) < 1: raise exc.HTTPBadRequest() for key in updates.keys(): if key not in ["name", "availability_zone"]: raise exc.HTTPBadRequest() if 'name' in updates: try: utils.check_string_length(updates['name'], "Aggregate name", 1, 255) except exception.InvalidInput as e: raise exc.HTTPBadRequest(explanation=e.format_message()) try: aggregate = self.api.update_aggregate(context, id, updates) except exception.AggregateNotFound: LOG.info(_('Cannot update aggregate: %s'), id) raise exc.HTTPNotFound() return self._marshall_aggregate(aggregate) def delete(self, req, id): """Removes an aggregate by id.""" context = _get_context(req) authorize(context) try: self.api.delete_aggregate(context, id) except exception.AggregateNotFound: LOG.info(_('Cannot delete aggregate: %s'), id) raise exc.HTTPNotFound() def action(self, req, id, body): _actions = { 'add_host': self._add_host, 'remove_host': self._remove_host, 'set_metadata': self._set_metadata, } for action, data in body.iteritems(): if action not in _actions.keys(): msg = _('Aggregates does not have %s action') % action raise exc.HTTPBadRequest(explanation=msg) return _actions[action](req, id, data) raise exc.HTTPBadRequest(explanation=_("Invalid request body")) @get_host_from_body def _add_host(self, req, id, host): """Adds a host to the specified aggregate.""" context = _get_context(req) authorize(context) try: aggregate = self.api.add_host_to_aggregate(context, id, host) except (exception.AggregateNotFound, exception.ComputeHostNotFound): LOG.info(_('Cannot add host %(host)s in aggregate %(id)s'), {'host': host, 'id': id}) raise exc.HTTPNotFound() except (exception.AggregateHostExists, exception.InvalidAggregateAction) as e: LOG.info(_('Cannot add host %(host)s in aggregate %(id)s'), {'host': host, 'id': id}) raise exc.HTTPConflict(explanation=e.format_message()) return self._marshall_aggregate(aggregate) @get_host_from_body def _remove_host(self, req, id, host): """Removes a host from the specified aggregate.""" context = _get_context(req) authorize(context) try: aggregate = self.api.remove_host_from_aggregate(context, id, host) except (exception.AggregateNotFound, exception.AggregateHostNotFound, exception.ComputeHostNotFound): LOG.info(_('Cannot remove host %(host)s in aggregate %(id)s'), {'host': host, 'id': id}) raise exc.HTTPNotFound() except exception.InvalidAggregateAction: LOG.info(_('Cannot remove host %(host)s in aggregate %(id)s'), {'host': host, 'id': id}) raise exc.HTTPConflict() return self._marshall_aggregate(aggregate) def _set_metadata(self, req, id, body): """Replaces the aggregate's existing metadata with new metadata.""" context = _get_context(req) authorize(context) if len(body) != 1: raise exc.HTTPBadRequest() try: metadata = body["metadata"] except KeyError: raise exc.HTTPBadRequest() try: aggregate = self.api.update_aggregate_metadata(context, id, metadata) except exception.AggregateNotFound: LOG.info(_('Cannot set metadata %(metadata)s in aggregate %(id)s'), {'metadata': metadata, 'id': id}) raise exc.HTTPNotFound() return self._marshall_aggregate(aggregate) def _marshall_aggregate(self, aggregate): _aggregate = {} for key, value in aggregate.items(): # NOTE(danms): The original API specified non-TZ-aware timestamps if isinstance(value, datetime.datetime): value = value.replace(tzinfo=None) _aggregate[key] = value return {"aggregate": _aggregate} class Aggregates(extensions.ExtensionDescriptor): """Admin-only aggregate administration.""" name = "Aggregates" alias = "os-aggregates" namespace = "http://docs.openstack.org/compute/ext/aggregates/api/v1.1" updated = "2012-01-12T00:00:00+00:00" def __init__(self, ext_mgr): ext_mgr.register(self) def get_resources(self): resources = [] res = extensions.ResourceExtension('os-aggregates', AggregateController(), member_actions={"action": "POST", }) resources.append(res) return resources
ntt-sic/nova
nova/api/openstack/compute/contrib/aggregates.py
Python
apache-2.0
8,962
0.000112
# -*- coding: utf-8 -*- # Generated by Django 1.11.13 on 2018-07-02 11:40 from __future__ import unicode_literals from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('dashboard', '0022_query_amcat_options'), ] operations = [ migrations.AlterField( model_name='query', name='amcat_query_id', field=models.IntegerField(), ), migrations.AlterUniqueTogether( name='query', unique_together=set([('system', 'amcat_query_id')]), ), migrations.AlterModelTable( name='querycache', table=None, ), ]
amcat/amcat-dashboard
dashboard/migrations/0023_auto_20180702_1140.py
Python
agpl-3.0
696
0
""" __MT_post__indirectLink_S.py_____________________________________________________ Automatically generated AToM3 syntactic object (DO NOT MODIFY DIRECTLY) Author: levi Modified: Sun Aug 9 23:46:05 2015 _________________________________________________________________________________ """ from ASGNode import * from ATOM3Type import * from ATOM3String import * from graph_MT_post__indirectLink_S import * class MT_post__indirectLink_S(ASGNode, ATOM3Type): def __init__(self, parent = None): ASGNode.__init__(self) ATOM3Type.__init__(self) self.superTypes = [] self.graphClass_ = graph_MT_post__indirectLink_S self.isGraphObjectVisual = True if(hasattr(self, '_setHierarchicalLink')): self._setHierarchicalLink(False) if(hasattr(self, '_setHierarchicalNode')): self._setHierarchicalNode(False) self.parent = parent self.MT_label__=ATOM3String('', 20) self.MT_pivotOut__=ATOM3String('', 20) self.generatedAttributes = {'MT_label__': ('ATOM3String', ), 'MT_pivotOut__': ('ATOM3String', ) } self.realOrder = ['MT_label__','MT_pivotOut__'] self.directEditing = [1,1] def clone(self): cloneObject = MT_post__indirectLink_S( self.parent ) for atr in self.realOrder: cloneObject.setAttrValue(atr, self.getAttrValue(atr).clone() ) ASGNode.cloneActions(self, cloneObject) return cloneObject def copy(self, other): ATOM3Type.copy(self, other) for atr in self.realOrder: self.setAttrValue(atr, other.getAttrValue(atr) ) ASGNode.copy(self, other) def preCondition (self, actionID, * params): if self.graphObject_: return self.graphObject_.preCondition(actionID, params) else: return None def postCondition (self, actionID, * params): if self.graphObject_: return self.graphObject_.postCondition(actionID, params) else: return None def preAction (self, actionID, * params): if actionID == self.CREATE: self.autoIncrLabel(params) if self.graphObject_: return self.graphObject_.preAction(actionID, params) else: return None def postAction (self, actionID, * params): if self.graphObject_: return self.graphObject_.postAction(actionID, params) else: return None def QOCA(self, params): """ QOCA Constraint Template NOTE: DO NOT select a POST/PRE action trigger Constraints will be added/removed in a logical manner by other mechanisms. """ return # <--- Remove this if you want to use QOCA # Get the high level constraint helper and solver from Qoca.atom3constraints.OffsetConstraints import OffsetConstraints oc = OffsetConstraints(self.parent.qocaSolver) # Constraint only makes sense if there exists 2 objects connected to this link if(not (self.in_connections_ and self.out_connections_)): return # Get the graphical objects (subclass of graphEntity/graphLink) graphicalObjectLink = self.graphObject_ graphicalObjectSource = self.in_connections_[0].graphObject_ graphicalObjectTarget = self.out_connections_[0].graphObject_ objTuple = (graphicalObjectSource, graphicalObjectTarget, graphicalObjectLink) """ Example constraint, see Kernel/QOCA/atom3constraints/OffsetConstraints.py For more types of constraints """ oc.LeftExactDistance(objTuple, 20) oc.resolve() # Resolve immediately after creating entity & constraint def autoIncrLabel(self, params): #=============================================================================== # Auto increment the label #=============================================================================== # If there is already one, ignore if not self.MT_label__.isNone(): return # Get the maximum label of all MT_pre__ elements label = 0 for nt in self.parent.ASGroot.listNodes: if nt.startswith('MT_post__'): for node in self.parent.ASGroot.listNodes[nt]: currLabel = 0 try: currLabel = int(node.MT_label__.getValue()) except: pass if currLabel > label: label = currLabel # The label of this instance will be the max label + 1 self.MT_label__.setValue(str(label + 1))
levilucio/SyVOLT
GM2AUTOSAR_MM/MT_post__indirectLink_S.py
Python
mit
4,553
0.028992
#! /usr/bin/env python # # python script to generate a valid stepfile for WRF cycling # import sys import pandas import calendar filename = 'stepfile' # default filename lleap = True # allow leap days (not used in some GCM calendars) lecho = False lperiod = False dateargs = [] # list of date arguments passed to date_range for arg in sys.argv[1:]: if arg[:11] == '--interval=': freq = arg[11:].lower() # remains a string and is interpreted by date_range elif arg[:8] == '--steps=': lperiod = True; periods = int(arg[8:]) + 1 # each step is bounded by two timestamps elif arg == '-l' or arg == '--noleap': lleap = False # omit leap days to accomodate some GCM calendars elif arg == '-e' or arg == '--echo': lecho = True elif arg == '-h' or arg == '--help': print('') print("Usage: "+sys.argv[0]+" [-e] [-h] [--interval=interval] [--steps=steps] begin-date [end-date]") print(" Interval, begin-date and end-date or steps must be specified.") print("") print(" --interval= step spacing / interval (D=days, W=weeks, M=month)") print(" --steps= number of steps in stepfile") print(" -l | --noleap omit leap days (to accomodate some GCM calendars)") print(" -e | --echo print steps to stdout instead of writing to stepfile") print(" -h | --help print this message") print('') sys.exit(1) else: dateargs.append(arg) # output patterns lmonthly = False dateform = '%Y-%m-%d_%H:%M:%S' # N.B.: because pandas date_range always anchors intervals at the end of the month, we have to subtract one # day and add it again later, in order to re-anchor at the first of the month stepform = '%Y-%m-%d' offset = pandas.DateOffset() # no offset if 'w' in freq: oo = 1 if '-sun' in freq else 0 offset = pandas.DateOffset(days=pandas.to_datetime(dateargs[0]).dayofweek + oo) elif 'm' in freq: lmonthly = True stepform = '%Y-%m' offset = pandas.DateOffset(days=pandas.to_datetime(dateargs[0]).day) #print dateargs begindate = pandas.to_datetime(dateargs[0]) - offset # check input and generate datelist if lperiod: if len(dateargs) != 1: raise ValueError('Can only specify begin-date, if the number of periods is given.') datelist = pandas.date_range(begindate, periods=periods, freq=freq) # generate datelist else: if len(dateargs) != 2: raise ValueError('Specify begin-date and end-date, if no number of periods is given.') enddate = pandas.to_datetime(dateargs[1]) - offset datelist = pandas.date_range(begindate, enddate, freq=freq) # generate datelist # open file, if not writing to stdout if not lecho: stepfile = open(filename, mode='w') # iterate over dates (skip first) lastdate = datelist[0] + offset # first element llastleap = False for date in datelist[1:]: lcurrleap = False currentdate = date + offset # N.B.: offset is not the interval/frequency; it is an offset at the beginning of the month or week if lmonthly: mon = date.month +1 if mon == 2: maxdays = 29 if calendar.isleap(date.year) else 28 elif mon in [4, 6, 9, 11]: maxdays = 30 else: maxdays = 31 if currentdate > date + pandas.DateOffset(days=maxdays): currentdate = date + pandas.DateOffset(days=maxdays) # handle calendars without leap days (turn Feb. 29th into Mar. 1st) if not lleap and calendar.isleap(currentdate.year) and ( currentdate.month==2 and currentdate.day==29 ): lcurrleap = True currentdate += pandas.DateOffset(days=1) # move one day ahead # generate line for last step # print currentdate.month,currentdate.day if lleap or not (freq.lower()=='1d' and llastleap): # skip if this is daily output, a leap day, and a non-leap-year calendar... stepline = "{0:s} '{1:s}' '{2:s}'\n".format(lastdate.strftime(stepform),lastdate.strftime(dateform), currentdate.strftime(dateform)) # write to appropriate output if lecho: sys.stdout.write(stepline) else: stepfile.write(stepline) # remember last step lastdate = currentdate llastleap = lcurrleap # close file if not lecho: stepfile.close()
aerler/WRF-Tools
Python/wrfrun/generateStepfile.py
Python
gpl-3.0
4,142
0.021004
# # 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. # """Wrapper of Beam runners that's built for running and verifying e2e tests.""" from __future__ import absolute_import from __future__ import print_function import logging import time from apache_beam.internal import pickler from apache_beam.options.pipeline_options import GoogleCloudOptions from apache_beam.options.pipeline_options import StandardOptions from apache_beam.options.pipeline_options import TestOptions from apache_beam.runners.dataflow.dataflow_runner import DataflowRunner from apache_beam.runners.runner import PipelineState __all__ = ['TestDataflowRunner'] # Dataflow take up to 10mins for the long tail of starting/stopping worker # pool. WAIT_IN_STATE_TIMEOUT = 10 * 60 _LOGGER = logging.getLogger(__name__) class TestDataflowRunner(DataflowRunner): def run_pipeline(self, pipeline, options): """Execute test pipeline and verify test matcher""" test_options = options.view_as(TestOptions) on_success_matcher = test_options.on_success_matcher wait_duration = test_options.wait_until_finish_duration is_streaming = options.view_as(StandardOptions).streaming # [BEAM-1889] Do not send this to remote workers also, there is no need to # send this option to remote executors. test_options.on_success_matcher = None self.result = super(TestDataflowRunner, self).run_pipeline( pipeline, options) if self.result.has_job: # TODO(markflyhigh)(BEAM-1890): Use print since Nose dosen't show logs # in some cases. print('Worker logs: %s' % self.build_console_url(options)) try: self.wait_until_in_state(PipelineState.RUNNING) if is_streaming and not wait_duration: _LOGGER.warning('Waiting indefinitely for streaming job.') self.result.wait_until_finish(duration=wait_duration) if on_success_matcher: from hamcrest import assert_that as hc_assert_that hc_assert_that(self.result, pickler.loads(on_success_matcher)) finally: if not self.result.is_in_terminal_state(): self.result.cancel() self.wait_until_in_state(PipelineState.CANCELLED) return self.result def build_console_url(self, options): """Build a console url of Dataflow job.""" project = options.view_as(GoogleCloudOptions).project region_id = options.view_as(GoogleCloudOptions).region job_id = self.result.job_id() return ( 'https://console.cloud.google.com/dataflow/jobsDetail/locations' '/%s/jobs/%s?project=%s' % (region_id, job_id, project)) def wait_until_in_state(self, expected_state, timeout=WAIT_IN_STATE_TIMEOUT): """Wait until Dataflow pipeline enters a certain state.""" if not self.result.has_job: raise IOError('Failed to get the Dataflow job id.') start_time = time.time() while time.time() - start_time <= timeout: job_state = self.result.state if self.result.is_in_terminal_state() or job_state == expected_state: return job_state time.sleep(5) raise RuntimeError('Timeout after %d seconds while waiting for job %s ' 'enters expected state %s. Current state is %s.' % (timeout, self.result.job_id(), expected_state, self.result.state))
RyanSkraba/beam
sdks/python/apache_beam/runners/dataflow/test_dataflow_runner.py
Python
apache-2.0
4,039
0.003714
from os import path from django.contrib.auth.models import User from django.test import TestCase from django.urls import reverse from files.models import CaptionedFile fixture_dir = path.join(path.abspath(path.dirname(__file__)), 'fixtures') class CaptionedFileTestCase(TestCase): def setUp(self): self.captioned_file = CaptionedFile.objects.create( caption="this is a file", publication=path.join('pubtest.txt') ) self.captioned_file.save() def test_creation(self): cf = CaptionedFile.objects.create( caption="lo lo", publication=path.join('pubtest.txt') ) cf.save() self.assertEqual(CaptionedFile.objects.count(), 2) # Cause setup created one already def test_update(self): self.captioned_file.caption = "I like text files" self.captioned_file.save() cf = CaptionedFile.objects.get() self.assertEqual(cf.caption, "I like text files") def test_delete(self): cf = CaptionedFile.objects.get() cf.delete() self.assertEqual(CaptionedFile.objects.count(), 0) class MultiEncodedAdminFormTest(TestCase): def setUp(self): self.user = User( username='admin', is_staff=True, is_superuser=True) self.user.set_password('admin') self.user.save() self.create_url = reverse('admin2:example3_captioned_file_create')
pydanny/django-admin2
example/files/tests/test_models.py
Python
bsd-3-clause
1,470
0
#!/usr/bin/env python # -*- coding: utf-8 -*- # # mainnav-reader - Version: 0.5.1 # # Copyright (c) 2009-2013, Dennis Keitzel # 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. # import sys from distutils.core import setup from mainnav_reader.helper import check_requirements if sys.argv[1] == 'install': check_requirements() setup( name='mainnav-reader', version='0.5.1', author='Dennis Keitzel', author_email='dennis.keitzel@arcor.de', url='http://code.google.com/p/mainnav-reader/', description='This little tool has the ability to read out and delete tracklog data from mainnav gps devices', license='BSD', packages=['mainnav_reader'], scripts=['mainnav-reader'], )
pbabik/mainnav-reader
setup.py
Python
bsd-2-clause
1,980
0.002525
from core.himesis import Himesis, HimesisPreConditionPatternLHS import uuid class HUnitConnectCAG_ConnectedLHS(HimesisPreConditionPatternLHS): def __init__(self): """ Creates the himesis graph representing the AToM3 model HUnitConnectCAG_ConnectedLHS """ # Flag this instance as compiled now self.is_compiled = True super(HUnitConnectCAG_ConnectedLHS, self).__init__(name='HUnitConnectCAG_ConnectedLHS', num_nodes=0, edges=[]) # Add the edges self.add_edges([]) # Set the graph attributes self["mm__"] = ['MT_pre__FamiliesToPersonsMM', 'MoTifRule'] self["MT_constraint__"] = """return True""" self["name"] = """""" self["GUID__"] = uuid.uuid3(uuid.NAMESPACE_DNS,'HUnitConnectCAG_ConnectedLHS') self["equations"] = [] # Set the node attributes # match class Channel(Channel) node self.add_node() self.vs[0]["MT_pre__attr1"] = """return True""" self.vs[0]["MT_label__"] = """1""" self.vs[0]["mm__"] = """MT_pre__Channel""" self.vs[0]["GUID__"] = uuid.uuid3(uuid.NAMESPACE_DNS,'Channel') # Add the edges self.add_edges([ ]) # define evaluation methods for each match class. def eval_attr11(self, attr_value, this): return True # define evaluation methods for each match association. def constraint(self, PreNode, graph): return True
levilucio/SyVOLT
RSS2ATOM/contracts/unit/HUnitConnectCAG_ConnectedLHS.py
Python
mit
1,301
0.032283
# vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright 2013, Mirantis 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. # # @author: Tatiana Mazur from django.utils.translation import ugettext_lazy as _ # noqa from horizon import exceptions from horizon import forms from horizon.utils import fields from horizon import workflows from openstack_dashboard import api class AddVPNServiceAction(workflows.Action): name = forms.CharField(max_length=80, label=_("Name")) description = forms.CharField( initial="", required=False, max_length=80, label=_("Description")) router_id = forms.ChoiceField(label=_("Router")) subnet_id = forms.ChoiceField(label=_("Subnet")) admin_state_up = forms.BooleanField(label=_("Admin State"), initial=True, required=False) def __init__(self, request, *args, **kwargs): super(AddVPNServiceAction, self).__init__(request, *args, **kwargs) def populate_subnet_id_choices(self, request, context): subnet_id_choices = [('', _("Select a Subnet"))] try: tenant_id = request.user.tenant_id networks = api.neutron.network_list_for_tenant(request, tenant_id) except Exception: exceptions.handle(request, _('Unable to retrieve networks list.')) networks = [] for n in networks: for s in n['subnets']: subnet_id_choices.append((s.id, s.cidr)) self.fields['subnet_id'].choices = subnet_id_choices return subnet_id_choices def populate_router_id_choices(self, request, context): router_id_choices = [('', _("Select a Router"))] try: routers = api.neutron.router_list(request) except Exception: exceptions.handle(request, _('Unable to retrieve routers list.')) routers = [] for r in routers: router_id_choices.append((r.id, r.name)) self.fields['router_id'].choices = router_id_choices return router_id_choices class Meta: name = _("Add New VPN Service") permissions = ('openstack.services.network',) help_text = _("Create VPN Service for current project.\n\n" "Assign a name and description for the VPN Service. " "Select a router and a subnet. " "Admin State is Up (checked) by default." ) class AddVPNServiceStep(workflows.Step): action_class = AddVPNServiceAction contributes = ("name", "description", "subnet_id", "router_id", "admin_state_up") def contribute(self, data, context): context = super(AddVPNServiceStep, self).contribute(data, context) if data: return context class AddVPNService(workflows.Workflow): slug = "addvpnservice" name = _("Add VPN Service") finalize_button_name = _("Add") success_message = _('Added VPN Service "%s".') failure_message = _('Unable to add VPN Service "%s".') success_url = "horizon:project:vpn:index" default_steps = (AddVPNServiceStep,) def format_status_message(self, message): return message % self.context.get('name') def handle(self, request, context): try: api.vpn.vpnservice_create(request, **context) return True except Exception: return False class AddIKEPolicyAction(workflows.Action): name = forms.CharField(max_length=80, label=_("Name")) description = forms.CharField( initial="", required=False, max_length=80, label=_("Description")) auth_algorithm = forms.ChoiceField(label=_("Authorization algorithm")) encryption_algorithm = forms.ChoiceField(label=_("Encryption algorithm")) ike_version = forms.ChoiceField(label=_("IKE version")) lifetime_units = forms.ChoiceField(label=_("Lifetime units for IKE keys")) lifetime_value = forms.IntegerField( min_value=60, label=_("Lifetime value for IKE keys"), initial=3600, help_text=_("Equal to or more than 60")) pfs = forms.ChoiceField(label=_("Perfect Forward Secrecy")) phase1_negotiation_mode = forms.ChoiceField( label=_("IKE Phase1 negotiation mode")) def __init__(self, request, *args, **kwargs): super(AddIKEPolicyAction, self).__init__(request, *args, **kwargs) auth_algorithm_choices = [("sha1", "sha1")] self.fields['auth_algorithm'].choices = auth_algorithm_choices encryption_algorithm_choices = [("3des", "3des"), ("aes-128", "aes-128"), ("aes-192", "aes-192"), ("aes-256", "aes-256")] self.fields[ 'encryption_algorithm'].choices = encryption_algorithm_choices self.fields['encryption_algorithm'].initial = "aes-128" # Currently this field has only one choice, so mark it as readonly. self.fields['encryption_algorithm'].widget.attrs['readonly'] = True ike_version_choices = [("v1", "v1"), ("v2", "v2")] self.fields['ike_version'].choices = ike_version_choices lifetime_units_choices = [("seconds", "seconds")] self.fields['lifetime_units'].choices = lifetime_units_choices # Currently this field has only one choice, so mark it as readonly. self.fields['lifetime_units'].widget.attrs['readonly'] = True pfs_choices = [("group2", "group2"), ("group5", "group5"), ("group14", "group14")] self.fields['pfs'].choices = pfs_choices self.fields['pfs'].initial = "group5" phase1_neg_mode_choices = [("main", "main")] self.fields[ 'phase1_negotiation_mode'].choices = phase1_neg_mode_choices # Currently this field has only one choice, so mark it as readonly. self.fields['phase1_negotiation_mode'].widget.attrs['readonly'] = True class Meta: name = _("Add New IKE Policy") permissions = ('openstack.services.network',) help_text = _("Create IKE Policy for current project.\n\n" "Assign a name and description for the IKE Policy. " ) class AddIKEPolicyStep(workflows.Step): action_class = AddIKEPolicyAction contributes = ("name", "description", "auth_algorithm", "encryption_algorithm", "ike_version", "lifetime_units", "lifetime_value", "pfs", "phase1_negotiation_mode") def contribute(self, data, context): context = super(AddIKEPolicyStep, self).contribute(data, context) context.update({'lifetime': {'units': data['lifetime_units'], 'value': data['lifetime_value']}}) context.pop('lifetime_units') context.pop('lifetime_value') if data: return context class AddIKEPolicy(workflows.Workflow): slug = "addikepolicy" name = _("Add IKE Policy") finalize_button_name = _("Add") success_message = _('Added IKE Policy "%s".') failure_message = _('Unable to add IKE Policy "%s".') success_url = "horizon:project:vpn:index" default_steps = (AddIKEPolicyStep,) def format_status_message(self, message): return message % self.context.get('name') def handle(self, request, context): try: api.vpn.ikepolicy_create(request, **context) return True except Exception: return False class AddIPSecPolicyAction(workflows.Action): name = forms.CharField(max_length=80, label=_("Name")) description = forms.CharField( initial="", required=False, max_length=80, label=_("Description")) auth_algorithm = forms.ChoiceField(label=_("Authorization algorithm")) encapsulation_mode = forms.ChoiceField(label=_("Encapsulation mode")) encryption_algorithm = forms.ChoiceField(label=_("Encryption algorithm")) lifetime_units = forms.ChoiceField(label=_("Lifetime units")) lifetime_value = forms.IntegerField( min_value=60, label=_("Lifetime value for IKE keys "), initial=3600, help_text=_("Equal to or more than 60")) pfs = forms.ChoiceField(label=_("Perfect Forward Secrecy")) transform_protocol = forms.ChoiceField(label=_("Transform Protocol")) def __init__(self, request, *args, **kwargs): super(AddIPSecPolicyAction, self).__init__(request, *args, **kwargs) auth_algorithm_choices = [("sha1", "sha1")] self.fields['auth_algorithm'].choices = auth_algorithm_choices # Currently this field has only one choice, so mark it as readonly. self.fields['auth_algorithm'].widget.attrs['readonly'] = True encapsulation_mode_choices = [("tunnel", "tunnel"), ("transport", "transport")] self.fields['encapsulation_mode'].choices = encapsulation_mode_choices encryption_algorithm_choices = [("3des", "3des"), ("aes-128", "aes-128"), ("aes-192", "aes-192"), ("aes-256", "aes-256")] self.fields[ 'encryption_algorithm'].choices = encryption_algorithm_choices self.fields['encryption_algorithm'].initial = "aes-128" lifetime_units_choices = [("seconds", "seconds")] self.fields['lifetime_units'].choices = lifetime_units_choices # Currently this field has only one choice, so mark it as readonly. self.fields['lifetime_units'].widget.attrs['readonly'] = True pfs_choices = [("group2", "group2"), ("group5", "group5"), ("group14", "group14")] self.fields['pfs'].choices = pfs_choices self.fields['pfs'].initial = "group5" transform_protocol_choices = [("esp", "esp"), ("ah", "ah"), ("ah-esp", "ah-esp")] self.fields['transform_protocol'].choices = transform_protocol_choices class Meta: name = _("Add New IPSec Policy") permissions = ('openstack.services.network',) help_text = _("Create IPSec Policy for current project.\n\n" "Assign a name and description for the IPSec Policy. " ) class AddIPSecPolicyStep(workflows.Step): action_class = AddIPSecPolicyAction contributes = ("name", "description", "auth_algorithm", "encapsulation_mode", "encryption_algorithm", "lifetime_units", "lifetime_value", "pfs", "transform_protocol") def contribute(self, data, context): context = super(AddIPSecPolicyStep, self).contribute(data, context) context.update({'lifetime': {'units': data['lifetime_units'], 'value': data['lifetime_value']}}) context.pop('lifetime_units') context.pop('lifetime_value') if data: return context class AddIPSecPolicy(workflows.Workflow): slug = "addipsecpolicy" name = _("Add IPSec Policy") finalize_button_name = _("Add") success_message = _('Added IPSec Policy "%s".') failure_message = _('Unable to add IPSec Policy "%s".') success_url = "horizon:project:vpn:index" default_steps = (AddIPSecPolicyStep,) def format_status_message(self, message): return message % self.context.get('name') def handle(self, request, context): try: api.vpn.ipsecpolicy_create(request, **context) return True except Exception: return False class AddIPSecSiteConnectionAction(workflows.Action): name = forms.CharField(max_length=80, label=_("Name")) description = forms.CharField( initial="", required=False, max_length=80, label=_("Description")) vpnservice_id = forms.ChoiceField( label=_("VPN Service associated with this connection")) ikepolicy_id = forms.ChoiceField( label=_("IKE Policy associated with this connection")) ipsecpolicy_id = forms.ChoiceField( label=_("IPSec Policy associated with this connection")) peer_address = fields.IPField( label=_("Peer gateway public IPv4/IPv6 Address or FQDN"), help_text=_("Peer gateway public IPv4/IPv6 address or FQDN for " "the VPN Connection"), version=fields.IPv4 | fields.IPv6, mask=False) peer_id = fields.IPField( label=_("Peer router identity for authentication (Peer ID)"), help_text=_("Peer router identity for authentication. " "Can be IPv4/IPv6 address, e-mail, key ID, or FQDN"), version=fields.IPv4 | fields.IPv6, mask=False) peer_cidrs = fields.IPField(label=_("Remote peer subnet"), help_text=_("Remote peer subnet address " "with mask in CIDR format " "(e.g. 20.1.0.0/24)"), version=fields.IPv4 | fields.IPv6, mask=True) psk = forms.CharField(max_length=80, label=_("Pre-Shared Key (PSK) string")) def populate_ikepolicy_id_choices(self, request, context): ikepolicy_id_choices = [('', _("Select IKE Policy"))] try: ikepolicies = api.vpn.ikepolicies_get(request) except Exception: exceptions.handle(request, _('Unable to retrieve IKE Policies list.')) ikepolicies = [] for p in ikepolicies: ikepolicy_id_choices.append((p.id, p.name)) self.fields['ikepolicy_id'].choices = ikepolicy_id_choices return ikepolicy_id_choices def populate_ipsecpolicy_id_choices(self, request, context): ipsecpolicy_id_choices = [('', _("Select IPSec Policy"))] try: ipsecpolicies = api.vpn.ipsecpolicies_get(request) except Exception: exceptions.handle(request, _('Unable to retrieve IPSec Policies list.')) ipsecpolicies = [] for p in ipsecpolicies: ipsecpolicy_id_choices.append((p.id, p.name)) self.fields['ipsecpolicy_id'].choices = ipsecpolicy_id_choices return ipsecpolicy_id_choices def populate_vpnservice_id_choices(self, request, context): vpnservice_id_choices = [('', _("Select VPN Service"))] try: vpnservices = api.vpn.vpnservices_get(request) except Exception: exceptions.handle(request, _('Unable to retrieve VPN Services list.')) vpnservices = [] for s in vpnservices: vpnservice_id_choices.append((s.id, s.name)) self.fields['vpnservice_id'].choices = vpnservice_id_choices return vpnservice_id_choices class Meta: name = _("Add New IPSec Site Connection") permissions = ('openstack.services.network',) help_text = _("Create IPSec Site Connection for current project.\n\n" "Assign a name and description for the " "IPSec Site Connection. " "All fields in this tab are required." ) class AddIPSecSiteConnectionStep(workflows.Step): action_class = AddIPSecSiteConnectionAction contributes = ("name", "description", "vpnservice_id", "ikepolicy_id", "ipsecpolicy_id", "peer_address", "peer_id", "peer_cidrs", "psk") class AddIPSecSiteConnectionOptionalAction(workflows.Action): mtu = forms.IntegerField( min_value=68, label=_("Maximum Transmission Unit size for the connection"), initial=1500, help_text=_("Equal to or more than 68 if the local subnet is IPv4. " "Equal to or more than 1280 if the local subnet is IPv6.")) dpd_action = forms.ChoiceField(label=_("Dead peer detection actions")) dpd_interval = forms.IntegerField( min_value=1, label=_("Dead peer detection interval"), initial=30, help_text=_("Valid integer")) dpd_timeout = forms.IntegerField( min_value=1, label=_("Dead peer detection timeout"), initial=120, help_text=_("Valid integer greater than the DPD interval")) initiator = forms.ChoiceField(label=_("Initiator state")) admin_state_up = forms.BooleanField(label=_("Admin State"), initial=True, required=False) def __init__(self, request, *args, **kwargs): super(AddIPSecSiteConnectionOptionalAction, self).__init__( request, *args, **kwargs) initiator_choices = [("bi-directional", "bi-directional"), ("response-only", "response-only")] self.fields['initiator'].choices = initiator_choices def populate_dpd_action_choices(self, request, context): dpd_action_choices = [("hold", "hold"), ("clear", "clear"), ("disabled", "disabled"), ("restart", "restart"), ("restart-by-peer", "restart-by-peer")] self.fields['dpd_action'].choices = dpd_action_choices return dpd_action_choices class Meta: name = _("Optional Parameters") permissions = ('openstack.services.network',) help_text = _("Fields in this tab are optional. " "You can configure the detail of " "IPSec site connection created." ) class AddIPSecSiteConnectionOptionalStep(workflows.Step): action_class = AddIPSecSiteConnectionOptionalAction contributes = ("dpd_action", "dpd_interval", "dpd_timeout", "initiator", "mtu", "admin_state_up") def contribute(self, data, context): context = super( AddIPSecSiteConnectionOptionalStep, self).contribute(data, context) context.update({'dpd': {'action': data['dpd_action'], 'interval': data['dpd_interval'], 'timeout': data['dpd_timeout']}}) context.pop('dpd_action') context.pop('dpd_interval') context.pop('dpd_timeout') if data: return context class AddIPSecSiteConnection(workflows.Workflow): slug = "addipsecsiteconnection" name = _("Add IPSec Site Connection") finalize_button_name = _("Add") success_message = _('Added IPSec Site Connection "%s".') failure_message = _('Unable to add IPSec Site Connection "%s".') success_url = "horizon:project:vpn:index" default_steps = (AddIPSecSiteConnectionStep, AddIPSecSiteConnectionOptionalStep) def format_status_message(self, message): return message % self.context.get('name') def handle(self, request, context): try: api.vpn.ipsecsiteconnection_create(request, **context) return True except Exception: return False
Havate/havate-openstack
proto-build/gui/horizon/Horizon_GUI/openstack_dashboard/dashboards/project/vpn/workflows.py
Python
apache-2.0
19,939
0
# Copyright 2020 The StackStorm Authors. # Copyright 2019 Extreme Networks, 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. from __future__ import absolute_import import unittest2 from jsonschema.exceptions import ValidationError from st2common.models.system import actionchain from st2tests.fixturesloader import FixturesLoader FIXTURES_PACK = "generic" TEST_FIXTURES = { "actionchains": [ "chain1.yaml", "malformedchain.yaml", "no_default_chain.yaml", "chain_with_vars.yaml", "chain_with_publish.yaml", ] } FIXTURES = FixturesLoader().load_fixtures( fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_FIXTURES ) CHAIN_1 = FIXTURES["actionchains"]["chain1.yaml"] MALFORMED_CHAIN = FIXTURES["actionchains"]["malformedchain.yaml"] NO_DEFAULT_CHAIN = FIXTURES["actionchains"]["no_default_chain.yaml"] CHAIN_WITH_VARS = FIXTURES["actionchains"]["chain_with_vars.yaml"] CHAIN_WITH_PUBLISH = FIXTURES["actionchains"]["chain_with_publish.yaml"] class ActionChainSchemaTest(unittest2.TestCase): def test_actionchain_schema_valid(self): chain = actionchain.ActionChain(**CHAIN_1) self.assertEqual(len(chain.chain), len(CHAIN_1["chain"])) self.assertEqual(chain.default, CHAIN_1["default"]) def test_actionchain_no_default(self): chain = actionchain.ActionChain(**NO_DEFAULT_CHAIN) self.assertEqual(len(chain.chain), len(NO_DEFAULT_CHAIN["chain"])) self.assertEqual(chain.default, None) def test_actionchain_with_vars(self): chain = actionchain.ActionChain(**CHAIN_WITH_VARS) self.assertEqual(len(chain.chain), len(CHAIN_WITH_VARS["chain"])) self.assertEqual(len(chain.vars), len(CHAIN_WITH_VARS["vars"])) def test_actionchain_with_publish(self): chain = actionchain.ActionChain(**CHAIN_WITH_PUBLISH) self.assertEqual(len(chain.chain), len(CHAIN_WITH_PUBLISH["chain"])) self.assertEqual( len(chain.chain[0].publish), len(CHAIN_WITH_PUBLISH["chain"][0]["publish"]) ) def test_actionchain_schema_invalid(self): with self.assertRaises(ValidationError): actionchain.ActionChain(**MALFORMED_CHAIN)
nzlosh/st2
st2common/tests/unit/test_actionchain_schema.py
Python
apache-2.0
2,701
0.00037
def first(l): try: return l.pop() except Exception: return None
jdavisp3/TigerShark
tigershark/facade/utils.py
Python
bsd-3-clause
88
0.011364
# Copyright (c) 2012 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. '''Base class and interface for tools. ''' from __future__ import print_function class Tool(object): '''Base class for all tools. Tools should use their docstring (i.e. the class-level docstring) for the help they want to have printed when they are invoked.''' # # Interface (abstract methods) # def ShortDescription(self): '''Returns a short description of the functionality of the tool.''' raise NotImplementedError() def Run(self, global_options, my_arguments): '''Runs the tool. Args: global_options: object grit_runner.Options my_arguments: [arg1 arg2 ...] Return: 0 for success, non-0 for error ''' raise NotImplementedError() # # Base class implementation # def __init__(self): self.o = None def ShowUsage(self): '''Show usage text for this tool.''' print(self.__doc__) def SetOptions(self, opts): self.o = opts def Out(self, text): '''Always writes out 'text'.''' self.o.output_stream.write(text) def VerboseOut(self, text): '''Writes out 'text' if the verbose option is on.''' if self.o.verbose: self.o.output_stream.write(text) def ExtraVerboseOut(self, text): '''Writes out 'text' if the extra-verbose option is on. ''' if self.o.extra_verbose: self.o.output_stream.write(text)
endlessm/chromium-browser
tools/grit/grit/tool/interface.py
Python
bsd-3-clause
1,507
0.011944
""" Global configuration for the problem settings """ import numpy as np from scipy import stats horizon = 300 runs = 40 DefaultConfiguration = { "price_buy" : [1.2,2.1,3.3], "price_sell" : [1,2,3], "price_probabilities" : np.array([[0.8, 0.1, 0.1],[0.1, 0.8, 0.1],[0.1, 0.1, 0.8]]), "initial_capacity" : 1, "initial_inventory" : 0.5, "degradation" : {"fun":"polynomial","charge":[0.0,0,0.01], "discharge":[0.01,-0.02,0.01] }, "capacity_cost" : 1, "change_capacity" : False # assume that the capacity does not change } def construct_martingale(prices, variance): """ Constructs a definitions with a martingale definition of transition probabilities. The change in price is modeled as a normal distribution with zero mean and the specified variance. The capacity of the battery does in fact change Parameters ---------- prices : array **Sell** prices that correspond to states in the Martingale price state process. **Buy** prices are 10% higher. variance : float Variance of the normal distribution Returns ------- out : dict Configuration that corresponds to the martingale """ states = len(prices) # defines over how many states the probability is spread over spread = min(5,states-1) if type(prices) is not np.ndarray: prices = np.array(prices) # relative transition probabilities p = stats.norm(0,variance).pdf(np.arange(-spread,spread+1)) p = p / p.sum() # add extra 0s to both ends of p p = np.concatenate((np.zeros(states-spread-1), p, np.zeros(states-spread-1))) P = [p[states-i-1:2*states-i-1] for i in range(states)] P = np.array(P) P = np.diag(1/P.sum(1)).dot(P) configuration = { "price_buy" : 1.1 * prices, "price_sell" : prices, "price_probabilities" : P, "initial_capacity" : 1, "initial_inventory" : 0.5, "degradation" : {"fun":"polynomial","charge":[0.0,0,0.01], "discharge":[0.01,0.02,0.01] }, "capacity_cost" : 1, "change_capacity" : True # assume that the capacity does not change } return configuration def construct_massdata(degrade): """ Returns a problem definition on what is described in the experimental section of the paper This uses a simple uniform quantization of energy prices Paramaters ---------- degrade : bool Whether the battery degrades """ prices = np.array([25.0, 50.0, 75.0, 100.0, 125.0, 150.0, 175.0, 200.0, 250.0, 300.0]) P = np.array([[ 8.15584416e-01, 1.76623377e-01, 5.19480519e-03, 2.59740260e-03, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [ 4.70114171e-02, 8.72397582e-01, 7.25319006e-02, 7.38750839e-03, 0.00000000e+00, 6.71591672e-04, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [ 1.19904077e-03, 1.31894484e-01, 7.79376499e-01, 6.95443645e-02, 1.43884892e-02, 3.59712230e-03, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [ 0.00000000e+00, 4.24528302e-02, 2.83018868e-01, 5.14150943e-01, 1.22641509e-01, 2.35849057e-02, 9.43396226e-03, 0.00000000e+00, 0.00000000e+00, 4.71698113e-03], [ 0.00000000e+00, 2.15053763e-02, 9.67741935e-02, 2.68817204e-01, 4.30107527e-01, 1.29032258e-01, 4.30107527e-02, 1.07526882e-02, 0.00000000e+00, 0.00000000e+00], [ 0.00000000e+00, 0.00000000e+00, 3.22580645e-02, 2.58064516e-01, 3.54838710e-01, 1.93548387e-01, 9.67741935e-02, 6.45161290e-02, 0.00000000e+00, 0.00000000e+00], [ 0.00000000e+00, 7.14285714e-02, 1.42857143e-01, 0.00000000e+00, 7.14285714e-02, 2.14285714e-01, 2.85714286e-01, 1.42857143e-01, 7.14285714e-02, 0.00000000e+00], [ 0.00000000e+00, 0.00000000e+00, 1.42857143e-01, 0.00000000e+00, 2.85714286e-01, 0.00000000e+00, 0.00000000e+00, 2.85714286e-01, 2.85714286e-01, 0.00000000e+00], [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 2.50000000e-01, 2.50000000e-01, 2.50000000e-01, 0.00000000e+00, 2.50000000e-01, 0.00000000e+00], [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]]) if degrade: degradation = {"fun":"polynomial","charge" : [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.00142857142857143], "discharge" : [0.0, 0.00500000000000000, -0.00750000000000000, 0.00500000000000000, -0.00125000000000000] } else: degradation = {"fun":"polynomial","charge" : [0.0], "discharge" : [0.0] } configuration = { "price_buy" : 1.05 * prices, "price_sell" : 0.95 * prices, "price_probabilities" : P, "initial_capacity" : 1, "initial_inventory" : 0.5, "degradation" : degradation, "capacity_cost" : 20000, "change_capacity" : True } return configuration
marekpetrik/RAAM
raam/examples/inventory/configuration.py
Python
mit
5,606
0.019265
# Copyright 2015 Google LLC # # 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 unittest import mock from ._testing import _make_credentials from google.cloud.bigtable.cluster import Cluster class TestInstance(unittest.TestCase): PROJECT = "project" INSTANCE_ID = "instance-id" INSTANCE_NAME = "projects/" + PROJECT + "/instances/" + INSTANCE_ID LOCATION_ID = "locid" LOCATION = "projects/" + PROJECT + "/locations/" + LOCATION_ID APP_PROFILE_PATH = ( "projects/" + PROJECT + "/instances/" + INSTANCE_ID + "/appProfiles/" ) DISPLAY_NAME = "display_name" LABELS = {"foo": "bar"} OP_ID = 8915 OP_NAME = "operations/projects/{}/instances/{}operations/{}".format( PROJECT, INSTANCE_ID, OP_ID ) TABLE_ID = "table_id" TABLE_NAME = INSTANCE_NAME + "/tables/" + TABLE_ID @staticmethod def _get_target_class(): from google.cloud.bigtable.instance import Instance return Instance def _make_one(self, *args, **kwargs): return self._get_target_class()(*args, **kwargs) @staticmethod def _get_target_client_class(): from google.cloud.bigtable.client import Client return Client def _make_client(self, *args, **kwargs): return self._get_target_client_class()(*args, **kwargs) def test_constructor_defaults(self): client = object() instance = self._make_one(self.INSTANCE_ID, client) self.assertEqual(instance.instance_id, self.INSTANCE_ID) self.assertEqual(instance.display_name, self.INSTANCE_ID) self.assertIsNone(instance.type_) self.assertIsNone(instance.labels) self.assertIs(instance._client, client) self.assertIsNone(instance.state) def test_constructor_non_default(self): from google.cloud.bigtable import enums instance_type = enums.Instance.Type.DEVELOPMENT state = enums.Instance.State.READY labels = {"test": "test"} client = object() instance = self._make_one( self.INSTANCE_ID, client, display_name=self.DISPLAY_NAME, instance_type=instance_type, labels=labels, _state=state, ) self.assertEqual(instance.instance_id, self.INSTANCE_ID) self.assertEqual(instance.display_name, self.DISPLAY_NAME) self.assertEqual(instance.type_, instance_type) self.assertEqual(instance.labels, labels) self.assertIs(instance._client, client) self.assertEqual(instance.state, state) def test__update_from_pb_success(self): from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 from google.cloud.bigtable import enums instance_type = enums.Instance.Type.PRODUCTION state = enums.Instance.State.READY instance_pb = data_v2_pb2.Instance( display_name=self.DISPLAY_NAME, type=instance_type, labels=self.LABELS, state=state, ) instance = self._make_one(None, None) self.assertIsNone(instance.display_name) self.assertIsNone(instance.type_) self.assertIsNone(instance.labels) instance._update_from_pb(instance_pb) self.assertEqual(instance.display_name, self.DISPLAY_NAME) self.assertEqual(instance.type_, instance_type) self.assertEqual(instance.labels, self.LABELS) self.assertEqual(instance._state, state) def test__update_from_pb_success_defaults(self): from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 from google.cloud.bigtable import enums instance_pb = data_v2_pb2.Instance(display_name=self.DISPLAY_NAME) instance = self._make_one(None, None) self.assertIsNone(instance.display_name) self.assertIsNone(instance.type_) self.assertIsNone(instance.labels) instance._update_from_pb(instance_pb) self.assertEqual(instance.display_name, self.DISPLAY_NAME) self.assertEqual(instance.type_, enums.Instance.Type.UNSPECIFIED) self.assertFalse(instance.labels) def test__update_from_pb_no_display_name(self): from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 instance_pb = data_v2_pb2.Instance() instance = self._make_one(None, None) self.assertIsNone(instance.display_name) with self.assertRaises(ValueError): instance._update_from_pb(instance_pb) def test_from_pb_success(self): from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 from google.cloud.bigtable import enums credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance_type = enums.Instance.Type.PRODUCTION state = enums.Instance.State.READY instance_pb = data_v2_pb2.Instance( name=self.INSTANCE_NAME, display_name=self.INSTANCE_ID, type=instance_type, labels=self.LABELS, state=state, ) klass = self._get_target_class() instance = klass.from_pb(instance_pb, client) self.assertIsInstance(instance, klass) self.assertEqual(instance._client, client) self.assertEqual(instance.instance_id, self.INSTANCE_ID) self.assertEqual(instance.display_name, self.INSTANCE_ID) self.assertEqual(instance.type_, instance_type) self.assertEqual(instance.labels, self.LABELS) self.assertEqual(instance._state, state) def test_from_pb_bad_instance_name(self): from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 instance_name = "INCORRECT_FORMAT" instance_pb = data_v2_pb2.Instance(name=instance_name) klass = self._get_target_class() with self.assertRaises(ValueError): klass.from_pb(instance_pb, None) def test_from_pb_project_mistmatch(self): from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 ALT_PROJECT = "ALT_PROJECT" credentials = _make_credentials() client = self._make_client( project=ALT_PROJECT, credentials=credentials, admin=True ) self.assertNotEqual(self.PROJECT, ALT_PROJECT) instance_pb = data_v2_pb2.Instance(name=self.INSTANCE_NAME) klass = self._get_target_class() with self.assertRaises(ValueError): klass.from_pb(instance_pb, client) def test_name_property(self): from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client api = bigtable_instance_admin_client.BigtableInstanceAdminClient(mock.Mock()) credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) # Patch the the API method. client._instance_admin_client = api instance = self._make_one(self.INSTANCE_ID, client) self.assertEqual(instance.name, self.INSTANCE_NAME) def test___eq__(self): client = object() instance1 = self._make_one(self.INSTANCE_ID, client) instance2 = self._make_one(self.INSTANCE_ID, client) self.assertEqual(instance1, instance2) def test___eq__type_differ(self): client = object() instance1 = self._make_one(self.INSTANCE_ID, client) instance2 = object() self.assertNotEqual(instance1, instance2) def test___ne__same_value(self): client = object() instance1 = self._make_one(self.INSTANCE_ID, client) instance2 = self._make_one(self.INSTANCE_ID, client) comparison_val = instance1 != instance2 self.assertFalse(comparison_val) def test___ne__(self): instance1 = self._make_one("instance_id1", "client1") instance2 = self._make_one("instance_id2", "client2") self.assertNotEqual(instance1, instance2) def test_create_check_location_and_clusters(self): instance = self._make_one(self.INSTANCE_ID, None) with self.assertRaises(ValueError): instance.create(location_id=self.LOCATION_ID, clusters=[object(), object()]) def test_create_check_serve_nodes_and_clusters(self): instance = self._make_one(self.INSTANCE_ID, None) with self.assertRaises(ValueError): instance.create(serve_nodes=3, clusters=[object(), object()]) def test_create_check_default_storage_type_and_clusters(self): instance = self._make_one(self.INSTANCE_ID, None) with self.assertRaises(ValueError): instance.create(default_storage_type=1, clusters=[object(), object()]) def _instance_api_response_for_create(self): import datetime from google.api_core import operation from google.longrunning import operations_pb2 from google.protobuf.any_pb2 import Any from google.cloud._helpers import _datetime_to_pb_timestamp from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client from google.cloud.bigtable_admin_v2.proto import ( bigtable_instance_admin_pb2 as messages_v2_pb2, ) from google.cloud.bigtable_admin_v2.types import instance_pb2 NOW = datetime.datetime.utcnow() NOW_PB = _datetime_to_pb_timestamp(NOW) metadata = messages_v2_pb2.CreateInstanceMetadata(request_time=NOW_PB) type_url = "type.googleapis.com/{}".format( messages_v2_pb2.CreateInstanceMetadata.DESCRIPTOR.full_name ) response_pb = operations_pb2.Operation( name=self.OP_NAME, metadata=Any(type_url=type_url, value=metadata.SerializeToString()), ) response = operation.from_gapic( response_pb, mock.Mock(), instance_pb2.Instance, metadata_type=messages_v2_pb2.CreateInstanceMetadata, ) project_path_template = "projects/{}" location_path_template = "projects/{}/locations/{}" instance_api = mock.create_autospec( bigtable_instance_admin_client.BigtableInstanceAdminClient ) instance_api.create_instance.return_value = response instance_api.project_path = project_path_template.format instance_api.location_path = location_path_template.format return instance_api, response def test_create(self): from google.cloud.bigtable import enums from google.cloud.bigtable_admin_v2.types import instance_pb2 import warnings credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one( self.INSTANCE_ID, client, self.DISPLAY_NAME, enums.Instance.Type.PRODUCTION, self.LABELS, ) instance_api, response = self._instance_api_response_for_create() client._instance_admin_client = instance_api serve_nodes = 3 with warnings.catch_warnings(record=True) as warned: result = instance.create( location_id=self.LOCATION_ID, serve_nodes=serve_nodes ) cluster_pb = instance_pb2.Cluster( location=instance_api.location_path(self.PROJECT, self.LOCATION_ID), serve_nodes=serve_nodes, default_storage_type=enums.StorageType.UNSPECIFIED, ) instance_pb = instance_pb2.Instance( display_name=self.DISPLAY_NAME, type=enums.Instance.Type.PRODUCTION, labels=self.LABELS, ) cluster_id = "{}-cluster".format(self.INSTANCE_ID) instance_api.create_instance.assert_called_once_with( parent=instance_api.project_path(self.PROJECT), instance_id=self.INSTANCE_ID, instance=instance_pb, clusters={cluster_id: cluster_pb}, ) self.assertEqual(len(warned), 1) self.assertIs(warned[0].category, DeprecationWarning) self.assertIs(result, response) def test_create_w_clusters(self): from google.cloud.bigtable import enums from google.cloud.bigtable_admin_v2.types import instance_pb2 credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one( self.INSTANCE_ID, client, self.DISPLAY_NAME, enums.Instance.Type.PRODUCTION, self.LABELS, ) instance_api, response = self._instance_api_response_for_create() client._instance_admin_client = instance_api # Perform the method and check the result. cluster_id_1 = "cluster-1" cluster_id_2 = "cluster-2" location_id_1 = "location-id-1" location_id_2 = "location-id-2" serve_nodes_1 = 3 serve_nodes_2 = 5 clusters = [ Cluster( cluster_id_1, instance, location_id=location_id_1, serve_nodes=serve_nodes_1, ), Cluster( cluster_id_2, instance, location_id=location_id_2, serve_nodes=serve_nodes_2, ), ] result = instance.create(clusters=clusters) cluster_pb_1 = instance_pb2.Cluster( location=instance_api.location_path(self.PROJECT, location_id_1), serve_nodes=serve_nodes_1, default_storage_type=enums.StorageType.UNSPECIFIED, ) cluster_pb_2 = instance_pb2.Cluster( location=instance_api.location_path(self.PROJECT, location_id_2), serve_nodes=serve_nodes_2, default_storage_type=enums.StorageType.UNSPECIFIED, ) instance_pb = instance_pb2.Instance( display_name=self.DISPLAY_NAME, type=enums.Instance.Type.PRODUCTION, labels=self.LABELS, ) instance_api.create_instance.assert_called_once_with( parent=instance_api.project_path(self.PROJECT), instance_id=self.INSTANCE_ID, instance=instance_pb, clusters={cluster_id_1: cluster_pb_1, cluster_id_2: cluster_pb_2}, ) self.assertIs(result, response) def test_exists(self): from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 from google.api_core import exceptions api = bigtable_instance_admin_client.BigtableInstanceAdminClient(mock.Mock()) credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) # Create response_pb instance_name = client.instance_admin_client.instance_path( self.PROJECT, self.INSTANCE_ID ) response_pb = data_v2_pb2.Instance(name=instance_name) # Patch the stub used by the API method. client._instance_admin_client = api instance_admin_client = client._instance_admin_client instance_stub = instance_admin_client.transport instance_stub.get_instance.side_effect = [ response_pb, exceptions.NotFound("testing"), exceptions.BadRequest("testing"), ] # Perform the method and check the result. non_existing_instance_id = "instance-id-2" alt_instance_1 = self._make_one(self.INSTANCE_ID, client) alt_instance_2 = self._make_one(non_existing_instance_id, client) self.assertTrue(alt_instance_1.exists()) self.assertFalse(alt_instance_2.exists()) with self.assertRaises(exceptions.BadRequest): alt_instance_2.exists() def test_reload(self): from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client from google.cloud.bigtable import enums api = bigtable_instance_admin_client.BigtableInstanceAdminClient(mock.Mock()) credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one(self.INSTANCE_ID, client) # Create response_pb DISPLAY_NAME = u"hey-hi-hello" instance_type = enums.Instance.Type.PRODUCTION response_pb = data_v2_pb2.Instance( display_name=DISPLAY_NAME, type=instance_type, labels=self.LABELS ) # Patch the stub used by the API method. client._instance_admin_client = api bigtable_instance_stub = client._instance_admin_client.transport bigtable_instance_stub.get_instance.side_effect = [response_pb] # Create expected_result. expected_result = None # reload() has no return value. # Check Instance optional config values before. self.assertEqual(instance.display_name, self.INSTANCE_ID) # Perform the method and check the result. result = instance.reload() self.assertEqual(result, expected_result) # Check Instance optional config values before. self.assertEqual(instance.display_name, DISPLAY_NAME) def _instance_api_response_for_update(self): import datetime from google.api_core import operation from google.longrunning import operations_pb2 from google.protobuf.any_pb2 import Any from google.cloud._helpers import _datetime_to_pb_timestamp from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client from google.cloud.bigtable_admin_v2.proto import ( bigtable_instance_admin_pb2 as messages_v2_pb2, ) from google.cloud.bigtable_admin_v2.types import instance_pb2 NOW = datetime.datetime.utcnow() NOW_PB = _datetime_to_pb_timestamp(NOW) metadata = messages_v2_pb2.UpdateInstanceMetadata(request_time=NOW_PB) type_url = "type.googleapis.com/{}".format( messages_v2_pb2.UpdateInstanceMetadata.DESCRIPTOR.full_name ) response_pb = operations_pb2.Operation( name=self.OP_NAME, metadata=Any(type_url=type_url, value=metadata.SerializeToString()), ) response = operation.from_gapic( response_pb, mock.Mock(), instance_pb2.Instance, metadata_type=messages_v2_pb2.UpdateInstanceMetadata, ) instance_path_template = "projects/{project}/instances/{instance}" instance_api = mock.create_autospec( bigtable_instance_admin_client.BigtableInstanceAdminClient ) instance_api.partial_update_instance.return_value = response instance_api.instance_path = instance_path_template.format return instance_api, response def test_update(self): from google.cloud.bigtable import enums from google.protobuf import field_mask_pb2 from google.cloud.bigtable_admin_v2.types import instance_pb2 credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one( self.INSTANCE_ID, client, display_name=self.DISPLAY_NAME, instance_type=enums.Instance.Type.DEVELOPMENT, labels=self.LABELS, ) instance_api, response = self._instance_api_response_for_update() client._instance_admin_client = instance_api result = instance.update() instance_pb = instance_pb2.Instance( name=instance.name, display_name=instance.display_name, type=instance.type_, labels=instance.labels, ) update_mask_pb = field_mask_pb2.FieldMask( paths=["display_name", "type", "labels"] ) instance_api.partial_update_instance.assert_called_once_with( instance=instance_pb, update_mask=update_mask_pb ) self.assertIs(result, response) def test_update_empty(self): from google.protobuf import field_mask_pb2 from google.cloud.bigtable_admin_v2.types import instance_pb2 credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one(None, client) instance_api, response = self._instance_api_response_for_update() client._instance_admin_client = instance_api result = instance.update() instance_pb = instance_pb2.Instance( name=instance.name, display_name=instance.display_name, type=instance.type_, labels=instance.labels, ) update_mask_pb = field_mask_pb2.FieldMask() instance_api.partial_update_instance.assert_called_once_with( instance=instance_pb, update_mask=update_mask_pb ) self.assertIs(result, response) def test_delete(self): from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one(self.INSTANCE_ID, client) instance_api = mock.create_autospec( bigtable_instance_admin_client.BigtableInstanceAdminClient ) instance_api.delete_instance.return_value = None client._instance_admin_client = instance_api result = instance.delete() instance_api.delete_instance.assert_called_once_with(instance.name) self.assertIsNone(result) def test_get_iam_policy(self): from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client from google.iam.v1 import policy_pb2 from google.cloud.bigtable.policy import BIGTABLE_ADMIN_ROLE credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one(self.INSTANCE_ID, client) version = 1 etag = b"etag_v1" members = ["serviceAccount:service_acc1@test.com", "user:user1@test.com"] bindings = [{"role": BIGTABLE_ADMIN_ROLE, "members": members}] iam_policy = policy_pb2.Policy(version=version, etag=etag, bindings=bindings) # Patch the stub used by the API method. instance_api = mock.create_autospec( bigtable_instance_admin_client.BigtableInstanceAdminClient ) client._instance_admin_client = instance_api instance_api.get_iam_policy.return_value = iam_policy # Perform the method and check the result. result = instance.get_iam_policy() instance_api.get_iam_policy.assert_called_once_with(resource=instance.name) self.assertEqual(result.version, version) self.assertEqual(result.etag, etag) admins = result.bigtable_admins self.assertEqual(len(admins), len(members)) for found, expected in zip(sorted(admins), sorted(members)): self.assertEqual(found, expected) def test_set_iam_policy(self): from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client from google.iam.v1 import policy_pb2 from google.cloud.bigtable.policy import Policy from google.cloud.bigtable.policy import BIGTABLE_ADMIN_ROLE credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one(self.INSTANCE_ID, client) version = 1 etag = b"etag_v1" members = ["serviceAccount:service_acc1@test.com", "user:user1@test.com"] bindings = [{"role": BIGTABLE_ADMIN_ROLE, "members": sorted(members)}] iam_policy_pb = policy_pb2.Policy(version=version, etag=etag, bindings=bindings) # Patch the stub used by the API method. instance_api = mock.create_autospec( bigtable_instance_admin_client.BigtableInstanceAdminClient ) instance_api.set_iam_policy.return_value = iam_policy_pb client._instance_admin_client = instance_api # Perform the method and check the result. iam_policy = Policy(etag=etag, version=version) iam_policy[BIGTABLE_ADMIN_ROLE] = [ Policy.user("user1@test.com"), Policy.service_account("service_acc1@test.com"), ] result = instance.set_iam_policy(iam_policy) instance_api.set_iam_policy.assert_called_once_with( resource=instance.name, policy=iam_policy_pb ) self.assertEqual(result.version, version) self.assertEqual(result.etag, etag) admins = result.bigtable_admins self.assertEqual(len(admins), len(members)) for found, expected in zip(sorted(admins), sorted(members)): self.assertEqual(found, expected) def test_test_iam_permissions(self): from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client from google.iam.v1 import iam_policy_pb2 credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one(self.INSTANCE_ID, client) permissions = ["bigtable.tables.create", "bigtable.clusters.create"] response = iam_policy_pb2.TestIamPermissionsResponse(permissions=permissions) instance_api = mock.create_autospec( bigtable_instance_admin_client.BigtableInstanceAdminClient ) instance_api.test_iam_permissions.return_value = response client._instance_admin_client = instance_api result = instance.test_iam_permissions(permissions) self.assertEqual(result, permissions) instance_api.test_iam_permissions.assert_called_once_with( resource=instance.name, permissions=permissions ) def test_cluster_factory(self): from google.cloud.bigtable import enums CLUSTER_ID = "{}-cluster".format(self.INSTANCE_ID) LOCATION_ID = "us-central1-c" SERVE_NODES = 3 STORAGE_TYPE = enums.StorageType.HDD instance = self._make_one(self.INSTANCE_ID, None) cluster = instance.cluster( CLUSTER_ID, location_id=LOCATION_ID, serve_nodes=SERVE_NODES, default_storage_type=STORAGE_TYPE, ) self.assertIsInstance(cluster, Cluster) self.assertEqual(cluster.cluster_id, CLUSTER_ID) self.assertEqual(cluster.location_id, LOCATION_ID) self.assertIsNone(cluster._state) self.assertEqual(cluster.serve_nodes, SERVE_NODES) self.assertEqual(cluster.default_storage_type, STORAGE_TYPE) def test_list_clusters(self): from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client from google.cloud.bigtable_admin_v2.proto import ( bigtable_instance_admin_pb2 as messages_v2_pb2, ) from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 from google.cloud.bigtable.instance import Instance from google.cloud.bigtable.instance import Cluster credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = Instance(self.INSTANCE_ID, client) failed_location = "FAILED" cluster_id1 = "cluster-id1" cluster_id2 = "cluster-id2" cluster_path_template = "projects/{}/instances/{}/clusters/{}" cluster_name1 = cluster_path_template.format( self.PROJECT, self.INSTANCE_ID, cluster_id1 ) cluster_name2 = cluster_path_template.format( self.PROJECT, self.INSTANCE_ID, cluster_id2 ) # Create response_pb response_pb = messages_v2_pb2.ListClustersResponse( failed_locations=[failed_location], clusters=[ data_v2_pb2.Cluster(name=cluster_name1), data_v2_pb2.Cluster(name=cluster_name2), ], ) # Patch the stub used by the API method. instance_api = mock.create_autospec( bigtable_instance_admin_client.BigtableInstanceAdminClient ) instance_api.list_clusters.side_effect = [response_pb] instance_api.cluster_path = cluster_path_template.format client._instance_admin_client = instance_api # Perform the method and check the result. clusters, failed_locations = instance.list_clusters() cluster_1, cluster_2 = clusters self.assertIsInstance(cluster_1, Cluster) self.assertEqual(cluster_1.name, cluster_name1) self.assertIsInstance(cluster_2, Cluster) self.assertEqual(cluster_2.name, cluster_name2) self.assertEqual(failed_locations, [failed_location]) def test_table_factory(self): from google.cloud.bigtable.table import Table app_profile_id = "appProfileId1262094415" instance = self._make_one(self.INSTANCE_ID, None) table = instance.table(self.TABLE_ID, app_profile_id=app_profile_id) self.assertIsInstance(table, Table) self.assertEqual(table.table_id, self.TABLE_ID) self.assertEqual(table._instance, instance) self.assertEqual(table._app_profile_id, app_profile_id) def _list_tables_helper(self, table_name=None): from google.cloud.bigtable_admin_v2.proto import table_pb2 as table_data_v2_pb2 from google.cloud.bigtable_admin_v2.proto import ( bigtable_table_admin_pb2 as table_messages_v1_pb2, ) from google.cloud.bigtable_admin_v2.gapic import ( bigtable_table_admin_client, bigtable_instance_admin_client, ) table_api = bigtable_table_admin_client.BigtableTableAdminClient(mock.Mock()) instance_api = bigtable_instance_admin_client.BigtableInstanceAdminClient( mock.Mock() ) credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one(self.INSTANCE_ID, client) # Create response_pb if table_name is None: table_name = self.TABLE_NAME response_pb = table_messages_v1_pb2.ListTablesResponse( tables=[table_data_v2_pb2.Table(name=table_name)] ) # Patch the stub used by the API method. client._table_admin_client = table_api client._instance_admin_client = instance_api bigtable_table_stub = client._table_admin_client.transport bigtable_table_stub.list_tables.side_effect = [response_pb] # Create expected_result. expected_table = instance.table(self.TABLE_ID) expected_result = [expected_table] # Perform the method and check the result. result = instance.list_tables() self.assertEqual(result, expected_result) def test_list_tables(self): self._list_tables_helper() def test_list_tables_failure_bad_split(self): with self.assertRaises(ValueError): self._list_tables_helper(table_name="wrong-format") def test_list_tables_failure_name_bad_before(self): BAD_TABLE_NAME = ( "nonempty-section-before" + "projects/" + self.PROJECT + "/instances/" + self.INSTANCE_ID + "/tables/" + self.TABLE_ID ) with self.assertRaises(ValueError): self._list_tables_helper(table_name=BAD_TABLE_NAME) def test_app_profile_factory(self): from google.cloud.bigtable.enums import RoutingPolicyType APP_PROFILE_ID_1 = "app-profile-id-1" ANY = RoutingPolicyType.ANY DESCRIPTION_1 = "routing policy any" APP_PROFILE_ID_2 = "app-profile-id-2" SINGLE = RoutingPolicyType.SINGLE DESCRIPTION_2 = "routing policy single" ALLOW_WRITES = True CLUSTER_ID = "cluster-id" instance = self._make_one(self.INSTANCE_ID, None) app_profile1 = instance.app_profile( APP_PROFILE_ID_1, routing_policy_type=ANY, description=DESCRIPTION_1 ) app_profile2 = instance.app_profile( APP_PROFILE_ID_2, routing_policy_type=SINGLE, description=DESCRIPTION_2, cluster_id=CLUSTER_ID, allow_transactional_writes=ALLOW_WRITES, ) self.assertEqual(app_profile1.app_profile_id, APP_PROFILE_ID_1) self.assertIs(app_profile1._instance, instance) self.assertEqual(app_profile1.routing_policy_type, ANY) self.assertEqual(app_profile1.description, DESCRIPTION_1) self.assertEqual(app_profile2.app_profile_id, APP_PROFILE_ID_2) self.assertIs(app_profile2._instance, instance) self.assertEqual(app_profile2.routing_policy_type, SINGLE) self.assertEqual(app_profile2.description, DESCRIPTION_2) self.assertEqual(app_profile2.cluster_id, CLUSTER_ID) self.assertEqual(app_profile2.allow_transactional_writes, ALLOW_WRITES) def test_list_app_profiles(self): from google.api_core.page_iterator import Iterator from google.api_core.page_iterator import Page from google.cloud.bigtable_admin_v2.gapic import bigtable_instance_admin_client from google.cloud.bigtable_admin_v2.proto import instance_pb2 as data_v2_pb2 from google.cloud.bigtable.app_profile import AppProfile class _Iterator(Iterator): def __init__(self, pages): super(_Iterator, self).__init__(client=None) self._pages = pages def _next_page(self): if self._pages: page, self._pages = self._pages[0], self._pages[1:] return Page(self, page, self.item_to_value) credentials = _make_credentials() client = self._make_client( project=self.PROJECT, credentials=credentials, admin=True ) instance = self._make_one(self.INSTANCE_ID, client) # Setup Expected Response app_profile_path_template = "projects/{}/instances/{}/appProfiles/{}" app_profile_id1 = "app-profile-id1" app_profile_id2 = "app-profile-id2" app_profile_name1 = app_profile_path_template.format( self.PROJECT, self.INSTANCE_ID, app_profile_id1 ) app_profile_name2 = app_profile_path_template.format( self.PROJECT, self.INSTANCE_ID, app_profile_id2 ) routing_policy = data_v2_pb2.AppProfile.MultiClusterRoutingUseAny() app_profiles = [ data_v2_pb2.AppProfile( name=app_profile_name1, multi_cluster_routing_use_any=routing_policy ), data_v2_pb2.AppProfile( name=app_profile_name2, multi_cluster_routing_use_any=routing_policy ), ] iterator = _Iterator(pages=[app_profiles]) # Patch the stub used by the API method. instance_api = mock.create_autospec( bigtable_instance_admin_client.BigtableInstanceAdminClient ) client._instance_admin_client = instance_api instance_api.app_profile_path = app_profile_path_template.format instance_api.list_app_profiles.return_value = iterator # Perform the method and check the result. app_profiles = instance.list_app_profiles() app_profile_1, app_profile_2 = app_profiles self.assertIsInstance(app_profile_1, AppProfile) self.assertEqual(app_profile_1.name, app_profile_name1) self.assertIsInstance(app_profile_2, AppProfile) self.assertEqual(app_profile_2.name, app_profile_name2)
tseaver/google-cloud-python
bigtable/tests/unit/test_instance.py
Python
apache-2.0
37,126
0.001104
""" Defines the URL routes for this app. """ from django.conf import settings from django.conf.urls import patterns, url from ..profile_images.views import ProfileImageView from .accounts.views import AccountDeactivationView, AccountViewSet from .preferences.views import PreferencesView, PreferencesDetailView from .verification_api.views import PhotoVerificationStatusView ME = AccountViewSet.as_view({ 'get': 'get', }) ACCOUNT_LIST = AccountViewSet.as_view({ 'get': 'list', }) ACCOUNT_DETAIL = AccountViewSet.as_view({ 'get': 'retrieve', 'patch': 'partial_update', }) urlpatterns = patterns( '', url(r'^v1/me$', ME, name='own_username_api'), url(r'^v1/accounts/{}$'.format(settings.USERNAME_PATTERN), ACCOUNT_DETAIL, name='accounts_api'), url(r'^v1/accounts$', ACCOUNT_LIST, name='accounts_detail_api'), url( r'^v1/accounts/{}/image$'.format(settings.USERNAME_PATTERN), ProfileImageView.as_view(), name='accounts_profile_image_api' ), url( r'^v1/accounts/{}/deactivate/$'.format(settings.USERNAME_PATTERN), AccountDeactivationView.as_view(), name='accounts_deactivation' ), url( r'^v1/accounts/{}/verification_status/$'.format(settings.USERNAME_PATTERN), PhotoVerificationStatusView.as_view(), name='verification_status' ), url( r'^v1/preferences/{}$'.format(settings.USERNAME_PATTERN), PreferencesView.as_view(), name='preferences_api' ), url( r'^v1/preferences/{}/(?P<preference_key>[a-zA-Z0-9_]+)$'.format(settings.USERNAME_PATTERN), PreferencesDetailView.as_view(), name='preferences_detail_api' ), )
prarthitm/edxplatform
openedx/core/djangoapps/user_api/urls.py
Python
agpl-3.0
1,706
0.001758
#NVDAObjects/IAccessible/sysTreeView32.py #A part of NonVisual Desktop Access (NVDA) #This file is covered by the GNU General Public License. #See the file COPYING for more details. #Copyright (C) 2007-2010 Michael Curran <mick@kulgan.net>, James Teh <jamie@jantrid.net> from ctypes import * from ctypes.wintypes import * import api import winKernel import controlTypes import speech import UIAHandler from . import IAccessible if UIAHandler.isUIAAvailable: from ..UIA import UIA from .. import NVDAObject from logHandler import log import watchdog TV_FIRST=0x1100 TVIS_STATEIMAGEMASK=0xf000 #Window messages TVM_GETITEMSTATE=TV_FIRST+39 TVM_GETITEM=TV_FIRST+62 TVM_MAPACCIDTOHTREEITEM=TV_FIRST+42 TVM_MAPHTREEITEMTOACCID=TV_FIRST+43 TVM_GETNEXTITEM=TV_FIRST+10 #item mask flags TVIF_CHILDREN=0x40 #Relation codes TVGN_ROOT=0 TVGN_NEXT=1 TVGN_PREVIOUS=2 TVGN_PARENT=3 TVGN_CHILD=4 class TVItemStruct(Structure): _fields_=[ ('mask',c_uint), ('hItem',c_void_p), ('state',c_uint), ('stateMask',c_uint), ('pszText',LPWSTR), ('cchTextMax',c_int), ('iImage',c_int), ('iSelectedImage',c_int), ('cChildren',c_int), ('lParam',LPARAM), ] class TreeView(IAccessible): def _get_firstChild(self): try: return super(TreeView, self).firstChild except: # Broken commctrl 5 tree view. return BrokenCommctrl5Item.getFirstItem(self) class TreeViewItem(IAccessible): def _get_role(self): return controlTypes.ROLE_TREEVIEWITEM def _get_treeview_hItem(self): if not hasattr(self,'_treeview_hItem'): self._treeview_hItem=watchdog.cancellableSendMessage(self.windowHandle,TVM_MAPACCIDTOHTREEITEM,self.IAccessibleChildID,0) if not self._treeview_hItem: # Tree views from comctl < 6.0 use the hItem as the child ID. self._treeview_hItem=self.IAccessibleChildID return self._treeview_hItem def _get_treeview_level(self): return int(self.IAccessibleObject.accValue(self.IAccessibleChildID)) def _get_states(self): states=super(TreeViewItem,self)._get_states() hItem=self.treeview_hItem itemStates=watchdog.cancellableSendMessage(self.windowHandle,TVM_GETITEMSTATE,hItem,TVIS_STATEIMAGEMASK) ch=(itemStates>>12)&3 if ch>0: states.add(controlTypes.STATE_CHECKABLE) if ch==2: states.add(controlTypes.STATE_CHECKED) elif ch==3: states.add(controlTypes.STATE_HALFCHECKED) return states def _get_value(self): return None def _get_parent(self): if self.IAccessibleChildID==0: return super(TreeViewItem,self)._get_parent() hItem=self.treeview_hItem if not hItem: return super(TreeViewItem,self)._get_parent() parentItem=watchdog.cancellableSendMessage(self.windowHandle,TVM_GETNEXTITEM,TVGN_PARENT,hItem) if parentItem<=0: return super(TreeViewItem,self)._get_parent() newID=watchdog.cancellableSendMessage(self.windowHandle,TVM_MAPHTREEITEMTOACCID,parentItem,0) if not newID: # Tree views from comctl < 6.0 use the hItem as the child ID. newID=parentItem return IAccessible(windowHandle=self.windowHandle,IAccessibleObject=self.IAccessibleObject,IAccessibleChildID=newID) def _get_firstChild(self): if self.IAccessibleChildID==0: return super(TreeViewItem,self)._get_firstChild() hItem=self.treeview_hItem if not hItem: return super(TreeViewItem,self)._get_firstChild() childItem=watchdog.cancellableSendMessage(self.windowHandle,TVM_GETNEXTITEM,TVGN_CHILD,hItem) if childItem<=0: return super(TreeViewItem,self)._get_firstChild() newID=watchdog.cancellableSendMessage(self.windowHandle,TVM_MAPHTREEITEMTOACCID,childItem,0) if not newID: # Tree views from comctl < 6.0 use the hItem as the child ID. newID=childItem return IAccessible(windowHandle=self.windowHandle,IAccessibleObject=self.IAccessibleObject,IAccessibleChildID=newID) def _get_next(self): if self.IAccessibleChildID==0: return super(TreeViewItem,self)._get_next() hItem=self.treeview_hItem if not hItem: return None nextItem=watchdog.cancellableSendMessage(self.windowHandle,TVM_GETNEXTITEM,TVGN_NEXT,hItem) if nextItem<=0: return None newID=watchdog.cancellableSendMessage(self.windowHandle,TVM_MAPHTREEITEMTOACCID,nextItem,0) if not newID: # Tree views from comctl < 6.0 use the hItem as the child ID. newID=nextItem return IAccessible(windowHandle=self.windowHandle,IAccessibleObject=self.IAccessibleObject,IAccessibleChildID=newID) def _get_previous(self): if self.IAccessibleChildID==0: return super(TreeViewItem,self)._get_previous() hItem=self.treeview_hItem if not hItem: return None prevItem=watchdog.cancellableSendMessage(self.windowHandle,TVM_GETNEXTITEM,TVGN_PREVIOUS,hItem) if prevItem<=0: return None newID=watchdog.cancellableSendMessage(self.windowHandle,TVM_MAPHTREEITEMTOACCID,prevItem,0) if not newID: # Tree views from comctl < 6.0 use the hItem as the child ID. newID=prevItem return IAccessible(windowHandle=self.windowHandle,IAccessibleObject=self.IAccessibleObject,IAccessibleChildID=newID) def _get_children(self): children=[] child=self.firstChild while child: children.append(child) child=child.next return children def _get_childCount(self): hItem=self.treeview_hItem if not hItem: return 0 childItem=watchdog.cancellableSendMessage(self.windowHandle,TVM_GETNEXTITEM,TVGN_CHILD,hItem) if childItem<=0: return 0 numItems=0 while childItem>0: numItems+=1 childItem=watchdog.cancellableSendMessage(self.windowHandle,TVM_GETNEXTITEM,TVGN_NEXT,childItem) return numItems def _get_positionInfo(self): if self.IAccessibleChildID==0: return super(TreeViewItem,self)._get_positionInfo() info={} info['level']=self.treeview_level hItem=self.treeview_hItem if not hItem: return info newItem=hItem index=0 while newItem>0: index+=1 newItem=watchdog.cancellableSendMessage(self.windowHandle,TVM_GETNEXTITEM,TVGN_PREVIOUS,newItem) newItem=hItem numItems=index-1 while newItem>0: numItems+=1 newItem=watchdog.cancellableSendMessage(self.windowHandle,TVM_GETNEXTITEM,TVGN_NEXT,newItem) info['indexInGroup']=index info['similarItemsInGroup']=numItems return info def event_stateChange(self): announceContains = self is api.getFocusObject() and controlTypes.STATE_EXPANDED in self.states and controlTypes.STATE_EXPANDED not in getattr(self,'_speakObjectPropertiesCache',{}).get('states',frozenset()) super(TreeViewItem,self).event_stateChange() if announceContains: speech.speakMessage(_("%s items")%self.childCount) class BrokenCommctrl5Item(IAccessible): """Handle broken CommCtrl v5 SysTreeView32 items in 64 bit applications. In these controls, IAccessible fails to retrieve any info, so we must retrieve it using UIA. We do this by obtaining a UIA NVDAObject and redirecting properties to it. We can't simply use UIA objects alone for these controls because UIA events are also broken. """ def __init__(self, _uiaObj=None, **kwargs): # This class is being directly instantiated. if not _uiaObj: raise ValueError("Cannot instantiate directly without supplying _uiaObj") self._uiaObj = _uiaObj super(BrokenCommctrl5Item, self).__init__(**kwargs) def initOverlayClass(self): self._uiaObj = None if UIAHandler.handler: parent=super(BrokenCommctrl5Item, self).parent if parent and parent.hasFocus: try: kwargs = {} UIA.kwargsFromSuper(kwargs, relation="focus") self._uiaObj = UIA(**kwargs) except: log.debugWarning("Retrieving UIA focus failed", exc_info=True) def _get_role(self): return self._uiaObj.role if self._uiaObj else controlTypes.ROLE_UNKNOWN def _get_name(self): return self._uiaObj.name if self._uiaObj else None def _get_description(self): return self._uiaObj.description if self._uiaObj else None def _get_value(self): return self._uiaObj.value if self._uiaObj else None def _get_states(self): return self._uiaObj.states if self._uiaObj else set() def _get_positionInfo(self): return self._uiaObj.positionInfo if self._uiaObj else {} def _get_location(self): return self._uiaObj.location if self._uiaObj else None def _makeRelatedObj(self, uiaObj): # We need to wrap related UIA objects so that the ancestry will return to IAccessible for the tree view itself. if not uiaObj: return None return BrokenCommctrl5Item(IAccessibleObject=self.IAccessibleObject, IAccessibleChildID=self.IAccessibleChildID, windowHandle=self.windowHandle, _uiaObj=uiaObj) def _get_parent(self): if self._uiaObj: uiaParent = self._uiaObj.parent # If the parent is the tree view itself (root window object), just use super's parent. IAccessible isn't broken on the container itself. if not uiaParent.UIAElement.cachedNativeWindowHandle: return self._makeRelatedObj(uiaParent) return super(BrokenCommctrl5Item, self).parent def _get_next(self): return self._makeRelatedObj(self._uiaObj.next) if self._uiaObj else None def _get_previous(self): return self._makeRelatedObj(self._uiaObj.previous) if self._uiaObj else None def _get_firstChild(self): return self._makeRelatedObj(self._uiaObj.firstChild) if self._uiaObj else None def _get_lastChild(self): return self._makeRelatedObj(self._uiaObj.lastChild) if self._uiaObj else None def _get_children(self): # Use the base algorithm, which uses firstChild and next. return NVDAObject._get_children(self) @classmethod def getFirstItem(cls, treeObj): """Get an instance for the first item in a given tree view. """ if not UIAHandler.handler: return None # Get a UIA object for the tree view by getting the root object for the window. try: kwargs = {"windowHandle": treeObj.windowHandle} UIA.kwargsFromSuper(kwargs) uiaObj = UIA(**kwargs) except: log.debugWarning("Error retrieving UIA object for tree view", exc_info=True) return None # Get the first tree item. uiaObj = uiaObj.firstChild if not uiaObj: return None # The IAccessibleChildID for this object isn't really used. # However, it must not be 0, as 0 is the tree view itself. return cls(IAccessibleObject=treeObj.IAccessibleObject, IAccessibleChildID=1, windowHandle=treeObj.windowHandle, _uiaObj=uiaObj)
daisymax/nvda
source/NVDAObjects/IAccessible/sysTreeView32.py
Python
gpl-2.0
10,467
0.040222
#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Created on Wed Mar 15 23:06:23 2017 @author: franklin """ # Your task here is to extract data from xml on authors of an article # and add it to a list, one item for an author. # See the provided data structure for the expected format. # The tags for first name, surname and email should map directly # to the dictionary keys import xml.etree.ElementTree as ET article_file = "data/exampleresearcharticle.xml" def get_root(fname): tree = ET.parse(fname) return tree.getroot() def get_author(root): authors = [] for author in root.findall('./fm/bibl/aug/au'): data = { "fnm": None, "snm": None, "email": None } data["fnm"] = author.find('./fnm').text data["snm"] = author.find('./snm').text data["email"] = author.find('./email').text authors.append(data) return authors def test(): solution = [{'fnm': 'Omer', 'snm': 'Mei-Dan', 'email': 'omer@extremegate.com'}, {'fnm': 'Mike', 'snm': 'Carmont', 'email': 'mcarmont@hotmail.com'}, {'fnm': 'Lior', 'snm': 'Laver', 'email': 'laver17@gmail.com'}, {'fnm': 'Meir', 'snm': 'Nyska', 'email': 'nyska@internet-zahav.net'}, {'fnm': 'Hagay', 'snm': 'Kammar', 'email': 'kammarh@gmail.com'}, {'fnm': 'Gideon', 'snm': 'Mann', 'email': 'gideon.mann.md@gmail.com'}, {'fnm': 'Barnaby', 'snm': 'Clarck', 'email': 'barns.nz@gmail.com'}, {'fnm': 'Eugene', 'snm': 'Kots', 'email': 'eukots@gmail.com'}] root = get_root(article_file) data = get_author(root) assert data[0] == solution[0] assert data[1]["fnm"] == solution[1]["fnm"] test()
franklinsales/udacity-data-analyst-nanodegree
project3/class-works/data-wrangling/data-in-more-complex-formats/quiz-extracting-data-corrected.py
Python
mit
1,669
0.001797
"""Benchmark runner. Copyright 2013 by Rackspace Hosting, 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. """ import sys from falcon import bench def fail(returncode, e): sys.stderr.write('\nERROR: %s\n\n' % e) sys.exit(returncode) def main(): try: bench.main() except KeyboardInterrupt: fail(1, 'Interrupted, terminating benchmark') except RuntimeError as e: fail(1, e) if __name__ == '__main__': main()
openilabs/falconlab
env/lib/python2.7/site-packages/falcon/cmd/bench.py
Python
mit
944
0
# -*- coding: utf-8 -*- # This file carries the module's version information which will be updated # during execution of the installation script, setup.py. Distribution tarballs # contain a pre-generated copy of this file. __version__ = '0.2'
EMS-TU-Ilmenau/fastmat
fastmat/version.py
Python
apache-2.0
245
0
# https://www.w3resource.com/python-exercises/ # 1. Write a Python program to print the following string in a specific format (see the output). # Sample String : "Twinkle, twinkle, little star, How I wonder what you are! Up above the world so high, Like a diamond # in the sky. Twinkle, twinkle, little star, How I wonder what you are" Output : # Twinkle, twinkle, little star, # How I wonder what you are! # Up above the world so high, # Like a diamond in the sky. # Twinkle, twinkle, little star, # How I wonder what you are string = """ Twinkle, twinkle, little star, \t\tUp above the world so high, \t\tLike a diamond in the sky. Twinkle, twinkle, little star, \tHow I wonder what you are """ print string
dadavidson/Python_Lab
Python-w3resource/Python_Basic/ex01.py
Python
mit
715
0.00979
#!/usr/bin/python # -*- coding: utf-8 -*- import cairo, Image import gtk, gobject from numpy import cos, sin, pi, sqrt, sort, square,array, zeros, diff,\ column_stack,ones, reshape, linspace, arctan2 from numpy import sum as npsum from numpy.random import random, seed from itertools import count from speedup.speedup import pyx_collision_reject #from speedup.speedup import pyx_growth_branch from speedup.speedup import pyx_growth from speedup.speedup import pyx_segment_attract seed(4) FNAME = './img/xx' BACK = [1]*3 FRONT = [0,0,0,0.7] CONTRASTA = [0.84,0.37,0] # orange CONTRASTB = [0.53,0.53,1] # lightblue CONTRASTC = [0.84,1,0] PI = pi TWOPI = 2.*pi NMAX = 2*1e8 SIZE = 1500 ONE = 1./SIZE STP = ONE*0.9 FARL = 30.*ONE NEARL = 4.*ONE GROW_NEAR_LIMIT = NEARL MID = 0.5 LINEWIDTH = 3.*ONE #### RENDER_ITT = 2000 # redraw this often ZONEWIDTH = FARL/ONE ZONES = int(SIZE/ZONEWIDTH) class Render(object): def __init__(self,n): self.n = n self.__init_cairo() window = gtk.Window() window.resize(self.n, self.n) window.connect("destroy", self.__write_image_and_exit) darea = gtk.DrawingArea() darea.connect("expose-event", self.expose) window.add(darea) window.show_all() self.darea = darea self.num_img = 0 def clear_canvas(self): self.ctx.set_source_rgb(*BACK) self.ctx.rectangle(0,0,1,1) self.ctx.fill() def __write_image_and_exit(self,*args): self.sur.write_to_png('on_exit.png') gtk.main_quit(*args) def __init_cairo(self): sur = cairo.ImageSurface(cairo.FORMAT_ARGB32,self.n,self.n) ctx = cairo.Context(sur) ctx.scale(self.n,self.n) ctx.set_source_rgb(*BACK) ctx.rectangle(0,0,1,1) ctx.fill() self.sur = sur self.ctx = ctx def init_step(self,e): self.step = e #gobject.timeout_add(5,self.step_wrap) gobject.idle_add(self.step_wrap) self.steps = 0 def line(self,x1,y1,x2,y2): self.ctx.set_source_rgba(*FRONT) self.ctx.move_to(x1,y1) self.ctx.line_to(x2,y2) self.ctx.stroke() def circle(self,x,y,r,fill=False): self.ctx.arc(x,y,r,0,pi*2.) if fill: self.ctx.fill() else: self.ctx.stroke() def circles(self,xx,yy,rr,fill=False): if fill: action = self.ctx.fill else: action = self.ctx.stroke for x,y,r in zip(xx,yy,rr): self.ctx.arc(x,y,r,0,TWOPI) action() def circle_stroke(self,x1,y1,x2,y2,r): dx = x1-x2 dy = y1-y2 dd = sqrt(dx*dx+dy*dy) n = int(dd/ONE) n = n if n>2 else 2 a = arctan2(dy,dx) scale = linspace(0,dd,n) xp = x1-scale*cos(a) yp = y1-scale*sin(a) for x,y in zip(xp,yp): self.ctx.arc(x,y,r,0,pi*2.) self.ctx.fill() def expose(self,*args): cr = self.darea.window.cairo_create() cr.set_source_surface(self.sur,0,0) cr.paint() def step_wrap(self,*args): res = self.step() self.steps += 1 if not self.steps%RENDER_ITT: self.expose() return res class Line(object): def __init__(self): self.X = zeros((NMAX,2),'float') self.SV = zeros((NMAX,2),'int') self.SVMASK = zeros(NMAX,'int') self.VS = {} self.vnum = 0 self.snum = 0 self.sind = 0 self.ZV = [[] for i in xrange((ZONES+2)**2)] self.VZ = zeros(NMAX,'int') def _add_vertex(self,x): """ add vertex loctated at x. zone maps are updated. """ vnum = self.vnum self.X[vnum,:] = x z = get_z(x,ZONES) self.ZV[z].append(vnum) self.VZ[vnum] = z self.vnum += 1 return self.vnum-1 def update_zone_maps(self): """ check if vertices have changed zone, and update those that have. """ vnum = self.vnum zz = get_zz(self.X[:vnum,:],ZONES) mask = (zz != self.VZ[:vnum]).nonzero()[0] for bad_v in mask: new_z = zz[bad_v] old_z = self.VZ[bad_v] new = [v for v in self.ZV[old_z] if v != bad_v] self.ZV[old_z] = new self.ZV[new_z].append(bad_v) self.VZ[mask] = zz[mask] def _add_segment(self,a,b): """ add new segment between vertices a,b. """ self.SV[self.sind,:] = [a,b] self.SVMASK[self.sind] = 1 add = make_dict_list_add(self.VS) add(a,self.sind) add(b,self.sind) self.sind += 1 self.snum += 1 return self.sind-1 def _add_vertex_segment(self,x,a): """ add new vertex x connected to vertex a with a new segment. """ v = self._add_vertex(x) self._add_segment(v,a) def _delete_segment(self,a): """ delete segment a and related connections. """ vv = self.SV[a,:] self.SVMASK[a] = 0 self.snum -= 1 for v in vv: if self.VS.has_key(v): vs = [s for s in self.VS[v] if s!=a] if len(vs)>0: self.VS[v] = vs else: del(self.VS[v]) return vv def split_segment(self,a): """ add new vertex, v, at the middle of segment a with vertices: [v0,v1] creates new segments b,c such that: v0 -b- v -c- v1 """ vv = self.SV[a,:] midx = (self.X[vv[1],0] + self.X[vv[0],0])*0.5 midy = (self.X[vv[1],1] + self.X[vv[0],1])*0.5 #TODO: improve newv = self._add_vertex([midx,midy]) self._delete_segment(a) b = self._add_segment(vv[0],newv) c = self._add_segment(vv[1],newv) return newv, [b,c] def make_dict_list_add(d): def add(k,v): if d.has_key(k): d[k].append(v) else: d[k] = [v] return add def get_z(x,nz): """ find zone z of x. we have nz zones in each direction. """ i = 1+int(x[0]*nz) j = 1+int(x[1]*nz) z = i*nz+j return z def get_zz(xx,nz): """ same as get_z for a vector of points. """ ij = (xx*nz).astype('int') zz = ij[:,0]*(nz+2) + ij[:,1]+1 return zz def init_circle(l,ix,iy,r,n): th = sort(random(n)*TWOPI) rad = (0.9 + 0.1*(0.5-random(n)))*r xx = column_stack( (ix+cos(th)*rad, iy+sin(th)*rad) ) vv = [] for x in xx: vv.append(l._add_vertex(x)) for i in xrange(len(vv)-1): seg = l._add_segment(vv[i],vv[i+1]) l._add_segment(vv[0],vv[-1]) def init_horizontal_line(l,x1,x2,y1,y2,n): x = sort(x1+(x2-x1)*random(n)) y = y1 + (y2-y1)*random(n) xx = column_stack((x,y)) vv = [] for x in xx: vv.append(l._add_vertex(x)) for i in xrange(len(vv)-1): seg = l._add_segment(vv[i],vv[i+1]) if i == 0: first = seg def main(): L = Line() render = Render(SIZE) init_circle(L,MID,MID,0.001,50) #init_horizontal_line(L,MID-0.2,MID+0.2,MID-0.001,MID+0.001,100) SX = zeros((NMAX,2),'float') def show(render,l): render.clear_canvas() render.ctx.set_source_rgba(*FRONT) render.ctx.set_line_width(LINEWIDTH) for vv in l.SV[:l.sind,:][l.SVMASK[:l.sind]>0,:]: render.circle_stroke(l.X[vv[0],0],l.X[vv[0],1], l.X[vv[1],0],l.X[vv[1],1], ONE*2) def step(): rnd1 = random(L.sind) #rnd2 = random(L.sind) pyx_growth(L,rnd1,GROW_NEAR_LIMIT) #pyx_growth_branch(L,rnd1,rnd2,GROW_NEAR_LIMIT) L.update_zone_maps() if not render.steps%RENDER_ITT: show(render,L) print 'steps:',render.steps,'vnum:',L.vnum,'snum:',L.snum fn = '{:s}_nearl{:0.0f}_itt{:07d}.png' fn = fn.format(FNAME,FARL/ONE,render.steps) render.sur.write_to_png(fn) vnum = L.vnum SX[:vnum,:] = 0. pyx_segment_attract(L,SX[:vnum,:],NEARL) pyx_collision_reject(L,SX[:vnum,:],FARL,ZONES) SX[:vnum,:] *= STP L.X[:vnum,:] += SX[:vnum,:] return True render.init_step(step) gtk.main() if __name__ == '__main__' : if True: import pstats, cProfile fn = './profile/profile' cProfile.run('main()',fn) p = pstats.Stats(fn) p.strip_dirs().sort_stats('cumulative').print_stats() else: main()
inconvergent/differential_ani
differential.py
Python
mit
7,824
0.034126
# -*- coding: utf-8 -*- import classes.level_controller as lc import classes.game_driver as gd import classes.extras as ex import classes.board import random import math import pygame class Board(gd.BoardGame): def __init__(self, mainloop, speaker, config, screen_w, screen_h): self.level = lc.Level(self,mainloop,999,1) gd.BoardGame.__init__(self,mainloop,speaker,config,screen_w,screen_h,11,9) def create_game_objects(self, level = 1): self.board.draw_grid = False color = ex.hsv_to_rgb(225,15,235) color2 = (255,255,255) self.col_r = (255,0,0) self.col_g = (0,255,0) self.col_b = (0,0,255) self.col_k = (0,0,0) self.col_e = (255,255,255) colorkey = (2,2,2) self.col_bg = (255,255,255) #self.col_k #(255,246,219) data = [32,23] #stretch width to fit the screen size x_count = self.get_x_count(data[1],even=True) if x_count > 32: data[0] = x_count self.data = data self.points = 20 self.vis_buttons = [1,0,0,0,1,1,1,0,0] self.mainloop.info.hide_buttonsa(self.vis_buttons) self.layout.update_layout(data[0],data[1]) scale = self.layout.scale self.board.level_start(data[0],data[1],scale) self.board.board_bg.initcolor = self.col_bg self.board.board_bg.color = self.col_bg self.board.board_bg.update_me = True self.board.moved = self.moved self.choice_list = [] step = 255 / 20.0 for i in range(21): self.choice_list.append(int(255 - i*step)) self.picked = [] for i in range(3): self.picked.append(self.choice_list[random.randrange(0,len(self.choice_list))]) y = data[1]-3 self.rgb_g = [y,y,y] self.rgbx3 = [self.col_k,self.col_k,self.col_k] self.board.add_unit(1,y,2,3,classes.board.ImgAlphaShip,"",self.col_r,"light_r.png") self.board.add_unit(4,y,2,3,classes.board.ImgAlphaShip,"",self.col_g,"light_g.png") self.board.add_unit(7,y,2,3,classes.board.ImgAlphaShip,"",self.col_b,"light_b.png") for each in self.board.ships: each.outline = False each.audible = False each.image.set_colorkey(each.initcolor) #add colour circles - canvas self.board.add_unit(10,0,data[0]-10,data[1],classes.board.Label,"",self.col_e,"",0) self.canvas = self.board.units[0] self.canvas_center = [(self.canvas.grid_w*self.board.scale)//2,(self.canvas.grid_h*self.board.scale)//2] #adding borders between the colour tubes self.board.add_unit(0,0,1,data[1],classes.board.Label,"",self.col_bg,"",0) self.board.add_unit(3,0,1,data[1],classes.board.Label,"",self.col_bg,"",0) self.board.add_unit(6,0,1,data[1],classes.board.Label,"",self.col_bg,"",0) self.board.add_unit(9,0,1,data[1],classes.board.Label,"",self.col_bg,"",0) #adding colour guides self.board.add_door(1,0,2,data[1],classes.board.Door,"",color,"",0) self.board.units[-1].set_outline(self.col_r, 1) self.board.add_door(4,0,2,data[1],classes.board.Door,"",color,"",0) self.board.units[-1].set_outline(self.col_g, 1) self.board.add_door(7,0,2,data[1],classes.board.Door,"",color,"",0) self.board.units[-1].set_outline(self.col_b, 1) #adding colour strips self.board.add_door(1,data[1]-1,2,1,classes.board.Door,"",self.col_r,"",0) self.board.add_door(4,data[1]-1,2,1,classes.board.Door,"",self.col_g,"",0) self.board.add_door(7,data[1]-1,2,1,classes.board.Door,"",self.col_b,"",0) #black background self.board.add_door(1,0,2,data[1],classes.board.Door,"",self.col_k,"",0) self.board.units[-1].image.set_colorkey(None) self.board.add_door(4,0,2,data[1],classes.board.Door,"",self.col_k,"",0) self.board.units[-1].image.set_colorkey(None) self.board.add_door(7,0,2,data[1],classes.board.Door,"",self.col_k,"",0) self.board.units[-1].image.set_colorkey(None) for i in [5,6,7,8,9,10,11,12,13]: if i>7: self.board.units[i].image.set_colorkey(colorkey) self.board.all_sprites_list.move_to_back(self.board.units[i]) else: self.board.all_sprites_list.move_to_front(self.board.units[i]) self.canvas.set_outline((255,75,0),1) self.canv = [] for i in range(4): self.canv.append(pygame.Surface([self.canvas.grid_w*self.board.scale, self.canvas.grid_h*self.board.scale-1])) self.board.all_sprites_list.move_to_back(self.board.board_bg) self.mix() def mix(self): for i in range(3): self.rgb_g[i] = self.board.ships[i].grid_y self.update_sliders() self.canv[3].fill(self.col_k) ct = self.canvas_center radius = 9*self.board.scale radius2 = 5*self.board.scale x = 1*self.board.scale rect = [[ct[0],ct[1]-x],[ct[0]-x,ct[1]+x],[ct[0]+x,ct[1]+x]] for i in range(3): pygame.draw.circle(self.canv[i], self.rgbx3[i], rect[i], radius, 0) self.canv[3].blit(self.canv[i],[0,0],special_flags = pygame.BLEND_ADD) pygame.draw.circle(self.canv[3], self.picked, ct, radius2, 0) self.canvas.painting = self.canv[3].copy() self.canvas.update_me = True def update_sliders(self): for i in range(3): strip = self.board.units[i+8] strip.grid_y = self.rgb_g[i]+3-3 strip.grid_h = self.data[1]-strip.grid_y+3 col = [] for each in strip.initcolor: if each > 0: if strip.grid_y == 20: col.append(0) elif strip.grid_y == 0: col.append(255) else: step = 255 / 20.0 col.append(int(255 - (strip.grid_y) * step)) else: col.append(0) self.rgbx3[i] = col strip.color = col strip.pos_update() strip.update_me = True def moved(self): self.mix() def handle(self,event): gd.BoardGame.handle(self, event) #send event handling up def update(self,game): game.fill((0,0,0)) gd.BoardGame.update(self, game) #rest of painting done by parent def check_result(self): r = self.rgbx3[0][0] g = self.rgbx3[1][1] b = self.rgbx3[2][2] if self.picked != [r,g,b]: help = "" if self.picked[0] > r: help += self.dp['more red'] + ", " elif self.picked[0] < r: help += self.dp['less red'] + ", " else: help += self.dp['red is ok'] + ", " if self.picked[1] > g: help += self.dp['more green'] + ", " elif self.picked[1] < g: help += self.dp['less green'] + ", " else: help += self.dp['green is ok'] + ", " if self.picked[2] > b: help += self.dp['more blue'] + ". " elif self.picked[2] < b: help += self.dp['less blue'] + ". " else: help += self.dp['blue is ok'] + ". " self.say(help) if self.points > 0: self.points -= 1 self.level.try_again(silent = self.mainloop.speaker.talkative) else: self.update_score(self.points) self.level.next_board()
OriHoch/pysiogame
game_boards/game054.py
Python
gpl-3.0
7,891
0.034216
from os.path import join, expanduser from subprocess import Popen from unittest import skipIf from unittest.mock import ANY, call, MagicMock, Mock from genty import genty, genty_dataset import re from app.project_type.git import Git from app.util.conf.configuration import Configuration from app.util.process_utils import is_windows, get_environment_variable_setter_command from test.framework.base_unit_test_case import BaseUnitTestCase from test.framework.comparators import AnyStringMatching @genty class TestGit(BaseUnitTestCase): def setUp(self): super().setUp() self.patch('app.project_type.git.fs.create_dir') self.patch('os.unlink') self.patch('os.symlink') self.os_path_exists_mock = self.patch('app.project_type.git.os.path.exists') self.os_path_exists_mock.return_value = False self.os_path_isfile_mock = self.patch('app.project_type.git.os.path.isfile') self.os_path_isfile_mock.return_value = False def test_timing_file_path_happy_path(self): git_env = Git("ssh://scm.dev.box.net/box/www/current", 'origin', 'refs/changes/78/151978/27') actual_timing_file_sys_path = git_env.timing_file_path('QUnit') expected_timing_file_sys_path = join( Configuration['base_directory'], 'timings', 'master', 'scm.dev.box.net', 'box', 'www', 'current', 'QUnit.timing.json', ) self.assertEquals(expected_timing_file_sys_path, actual_timing_file_sys_path) def test_execute_command_in_project_specifies_cwd_if_exists(self): self.os_path_exists_mock.return_value = True project_type_popen_patch = self._patch_popen() fake_project_directory = 'proj_dir' fake_command = 'some_command' git_env = Git("ssh://scm.dev.box.net/box/www/current", 'origin', 'refs/changes/78/151978/27') git_env.project_directory = fake_project_directory git_env.execute_command_in_project(fake_command) env_setter = get_environment_variable_setter_command('PROJECT_DIR', fake_project_directory) project_type_popen_patch.assert_called_once_with( '{} {}'.format(env_setter, fake_command), cwd=fake_project_directory, shell=ANY, stdout=ANY, stderr=ANY, start_new_session=ANY, ) def test_execute_command_in_project_type_specifies_cwd_if_doesnt_exist(self): project_type_popen_patch = self._patch_popen() fake_project_directory = 'proj_dir' fake_command = 'some_command' git_env = Git("ssh://scm.dev.box.net/box/www/current", 'origin', 'refs/changes/78/151978/27') git_env.project_directory = fake_project_directory git_env.execute_command_in_project(fake_command) env_setter = get_environment_variable_setter_command('PROJECT_DIR', fake_project_directory) project_type_popen_patch.assert_called_once_with( '{} {}'.format(env_setter, fake_command), cwd=None, shell=ANY, stdout=ANY, stderr=ANY, start_new_session=ANY, ) @genty_dataset( regular_path=( 'http://scm.example.com/path/to/project', join('scm.example.com', 'path', 'to', 'project') ), with_netloc=( 'ssh://scm.dev.box.net:12345/awesome-project', join('scm.dev.box.net12345', 'awesomeproject') ), no_netloc=( 'git.dev.box.net:Productivity/ClusterRunnerHealthCheck', join('git.dev.box.net', 'Productivity', 'ClusterRunnerHealthCheck') ), ) def test_get_full_repo_directory(self, url, expected_repo_path_without_base): Configuration['repo_directory'] = join(expanduser('~'), '.clusterrunner', 'repos') expected_repo_path = join( Configuration['repo_directory'], expected_repo_path_without_base, ) actual_repo_path = Git.get_full_repo_directory(url) self.assertEqual(expected_repo_path, actual_repo_path) def test_get_timing_file_directory(self): Configuration['timings_directory'] = join(expanduser('~'), '.clusterrunner', 'timing') url = 'http://scm.example.com/path/to/project' actual_timings_sys_path = Git.get_timing_file_directory(url) expected_timings_sys_path = join( Configuration['timings_directory'], 'scm.example.com', 'path', 'to', 'project', ) self.assertEqual(expected_timings_sys_path, actual_timings_sys_path) def test_get_repo_directory_removes_colon_from_directory_if_exists(self): Configuration['repo_directory'] = join(expanduser('~'), 'tmp', 'repos') git = Git("some_remote_value", 'origin', 'ref/to/some/branch') actual_repo_directory = git.get_full_repo_directory('ssh://source_control.cr.com:1234/master') expected_repo_directory = join( Configuration['repo_directory'], 'source_control.cr.com1234', 'master' ) self.assertEqual(expected_repo_directory, actual_repo_directory) def test_get_timing_file_directory_removes_colon_from_directory_if_exists(self): Configuration['timings_directory'] = join(expanduser('~'), 'tmp', 'timings') git = Git("some_remote_value", 'origin', 'ref/to/some/branch') actual_timing_directory = git.get_timing_file_directory('ssh://source_control.cr.com:1234/master') expected_timing_directory = join( Configuration['timings_directory'], 'source_control.cr.com1234', 'master', ) self.assertEqual(expected_timing_directory, actual_timing_directory) @genty_dataset( shallow_clone_false=(False, True), shallow_clone_true=(True, False), ) def test_fetch_project_with_pre_shallow_cloned_repo(self, shallow_clone, should_delete_clone): Configuration['shallow_clones'] = shallow_clone self.os_path_isfile_mock.return_value = True self.os_path_exists_mock.return_value = True mock_fs = self.patch('app.project_type.git.fs') mock_rmtree = self.patch('shutil.rmtree') git = Git('url') git._repo_directory = 'fake/repo_path' git._execute_and_raise_on_failure = MagicMock() git.execute_command_in_project = Mock(return_value=('', 0)) mock_fs.create_dir.call_count = 0 # only measure calls made in _fetch_project mock_rmtree.call_count = 0 git._fetch_project() if should_delete_clone: mock_rmtree.assert_called_once_with('fake/repo_path') else: self.assertFalse(mock_rmtree.called) @genty_dataset( failed_rev_parse=(1, True), successful_rev_parse=(0, False), ) def test_repo_is_cloned_if_and_only_if_rev_parse_fails(self, rev_parse_return_code, expect_git_clone_call): mock_popen = self._patch_popen({ 'git rev-parse$': _FakePopenResult(return_code=rev_parse_return_code) }) Configuration['repo_directory'] = '/repo-directory' git = Git(url='http://original-user-specified-url.test/repo-path/repo-name') git.fetch_project() git_clone_call = call(AnyStringMatching('git clone'), start_new_session=ANY, stdout=ANY, stderr=ANY, cwd=ANY, shell=ANY) if expect_git_clone_call: self.assertIn(git_clone_call, mock_popen.call_args_list, 'If "git rev-parse" returns a failing exit code, ' '"git clone" should be called.') else: self.assertNotIn(git_clone_call, mock_popen.call_args_list, 'If "git rev-parse" returns a successful exit ' 'code, "git clone" should not be called.') @genty_dataset( shallow_clone=(True,), no_shallow_clone=(False,), ) def test_fetch_project_passes_depth_parameter_for_shallow_clone_configuration(self, shallow_clone): Configuration['shallow_clones'] = shallow_clone self.os_path_isfile_mock.return_value = False self.os_path_exists_mock.return_value = False mock_popen = self._patch_popen({'git rev-parse$': _FakePopenResult(return_code=1)}) git = Git(url='http://original-user-specified-url.test/repo-path/repo-name') git.fetch_project() git_clone_call = call(AnyStringMatching('git clone --depth=1'), start_new_session=ANY, stdout=ANY, stderr=ANY, cwd=ANY, shell=ANY) if shallow_clone: self.assertIn(git_clone_call, mock_popen.call_args_list, 'If shallow cloning, the --depth=1 parameter ' 'should be present.') else: self.assertNotIn(git_clone_call, mock_popen.call_args_list, 'If deep cloning, the --depth=1 parameter ' 'must be absent.') @genty_dataset( strict_host_checking_is_on=(True,), strict_host_checking_is_off=(False,), ) def test_execute_git_command_auto_sets_strict_host_option_correctly(self, strict_host_check_setting): Configuration['git_strict_host_key_checking'] = strict_host_check_setting popen_mock = self._patch_popen() git = Git(url='http://some-user-url.com/repo-path/repo-name') git._execute_git_command_in_repo_and_raise_on_failure('fakecmd') if strict_host_check_setting: expected_ssh_arg = '-o StrictHostKeyChecking=yes' else: expected_ssh_arg = '-o StrictHostKeyChecking=no' expected_call = call(AnyStringMatching(expected_ssh_arg), start_new_session=ANY, stdout=ANY, stderr=ANY, cwd=ANY, shell=ANY) self.assertIn(expected_call, popen_mock.call_args_list, 'Executed git command should include the correct ' 'option for StrictHostKeyChecking.') @skipIf(is_windows(), 'Skipping test for cloning repo from master on Windows') def test_slave_param_overrides_returns_expected(self): Configuration['get_project_from_master'] = True Configuration['repo_directory'] = '/repo-directory' self._patch_popen({ 'git rev-parse FETCH_HEAD': _FakePopenResult(stdout='deadbee123\n') }) git = Git(url='http://original-user-specified-url.test/repo-path/repo-name') git.fetch_project() actual_overrides = git.slave_param_overrides() expected_overrides = { 'url': 'ssh://fake_hostname/repodirectory/originaluserspecifiedurl.test/repopath/reponame', 'branch': 'refs/clusterrunner/deadbee123', } self.assertEqual(expected_overrides, actual_overrides, 'Slave param overrides from Git object should match' 'expected.') def test_slave_param_overrides_when_get_project_from_master_is_disabled(self): Configuration['get_project_from_master'] = False git = Git(url='http://original-user-specified-url.test/repo-path/repo-name') actual_overrides = git.slave_param_overrides() self.assertFalse( 'url' in actual_overrides, '"url" should not be in the params to override when "get_project_from_master" is False', ) self.assertFalse( 'branch' in actual_overrides, '"branch" should not be in the params to override when "get_project_from_master" is False', ) def _patch_popen(self, command_to_result_map=None): """ Mock out calls to Popen to inject fake results for specific command strings. :param command_to_result_map: A dict that maps a command string regex to a _FakePopenResult object :type command_to_result_map: dict[str, _FakePopenResult] :return: The patched popen constructor mock :rtype: MagicMock """ command_to_result_map = command_to_result_map or {} self.patch('app.project_type.project_type.TemporaryFile', new=lambda: Mock()) project_type_popen_patch = self.patch('app.project_type.project_type.Popen_with_delayed_expansion') def fake_popen_constructor(command, stdout, stderr, *args, **kwargs): fake_result = _FakePopenResult() # default value for command_regex in command_to_result_map: if re.search(command_regex, command): fake_result = command_to_result_map[command_regex] break stdout.read.return_value = fake_result.stdout.encode() return Mock(spec=Popen, returncode=fake_result.return_code) project_type_popen_patch.side_effect = fake_popen_constructor return project_type_popen_patch class _FakePopenResult: def __init__(self, return_code=0, stdout='', stderr=''): self.return_code = return_code self.stdout = stdout self.stderr = stderr
box/ClusterRunner
test/unit/project_type/test_git.py
Python
apache-2.0
13,290
0.004138
''' Created on Mar 22, 2011 @author: jeroen ''' import os from fileinfo import FileInfo from bytesize import ByteSize class DirInfo(object): ''' Simple class to represent a directory and obtain data about if when needed. ''' def __init__(self, path, recursive=False): ''' Constructor ''' self._path = path self._initiated = False self._recursive = recursive self._files = [] self._dirs = [] self._filecount = 0 self._dircount = 0 self._totalsize = -1 self._codelines = 0 self._commentlines = 0 self._whitespacelines = 0 ''' Check if the dir data is cached, and if not, obtain it. ''' def _init_if_needed(self): if not self._initiated: self._initiated = True self._get_dir_info(self._path) def _get_dir_info(self, rootdir): for item in os.listdir(rootdir): fullname = os.path.join(rootdir, item) if not item.startswith('.') and not os.path.islink(fullname): if os.path.isdir(fullname): dir = DirInfo(fullname, self._recursive) self._dirs.append(dir) self._dircount += 1 if self._recursive: self._filecount += dir.get_filecount() self._dircount += dir.get_dircount() self._totalsize += dir.get_totalsize() self._codelines += dir.get_code_lines() self._commentlines += dir.get_comment_lines() self._whitespacelines += dir.get_whitespace_lines() else: file = FileInfo(rootdir, item) self._files.append(file) self._filecount += 1 self._totalsize += file.get_filesize() self._codelines += file.get_code_lines() self._commentlines += file.get_comment_lines() self._whitespacelines += file.get_whitespace_lines() def __repr__(self, recursive=None): self.set_recursive(recursive) self._init_if_needed() return "%s (%s dirs, %s files, %s lines: %s code, %s comment, %s empty) %s" % ( self._path, self._dircount, self._filecount, self.get_line_count(), self.get_code_lines(), self.get_comment_lines(), self.get_whitespace_lines(), ByteSize(self._totalsize).__repr__() ) ''' Sets that the directory should report data obtained recursivly, or only look at what's directly in it. Note that changing the recursive setting invalidates the cached info. ''' def set_recursive(self, recursive): if recursive is not None and recursive != self._recursive: self._recursive = recursive self._initiated = False def get_files(self): self._init_if_needed() return self._files def get_dirs(self): self._init_if_needed() return self._dirs def get_path(self): return self._path def get_totalsize(self): self._init_if_needed() return self._totalsize def get_code_lines(self): self._init_if_needed() return self._codelines def get_comment_lines(self): self._init_if_needed() return self._commentlines def get_whitespace_lines(self): self._init_if_needed() return self._whitespacelines def get_line_count(self): self._init_if_needed() return self._codelines + self._commentlines + self._whitespacelines def get_filecount(self): self._init_if_needed() return self._filecount def get_dircount(self): self._init_if_needed() return self._dircount
JeroenDeDauw/phpstat
src/phpstat/dirinfo.py
Python
gpl-3.0
4,098
0.006833
from math import log from PIL import Image, ImageDraw my_data = [['slashdot', 'USA', 'yes', 18, 'None'], ['google', 'France', 'yes', 23, 'Premium'], ['digg', 'USA', 'yes', 24, 'Basic'], ['kiwitobes', 'France', 'yes', 23, 'Basic'], ['google', 'UK', 'no', 21, 'Premium'], ['(direct)', 'New Zealand', 'no', 12, 'None'], ['(direct)', 'UK', 'no', 21, 'Basic'], ['google', 'USA', 'no', 24, 'Premium'], ['slashdot', 'France', 'yes', 19, 'None'], ['digg', 'USA', 'no', 18, 'None'], ['google', 'UK', 'no', 18, 'None'], ['kiwitobes', 'UK', 'no', 19, 'None'], ['digg', 'New Zealand', 'yes', 12, 'Basic'], ['slashdot', 'UK', 'no', 21, 'None'], ['google', 'UK', 'yes', 18, 'Basic'], ['kiwitobes', 'France', 'yes', 19, 'Basic']] class decisionnode(object): """docstring for decisionnode""" def __init__(self, col=-1, value=None, results=None, tb=None, fb=None): self.col = col self.value = value self.results = results self.tb = tb self.fb = fb def divideset(rows, column, value): split_function = None if isinstance(value, int) or isinstance(value, float): split_function = lambda row: row[column] >= value else: split_function = lambda row: row[column] == value set1 = [row for row in rows if split_function(row)] set2 = [row for row in rows if not split_function(row)] return (set1, set2) def uniquecounts(rows): results = {} for row in rows: r = row[-1] results.setdefault(r, 0) results[r] += 1 return results def giniimpurity(rows): total = len(rows) counts = uniquecounts(rows) imp = 0 for k1 in counts: p1 = float(counts[k1]) / total imp += p1 * (1 - p1) return imp def entropy(rows): total = len(rows) log2 = lambda x: log(x) / log(2) results = uniquecounts(rows) ent = 0.0 for r in results.keys(): p = float(results[r]) / total ent -= p * log2(p) return ent def buildtree(rows, scoref=entropy): if len(rows) == 0: return decisionnode() current_score = scoref(rows) best_gain = 0.0 best_criteria = None best_sets = None column_count = len(rows[0]) - 1 for col in xrange(column_count): column_values = {} for row in rows: column_values.setdefault(row[col], 1) for value in column_values.keys(): (set1, set2) = divideset(rows, col, value) p = float(len(set1)) / len(rows) gain = current_score - p * scoref(set1) - (1 - p) * scoref(set2) if gain > best_gain and len(set1) > 0 and len(set2) > 0: best_gain = gain best_criteria = (col, value) best_sets = (set1, set2) if best_gain > 0: trueBranch = buildtree(best_sets[0]) falseBranch = buildtree(best_sets[1]) return decisionnode(col=best_criteria[0], value=best_criteria[1], tb=trueBranch, fb=falseBranch) else: return decisionnode(results=uniquecounts(rows)) def printtree(tree, indent=''): if tree.results != None: print str(tree.results) else: print '%s:%s?' % (str(tree.col), str(tree.value)) print indent + 'T->' printtree(tree.tb, indent + '--') print indent + 'F->' printtree(tree.fb, indent + '--') def getwidth(trees): if trees.tb is None and trees.fb is None: return 1 else: return getwidth(trees.tb) + getwidth(trees.fb) def getdepth(trees): if trees.tb is None and trees.fb is None: return 0 else: return max(getdepth(trees.tb), getdepth(trees.fb)) + 1 def drawtrees(trees, jpeg='trees.jpg', widdelta=100, depdelta=100): w = getwidth(trees) * widdelta h = getdepth(trees) * depdelta + 120 img = Image.new('RGB', (w, h), (255, 255, 255)) draw = ImageDraw.Draw(img) drawnode(draw, trees, w / 2, 20, widdelta, depdelta) img.save(jpeg, 'JPEG') def drawnode(draw, trees, x, y, widdelta=100, depdelta=100): if trees.results is None: wf = getwidth(trees.fb) * widdelta wt = getwidth(trees.tb) * widdelta left = x - (wf + wt) / 2 right = x + (wf + wt) / 2 if isinstance(trees.value, int) or isinstance(trees.value, float): draw.text((x - 20, y - 10), '%s:>=%s?\n' % (str(trees.col), str(trees.value)), (0, 0, 0)) else: draw.text((x - 20, y - 10), '%s:==%s?\n' % (str(trees.col), str(trees.value)), (0, 0, 0)) draw.line((x, y, left + wf / 2, y + depdelta), fill=(255, 0, 0)) draw.line((x, y, right - wt / 2, y + depdelta), fill=(255, 0, 0)) drawnode(draw, trees.fb, left + wf / 2, y + depdelta, widdelta, depdelta) drawnode(draw, trees.tb, right - wt / 2, y + depdelta, widdelta, depdelta) else: txt = ' \n'.join(['%s:%d' % v for v in trees.results.items()]) draw.text((x - 20, y), txt, (0, 0, 0)) def classify(obs, tree): if tree.results is not None: return tree.results else: v = obs[tree.col] branch = None if isinstance(v, int) or isinstance(v, float): if v >= tree.value: branch = tree.tb else: branch = tree.fb else: if v == tree.value: branch = tree.tb else: branch = tree.fb return classify(obs, branch) def prune(tree, mingain): if tree.tb.results is None: prune(tree.tb, mingain) if tree.fb.results is None: prune(tree.fb, mingain) if tree.tb.results is not None and tree.fb.results is not None: tb, fb = [], [] for v, c in tree.tb.results.items(): tb += [[v]] * c for v, c in tree.fb.results.items(): fb += [[v]] * c delta = entropy(tb + fb) - (entropy(tb) + entropy(fb)) / 2 if delta < mingain: tree.tb, tree.fb = None, None tree.results = uniquecounts(tb + fb) def mdclassify(obs, tree): if tree.results is not None: return tree.results else: v=obs[tree.col] if v is None: tr, fr = mdclassify(obs, tree.tb), mdclassify(obs, tree.fb) tcount = sum(tr.values()) fcount = sum(fr.values()) tw = float(tcount)/(tcount+fcount) fw = float(fcount)/(tcount+fcount) result = {} for k,v in tr.items(): result.setdefault(k, v*tw) for k,v in fr.items(): result.setdefault(k, 0) result[k] += v*fw return result else: if isinstance(v, int) or isinstance(v, float): if v>=tree.value: branch = tree.tb else: branch = tree.fb else: if v == tree.value: branch = tree.tb else: branch = tree.fb return mdclassify(obs, branch) def variance(rows): if len(rows)==0: return 0 data = [float(row[-1]) for row in rows] mean = sum(data)/len(data) variance = sum([(d-mean)**2 for d in data])/len(data) return variance
luoshao23/ML_algorithm
Decission_Tree/tree.py
Python
mit
7,395
0.002299
"""Tests for coil."""
marineam/coil
coil/test/__init__.py
Python
mit
22
0
from django.contrib.auth.models import User from pandas import read_csv, notnull, DataFrame from numpy import isnan from django.test import TestCase from rhizome.models.campaign_models import Campaign, CampaignType, \ DataPointComputed, AggDataPoint from rhizome.models.location_models import Location, LocationType, \ LocationTree from rhizome.models.indicator_models import Indicator, IndicatorTag, \ IndicatorToTag, CalculatedIndicatorComponent from rhizome.models.document_models import Document, SourceSubmission from rhizome.models.datapoint_models import DataPoint from rhizome.cache_meta import LocationTreeCache from rhizome.tests.setup_helpers import TestSetupHelpers class AggRefreshTestCase(TestCase): ''' ''' def __init__(self, *args, **kwargs): super(AggRefreshTestCase, self).__init__(*args, **kwargs) def setUp(self): self.ts = TestSetupHelpers() data_df = read_csv('rhizome/tests/_data/calc_data.csv') self.create_metadata() self.user = User.objects.get(username="test") self.test_df = data_df[data_df['is_raw'] == 1] self.target_df = data_df[data_df['is_raw'] == 0] self.campaign_id = Campaign.objects.all()[0].id self.top_lvl_location = Location.objects.filter(name='Nigeria')[0] ltr = LocationTreeCache() ltr.main() def create_metadata(self): ''' Creating the Indicator, location, Campaign, meta data needed for the system to aggregate / caclulate. ''' read_csv('rhizome/tests/_data/campaigns.csv') location_df = read_csv('rhizome/tests/_data/locations.csv') indicator_df = read_csv('rhizome/tests/_data/indicators.csv') user_id = User.objects.create_user('test', 'john@john.com', 'test').id self.location_type1 = LocationType.objects.create(admin_level=0, name="country", id=1) self.location_type2 = LocationType.objects.create(admin_level=1, name="province", id=2) campaign_type1 = CampaignType.objects.create(name='test') self.locations = self.model_df_to_data(location_df, Location) self.indicators = self.model_df_to_data(indicator_df, Indicator) ind_tag = IndicatorTag.objects.create(tag_name='Polio') sub_tag = IndicatorTag.objects.create(tag_name='Polio Management', parent_tag_id=ind_tag.id) ind_to_tag_batch = [IndicatorToTag( **{'indicator_tag_id': sub_tag.id, 'indicator_id': ind.id}) for ind in self.indicators] IndicatorToTag.objects.bulk_create(ind_to_tag_batch) self.campaign_id = Campaign.objects.create( start_date='2016-01-01', end_date='2016-01-02', campaign_type_id=campaign_type1.id ).id document = Document.objects.create( doc_title='test', created_by_id=user_id, guid='test') self.ss = SourceSubmission.objects.create( document_id=document.id, submission_json='', row_number=0, data_date='2016-01-01' ).id def model_df_to_data(self, model_df, model): meta_ids = [] non_null_df = model_df.where((notnull(model_df)), None) list_of_dicts = non_null_df.transpose().to_dict() for row_ix, row_dict in list_of_dicts.iteritems(): row_id = model.objects.create(**row_dict) meta_ids.append(row_id) return meta_ids def create_raw_datapoints(self): for row_ix, row_data in self.test_df.iterrows(): dp_id = self.create_datapoint(row_data.location_id, row_data .data_date, row_data.indicator_id, row_data.value) # def create_datapoint(self, **kwargs): def create_datapoint(self, location_id, data_date, indicator_id, value): ''' Right now this is being performed as a database insert. I would like to Test this against the data entry resource, but this will do for now in order to test caching. ''' document_id = Document.objects.get(doc_title='test').id ss_id = SourceSubmission.objects.get(document_id=document_id).id dp = DataPoint.objects.create( location_id=location_id, data_date=data_date, indicator_id=indicator_id, campaign_id=self.campaign_id, value=value, source_submission_id=ss_id, unique_index=str(location_id) + str(data_date) + str(self.campaign_id) + str(indicator_id) ) return dp def test_location_aggregation(self): ''' Using the calc_data.csv, create a test_df and target_df. Ensure that the aggregation and calcuation are working properly, but ingesting the stored data, running the cache, and checking that the calculated data for the aggregate location (parent location, in this case Nigeria) is as expected. In addition to the datapoints in the test file, i insert a null valu to ensure that any null won't corrpupt the calculation. python manage.py test rhizome.tests.test_agg.AggRefreshTestCase. test_location_aggregation --settings=rhizome.settings.test ''' self.create_raw_datapoints() indicator_id, data_date, raw_location_id,\ agg_location_id, null_location_id, NaN_location_id = \ 22, '2016-01-01', 12910, 12907, 12928, 12913 location_ids = Location.objects.filter( parent_location_id=agg_location_id).values_list('id', flat=True) DataPoint.objects.filter( indicator_id=indicator_id, # data_date = data_date, location_id=null_location_id ).update(value=None) DataPoint.objects.filter( indicator_id=indicator_id, # data_date = data_date, location_id=NaN_location_id ).update(value='NaN') dps = DataPoint.objects.filter( indicator_id=indicator_id, # data_date = data_date, location_id__in=location_ids, value__isnull=False ).values_list('id', 'value') sum_dp_value = sum([y for x, y in dps if not isnan(y)]) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() ################################################# ## ensure that raw data gets into AggDataPoint ## ################################################# raw_value = DataPoint.objects.get( # data_date = data_date, indicator_id=indicator_id, location_id=raw_location_id)\ .value ind_obj = Indicator.objects.get(id=indicator_id) raw_value_in_agg = AggDataPoint.objects.get( # data_date = data_date, indicator_id=indicator_id, location_id=raw_location_id)\ .value self.assertEqual(raw_value, raw_value_in_agg) ############################################# ## ensure that the aggregated data gets in ## ############################################# loc_tree_df = DataFrame(list(LocationTree.objects.all().values())) agg_df = DataFrame(list(AggDataPoint.objects.filter(\ indicator_id=indicator_id,\ campaign_id=self.campaign_id ).values())) agg_value = AggDataPoint.objects.get( indicator_id=indicator_id, campaign_id=self.campaign_id, location_id=agg_location_id ).value self.assertEqual(agg_value, sum_dp_value) ###################################################### ## ensure that any raw data will override aggregate ## ###################################################### override_value = 909090 agg_override_dp = self.create_datapoint(agg_location_id, data_date, indicator_id, override_value) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() override_value_in_agg = AggDataPoint.objects.get( campaign_id=self.campaign_id, indicator_id=indicator_id, location_id=agg_location_id).value self.assertEqual(override_value, override_value_in_agg) ########################################### # ensure that percentages do not aggregate ########################################### pct_ind = Indicator.objects.create( name='pct missed', short_name='pct_missed', description='missed pct', data_format='pct', source_name='my brain', ) dp_1 = DataPoint.objects.create( indicator_id=pct_ind.id, location_id=location_ids[0], campaign_id=self.campaign_id, data_date=data_date, value=.2, source_submission_id=self.ss, unique_index=1 ) dp_2 = DataPoint.objects.create( indicator_id=pct_ind.id, location_id=location_ids[1], campaign_id=self.campaign_id, data_date=data_date, value=.6, source_submission_id=self.ss, unique_index=2 ) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() try: agg_dp_qs = AggDataPoint.objects.get( location_id=agg_location_id, indicator_id=pct_ind, campaign_id=self.campaign_id, ) error_ocurred = False except AggDataPoint.DoesNotExist: error_ocurred = True self.assertTrue(error_ocurred) def test_raw_data_to_computed(self): ''' This just makes sure that any data in the datapoint table, gets into the Calculated DataPoint table. That is, i insert a value for missed children in Borno, the same exact data should be in the datapoint_with_computed table no matter what. ''' self.create_raw_datapoints() indicator_id, data_date, raw_location_id,\ agg_location_id, campaign_id = 22, '2016-01-01', 12910, 12907, 1 location_ids = Location.objects.filter( parent_location_id=agg_location_id).values_list('id', flat=True) dp_values = DataPoint.objects.filter( indicator_id=indicator_id, data_date=data_date, location_id__in=location_ids ).values_list('value', flat=True) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() ############################################################ ## ensure that raw data gets into datapoint_with_computed ## ############################################################ raw_value = DataPoint.objects.get(data_date=data_date, indicator_id=indicator_id, location_id=raw_location_id)\ .value raw_value_in_agg = DataPointComputed.objects.get( campaign_id=self.campaign_id, indicator_id=indicator_id, location_id=raw_location_id)\ .value self.assertEqual(raw_value, raw_value_in_agg) def test_sum_and_pct(self): ''' The system uses the "PART_TO_BE_SUMMED" edge type in order to create indicators such that the sum of: - Number Missed - Missed due to other reasons(24) - Child Absent(251) - Not in Plan (267) - Not Visited (268) - Non Compliance(264) gives us: All Missed Children (21) as well as: pct missed children due to refusal (166) Here we create new metadata so we can test this functionality for an Abstracted use case and test that 1. We can SUM indicators 2. We can use the result of #2 as the denominator for a percentage calculation. ''' Indicator.objects.all().delete() data_date, location_id, agg_location_id = '2016-01-01', 12910, 12907 val_1, val_2, val_3 = 303, 808, 909 ## create the parent and sub indicators ## parent_indicator = Indicator.objects.create( name='Number of Avoidable Deaths', short_name='Number of Avoidable Deaths', data_format='int' ) sub_indicator_1 = Indicator.objects.create( name='Number of Deaths due to Conflict', short_name='Number of Deaths due to Conflict', data_format='int' ) sub_indicator_2 = Indicator.objects.create( name='Number of Deaths due to Malaria', short_name='Number of Deaths due to Malaria', data_format='int' ) sub_indicator_3 = Indicator.objects.create( name='Number of Deaths due to Hunger', short_name='Number of Deaths due to Hunger', data_format='int' ) pct_indicator = Indicator.objects.create( name='pct of Deaths due to Hunger', short_name='pct of Deaths due to Hunger', data_format='pct' ) ## FOR SUM OF PARTS CALUCLATIONS ## indicator_calc_1 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_1.id, calculation='PART_TO_BE_SUMMED' ) indicator_calc_2 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_2.id, calculation='PART_TO_BE_SUMMED' ) indicator_calc_3 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_3.id, calculation='PART_TO_BE_SUMMED' ) ## FOR PART OVER WHOLE CALCULATIONS ## indicator_calc_numerator = CalculatedIndicatorComponent.objects.create( indicator_id=pct_indicator.id, indicator_component_id=sub_indicator_3.id, calculation='NUMERATOR' ) indicator_calc_denominator = CalculatedIndicatorComponent.objects.create( indicator_id=pct_indicator.id, indicator_component_id=parent_indicator.id, calculation='DENOMINATOR' ) ss_id = SourceSubmission.objects.all()[0].id ## create the datapoints ## dp_1 = DataPoint.objects.create( indicator_id=sub_indicator_1.id, data_date=data_date, location_id=location_id, campaign_id=self.campaign_id, value=val_1, source_submission_id=ss_id, unique_index=1 ) dp_2 = DataPoint.objects.create( indicator_id=sub_indicator_2.id, data_date=data_date, location_id=location_id, campaign_id=self.campaign_id, value=val_2, source_submission_id=ss_id, unique_index=2 ) dp_3 = DataPoint.objects.create( indicator_id=sub_indicator_3.id, data_date=data_date, location_id=location_id, campaign_id=self.campaign_id, value=val_3, source_submission_id=ss_id, unique_index=3 ) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() calc_value_sum = DataPointComputed.objects.get( indicator_id=parent_indicator.id, campaign_id=self.campaign_id, location_id=location_id ).value calc_value_pct = DataPointComputed.objects.get( indicator_id=pct_indicator.id, campaign_id=self.campaign_id, location_id=location_id ).value # test SUM calculation sum_target_value = val_1 + val_2 + val_3 self.assertEqual(calc_value_sum, sum_target_value) # test part over whole calction pct_target_value = val_3 / float(sum_target_value) self.assertEqual(calc_value_pct, pct_target_value) def test_part_of_difference(self): ''' see here: rhizome.work/manage_system/manage/indicator/187 We use this calculation to perform the following calculation: WHOLE_OF_DIFFERENCE(x) - PART_OF_DIFFERENCE(y) ----------------------------------------- WHOLE_OF_DIFFERENCE(x) ''' data_date, location_id, agg_location_id = '2016-01-01', 12910, 12907 x, y = 303.00, 808.00 ## create the parent and sub indicators ## parent_indicator = Indicator.objects.create( name='Refsual Conversion', short_name='Refsual Conversion', data_format='pct' ) sub_indicator_part = Indicator.objects.create( name='Refusals After Revisit', short_name='Refusals After Revisit', data_format='int' ) sub_indicator_denom = Indicator.objects.create( name='Refusals Before Revisit', short_name='Refusals Before Revisit', data_format='int' ) ## FOR SUM OF PARTS CALUCLATIONS ## indicator_calc_1 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_part.id, calculation='PART_OF_DIFFERENCE' ) indicator_calc_3 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_denom.id, calculation='WHOLE_OF_DIFFERENCE' ) ss_id = SourceSubmission.objects.all()[0].id ## create the datapoints ## dp_1 = DataPoint.objects.create( indicator_id=sub_indicator_denom.id, data_date=data_date, location_id=location_id, campaign_id=self.campaign_id, value=x, source_submission_id=ss_id, unique_index=1 ) dp_2 = DataPoint.objects.create( indicator_id=sub_indicator_part.id, data_date=data_date, location_id=location_id, campaign_id=self.campaign_id, value=y, source_submission_id=ss_id, unique_index=2 ) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() calc_value = DataPointComputed.objects.get( indicator_id=parent_indicator.id, campaign_id=self.campaign_id, location_id=location_id ).value # test SUM calculation target_value = (x - y) / x self.assertEqual(round(calc_value, 4), round(target_value, 4)) def test_missing_part_of_sum(self): data_date, location_id, agg_location_id = '2016-01-01', 12910, 12907 val_1, val_2 = 101, 102 ## create the parent and sub indicators ## parent_indicator = Indicator.objects.create( name='Number of Missing Children', short_name='Number of Avoidable Deaths', data_format='int' ) sub_indicator_1 = Indicator.objects.create( name='Number Missing Due to Refusal', short_name='Number Missing Due to Refusal', data_format='int' ) sub_indicator_2 = Indicator.objects.create( name='Number Missing Due to Absence', short_name='Number Missing Due to Absence', data_format='int' ) sub_indicator_3 = Indicator.objects.create( name='Number Missing Due to ??', short_name='Number Missing Due to ??', data_format='int' ) indicator_calc_1 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_1.id, calculation='PART_TO_BE_SUMMED' ) indicator_calc_2 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_2.id, calculation='PART_TO_BE_SUMMED' ) indicator_calc_3 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_3.id, calculation='PART_TO_BE_SUMMED' ) ss_id = SourceSubmission.objects.all()[0].id ## create the datapoints. We're only adding data points for ## ## two of the three datapoints that are mapped as parts to be summed ## dp_1 = DataPoint.objects.create( indicator_id=sub_indicator_1.id, data_date=data_date, location_id=location_id, campaign_id=self.campaign_id, value=val_1, source_submission_id=ss_id, unique_index=1 ) dp_2 = DataPoint.objects.create( indicator_id=sub_indicator_2.id, data_date=data_date, location_id=location_id, campaign_id=self.campaign_id, value=val_2, source_submission_id=ss_id, unique_index=2 ) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() calc_value_sum = DataPointComputed.objects.get( indicator_id=parent_indicator.id, campaign_id=self.campaign_id, location_id=location_id ).value sum_target_value = val_1 + val_2 self.assertEqual(calc_value_sum, sum_target_value) def test_recursive_sum(self): ''' Consider the case in which we have "number of missed children" which is the sum of "missed children due to absence", "missed children due to refusal", and "missed children due to child absence." Now consider that "missed children due to refusal" is also generated from the sum of "refusal due to religious reasons", "refusal due to too many rounds", "refusal due to - unhappy with team " (see more here: http://rhizome.work/manage_system/manage/indicator/264). There are two levels here and this test aims to cover this use case. ''' data_date, location_id = '2016-01-01', 12910 Indicator.objects.all().delete() parent_indicator = Indicator.objects.create( name='Number of Avoidable Deaths', short_name='Number of Avoidable Deaths', data_format='int' ) sub_indicator_1 = Indicator.objects.create( name='Number of Deaths due to Conflict', short_name='Number of Deaths due to Conflict', data_format='int' ) sub_sub_indicator_1 = Indicator.objects.create( name='Number Conflict Deaths - Children', short_name='Conflict Deaths - Children', data_format='int' ) sub_sub_indicator_2 = Indicator.objects.create( name='Number of Adult Civilian Deaths', short_name='Number of Adult Civilian Deaths', data_format='int' ) sub_sub_indicator_3 = Indicator.objects.create( name='Number of Conflict Deaths - Militants', short_name='Conflict Deaths - Militants', data_format='int' ) sub_indicator_2 = Indicator.objects.create( name='Number of Deaths due to Malaria', short_name='Number of Deaths due to Malaria', data_format='int' ) sub_indicator_2_sub_1 = Indicator.objects.create( name='Number of Deaths due to Malaria -- Child had No Net', short_name='Number of Deaths due to Malaria -- no net', data_format='int' ) sub_indicator_2_sub_2 = Indicator.objects.create( name='Number of Deaths due to Malaria -- Child had No Medicine', short_name='Number of Deaths due to Malaria -- no Medicie', data_format='int' ) sub_indicator_3 = Indicator.objects.create( name='Number of Deaths due to Hunger', short_name='Number of Deaths due to Hunger', data_format='int' ) ## FOR SUM OF PARTS CALUCLATIONS ## indicator_calc_1 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_1.id, calculation='PART_TO_BE_SUMMED' ) indicator_calc_2 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_2.id, calculation='PART_TO_BE_SUMMED' ) indicator_calc_3 = CalculatedIndicatorComponent.objects.create( indicator_id=parent_indicator.id, indicator_component_id=sub_indicator_3.id, calculation='PART_TO_BE_SUMMED' ) ## 2nd layer of indicator calculation ## sub_indicator_calc_1 = CalculatedIndicatorComponent.objects.create( indicator_id=sub_indicator_1.id, indicator_component_id=sub_sub_indicator_1.id, calculation='PART_TO_BE_SUMMED' ) sub_indicator_calc_2 = CalculatedIndicatorComponent.objects.create( indicator_id=sub_indicator_1.id, indicator_component_id=sub_sub_indicator_2.id, calculation='PART_TO_BE_SUMMED' ) sub_indicator_calc_3 = CalculatedIndicatorComponent.objects.create( indicator_id=sub_indicator_1.id, indicator_component_id=sub_sub_indicator_3.id, calculation='PART_TO_BE_SUMMED' ) ## 2nd layer of indicator calculation ## sub_indicator_calc_1 = CalculatedIndicatorComponent.objects.create( indicator_id=sub_indicator_2.id, indicator_component_id=sub_indicator_2_sub_1.id, calculation='PART_TO_BE_SUMMED' ) sub_indicator_calc_2 = CalculatedIndicatorComponent.objects.create( indicator_id=sub_indicator_2.id, indicator_component_id=sub_indicator_2_sub_2.id, calculation='PART_TO_BE_SUMMED' ) ## create all the datapoints ## values_to_insert = { sub_indicator_2.id: 33, sub_indicator_3.id: 44, sub_sub_indicator_1.id: 44, sub_sub_indicator_2.id: 55, sub_sub_indicator_3.id: 66, sub_indicator_2_sub_1.id: 77, sub_indicator_2_sub_2.id: 88, } for k, v in values_to_insert.iteritems(): self.create_datapoint(location_id, data_date, k, v) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() parent_indicator_target_value = sum(values_to_insert.values()) parent_indicator_1_actual_value = DataPointComputed.objects.get( location_id=location_id, indicator_id=parent_indicator, ).value self.assertEqual(parent_indicator_1_actual_value, parent_indicator_target_value) # test that a parent overrides the sum of its children when there ## are multiple levels of indicator calcuations ## sub_2_target_val = values_to_insert[sub_indicator_2.id] sub_2_actual_val = DataPointComputed.objects.get( location_id=location_id, indicator_id=sub_indicator_2.id, ).value self.assertEqual(sub_2_target_val, sub_2_actual_val) def test_boolean_aggregation(self): # create a boolean indicato boolean_indicator = Indicator.objects.create( name='Is Controlled by "Anti Governemnt Elements"', short_name='Is at War', data_format='bool' ) # find the locations for which we should store raw data.. For instance # if it is 'district is at war', then we dont expect data stored at # the porivnce level. Here though, we get all children of a particluar # parent. locations = Location.objects.filter( parent_location_id=self.top_lvl_location.id) # split the data into 1 value being fale, the rest being trye. # this aludes to the fact that the parent location shoul dhave a value # that is somethign like [ 1 / data.length() ] false_loc_id = locations[0].id true_loc_list = locations[1:] ## create the true and false datapoints ## false_datapoint = DataPoint.objects.create( campaign_id=self.campaign_id, location_id=false_loc_id, indicator_id=boolean_indicator.id, source_submission_id=self.ss, value=0 ) true_datapoint_batch = [DataPoint(**{ 'campaign_id': self.campaign_id, 'location_id': loc.id, 'indicator_id': boolean_indicator.id, 'source_submission_id': self.ss, 'value': 1, 'unique_index': str(self.campaign_id) + str(boolean_indicator.id) + str(loc.id) }) for loc in true_loc_list] DataPoint.objects.bulk_create(true_datapoint_batch) # run the agg refresh ( this is the code that will actually transofrm # the booleans to numerics. ) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() # now get the expected aggrgated data and compare it with the percentage # value that we expect given how we split up the locations above. dwc_value = DataPointComputed.objects.get( location_id=self.top_lvl_location.id, campaign_id=self.campaign_id, indicator=boolean_indicator.id ).value expected_value = 1 - (1.0 / len(locations)) self.assertEqual(expected_value, dwc_value) def test_calculated_indicator_agg(self): Indicator.objects.all().delete() data_date, agg_location_id = '2016-01-01', 12907 child_locations = Location.objects.filter( parent_location_id=agg_location_id) location_id = child_locations[0].id location_id_2 = child_locations[1].id ## create the parent and sub indicators ## parent_indicator = Indicator.objects.create( name='Number of Avoidable Deaths', short_name='Number of Avoidable Deaths', data_format='int' ) sub_indicator_1 = Indicator.objects.create( name='Number of Deaths due to Conflict', short_name='Number of Deaths due to Conflict', data_format='int' ) pct_indicator = Indicator.objects.create( name='pct of Deaths due to Conflict', short_name='pct of Deaths due to Conflict', data_format='pct' ) ## FOR PART OVER WHOLE CALCULATIONS ## indicator_calc_numerator = CalculatedIndicatorComponent.objects.create( indicator_id=pct_indicator.id, indicator_component_id=sub_indicator_1.id, calculation='NUMERATOR' ) indicator_calc_denominator = CalculatedIndicatorComponent.objects.create( indicator_id=pct_indicator.id, indicator_component_id=parent_indicator.id, calculation='DENOMINATOR' ) val_1 = 32 val_2 = 100 val_1_loc_2 = 48 val_2_loc_2 = 200 ss_id = SourceSubmission.objects.all()[0].id ## create the datapoints ## dp_1 = DataPoint.objects.create( indicator_id=sub_indicator_1.id, data_date=data_date, location_id=location_id, campaign_id=self.campaign_id, value=val_1, source_submission_id=ss_id, unique_index=1 ) dp_2 = DataPoint.objects.create( indicator_id=parent_indicator.id, data_date=data_date, location_id=location_id, campaign_id=self.campaign_id, value=val_2, source_submission_id=ss_id, unique_index=2 ) dp_1_loc_2 = DataPoint.objects.create( indicator_id=sub_indicator_1.id, data_date=data_date, location_id=location_id_2, campaign_id=self.campaign_id, value=val_1_loc_2, source_submission_id=ss_id, unique_index=3 ) dp_2_loc_2 = DataPoint.objects.create( indicator_id=parent_indicator.id, data_date=data_date, location_id=location_id_2, campaign_id=self.campaign_id, value=val_2_loc_2, source_submission_id=ss_id, unique_index=4 ) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() calc_value_pct = DataPointComputed.objects.get( indicator_id=pct_indicator.id, campaign_id=self.campaign_id, location_id=location_id ).value calc_value_pct_2 = DataPointComputed.objects.get( indicator_id=pct_indicator.id, campaign_id=self.campaign_id, location_id=location_id_2 ).value # test part over whole calculation for child locations pct_target_value = val_1 / float(val_2) self.assertEqual(calc_value_pct, pct_target_value) pct_target_value_2 = val_1_loc_2 / float(val_2_loc_2) self.assertEqual(calc_value_pct_2, pct_target_value_2) # make sure that part over whole aggregates as well total_dp = DataPointComputed.objects.get( indicator_id=parent_indicator.id, campaign_id=self.campaign_id, location_id=agg_location_id).value self.assertEqual(total_dp, val_2 + val_2_loc_2) try: pct_dp = DataPointComputed.objects.get( indicator_id=pct_indicator.id, campaign_id=self.campaign_id, location_id=agg_location_id).value except ObjectDoesNotExist: fail("aggregation did not work") self.assertEqual(round(pct_dp, 5), round( (val_1 + val_1_loc_2) / float(val_2 + val_2_loc_2), 5)) def test_multiple_calculations(self): num_seen = Indicator.objects.create( name='number children seen', short_name='number children seen', data_format='int' ) num_vacc = Indicator.objects.create( name='number children vaccinated', short_name='number children vaccinated', data_format='int' ) num_missed = Indicator.objects.create( name='number children missed', short_name='number children missed', data_format='int' ) pct_missed = Indicator.objects.create( name='pct childrent missed', short_name='pct children missed', data_format='pct' ) indicator_calc_numerator = CalculatedIndicatorComponent.objects.create( indicator_id=pct_missed.id, indicator_component_id=num_missed.id, calculation='NUMERATOR' ) indicator_calc_denominator = CalculatedIndicatorComponent.objects.create( indicator_id=pct_missed.id, indicator_component_id=num_seen.id, calculation='DENOMINATOR' ) indicator_calc_part_of_diff = CalculatedIndicatorComponent.objects.create( indicator_id=pct_missed.id, indicator_component_id=num_vacc.id, calculation='PART_OF_DIFFERENCE' ) indicator_calc_part_of_whole = CalculatedIndicatorComponent.objects.create( indicator_id=pct_missed.id, indicator_component_id=num_seen.id, calculation='WHOLE_OF_DIFFERENCE' ) num_missed_val = 45.0 num_seen_val = 100.0 num_vacc_val = 55.0 ss_id = SourceSubmission.objects.all()[0].id dp_num_missed = DataPoint.objects.create( indicator_id=num_missed.id, location_id=self.top_lvl_location.id, campaign_id=self.campaign_id, value=num_missed_val, source_submission_id=ss_id, unique_index=3 ) dp_num_seen = DataPoint.objects.create( indicator_id=num_seen.id, location_id=self.top_lvl_location.id, campaign_id=self.campaign_id, value=num_seen_val, source_submission_id=ss_id, unique_index=4 ) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() # check that numerator and denominator option work cdp_pct_missed_1 = DataPointComputed.objects.filter( indicator_id=pct_missed.id)[0] self.assertEqual(cdp_pct_missed_1.value, num_missed_val / float(num_seen_val)) dp_num_vaccinated = DataPoint.objects.create( indicator_id=num_vacc.id, location_id=self.top_lvl_location.id, campaign_id=self.campaign_id, value=num_vacc_val, source_submission_id=ss_id, unique_index=5 ) campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() # check that this works when we can do whole/part of difference cdp_pct_missed_2 = DataPointComputed.objects.filter( indicator_id=pct_missed.id)[0] 1.0 - float(num_vacc_val) / float(num_seen_val) self.assertEqual(cdp_pct_missed_2.value, 0.45) # check that this works when we can only do whole/part of difference DataPoint.objects.filter(indicator_id=num_missed.id).delete() campaign_object = Campaign.objects.get(id = self.campaign_id) campaign_object.aggregate_and_calculate() cdp_pct_missed_3 = DataPointComputed.objects.filter( indicator_id=pct_missed.id)[0] self.assertEqual(cdp_pct_missed_3.value, 0.45)
unicef/rhizome
rhizome/tests/test_agg.py
Python
agpl-3.0
38,994
0.001795
"""AWS plugin for integration tests.""" from __future__ import (absolute_import, division, print_function) __metaclass__ = type import os from ..util import ( ApplicationError, display, is_shippable, ConfigParser, ) from . import ( CloudProvider, CloudEnvironment, CloudEnvironmentConfig, ) from ..core_ci import ( AnsibleCoreCI, ) class AwsCloudProvider(CloudProvider): """AWS cloud provider plugin. Sets up cloud resources before delegation.""" def filter(self, targets, exclude): """Filter out the cloud tests when the necessary config and resources are not available. :type targets: tuple[TestTarget] :type exclude: list[str] """ if os.path.isfile(self.config_static_path): return aci = self._create_ansible_core_ci() if os.path.isfile(aci.ci_key): return if is_shippable(): return super(AwsCloudProvider, self).filter(targets, exclude) def setup(self): """Setup the cloud resource before delegation and register a cleanup callback.""" super(AwsCloudProvider, self).setup() aws_config_path = os.path.expanduser('~/.aws') if os.path.exists(aws_config_path) and not self.args.docker and not self.args.remote: raise ApplicationError('Rename "%s" or use the --docker or --remote option to isolate tests.' % aws_config_path) if not self._use_static_config(): self._setup_dynamic() def _setup_dynamic(self): """Request AWS credentials through the Ansible Core CI service.""" display.info('Provisioning %s cloud environment.' % self.platform, verbosity=1) config = self._read_config_template() aci = self._create_ansible_core_ci() response = aci.start() if not self.args.explain: credentials = response['aws']['credentials'] values = dict( ACCESS_KEY=credentials['access_key'], SECRET_KEY=credentials['secret_key'], SECURITY_TOKEN=credentials['session_token'], REGION='us-east-1', ) display.sensitive.add(values['SECRET_KEY']) display.sensitive.add(values['SECURITY_TOKEN']) config = self._populate_config_template(config, values) self._write_config(config) def _create_ansible_core_ci(self): """ :rtype: AnsibleCoreCI """ return AnsibleCoreCI(self.args, 'aws', 'sts', persist=False, stage=self.args.remote_stage, provider=self.args.remote_provider) class AwsCloudEnvironment(CloudEnvironment): """AWS cloud environment plugin. Updates integration test environment after delegation.""" def get_environment_config(self): """ :rtype: CloudEnvironmentConfig """ parser = ConfigParser() parser.read(self.config_path) ansible_vars = dict( resource_prefix=self.resource_prefix, ) ansible_vars.update(dict(parser.items('default'))) display.sensitive.add(ansible_vars.get('aws_secret_key')) display.sensitive.add(ansible_vars.get('security_token')) if 'aws_cleanup' not in ansible_vars: ansible_vars['aws_cleanup'] = not self.managed env_vars = {'ANSIBLE_DEBUG_BOTOCORE_LOGS': 'True'} return CloudEnvironmentConfig( env_vars=env_vars, ansible_vars=ansible_vars, callback_plugins=['aws_resource_actions'], ) def on_failure(self, target, tries): """ :type target: TestTarget :type tries: int """ if not tries and self.managed: display.notice('If %s failed due to permissions, the IAM test policy may need to be updated. ' 'For help, consult @mattclay or @gundalow on GitHub or #ansible-devel on IRC.' % target.name)
thaim/ansible
test/lib/ansible_test/_internal/cloud/aws.py
Python
mit
3,947
0.00228
# -*- coding: utf-8 -*- # Copyright 2022 Google LLC # # 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. # # Generated code. DO NOT EDIT! # # Snippet for ListServices # NOTE: This snippet has been automatically generated for illustrative purposes only. # It may require modifications to work in your environment. # To install the latest published package dependency, execute the following: # python3 -m pip install google-cloud-service-usage # [START serviceusage_v1_generated_ServiceUsage_ListServices_async] from google.cloud import service_usage_v1 async def sample_list_services(): # Create a client client = service_usage_v1.ServiceUsageAsyncClient() # Initialize request argument(s) request = service_usage_v1.ListServicesRequest( ) # Make the request page_result = client.list_services(request=request) # Handle the response async for response in page_result: print(response) # [END serviceusage_v1_generated_ServiceUsage_ListServices_async]
googleapis/python-service-usage
samples/generated_samples/serviceusage_v1_generated_service_usage_list_services_async.py
Python
apache-2.0
1,497
0.000668
""" The MIT License Copyright (c) 2007 Leah Culver, Joe Stump, Mark Paschal, Vic Fryzel 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 urllib import time import random import urlparse import hmac import binascii import httplib2 try: from urlparse import parse_qs, parse_qsl except ImportError: from cgi import parse_qs, parse_qsl VERSION = '1.0' # Hi Blaine! HTTP_METHOD = 'GET' SIGNATURE_METHOD = 'PLAINTEXT' class Error(RuntimeError): """Generic exception class.""" def __init__(self, message='OAuth error occured.'): self._message = message @property def message(self): """A hack to get around the deprecation errors in 2.6.""" return self._message def __str__(self): return self._message class MissingSignature(Error): pass def build_authenticate_header(realm=''): """Optional WWW-Authenticate header (401 error)""" return {'WWW-Authenticate': 'OAuth realm="%s"' % realm} def escape(s): """Escape a URL including any /.""" return urllib.quote(s, safe='~') def generate_timestamp(): """Get seconds since epoch (UTC).""" return int(time.time()) def generate_nonce(length=8): """Generate pseudorandom number.""" return ''.join([str(random.randint(0, 9)) for i in range(length)]) def generate_verifier(length=8): """Generate pseudorandom number.""" return ''.join([str(random.randint(0, 9)) for i in range(length)]) class Consumer(object): """A consumer of OAuth-protected services. The OAuth consumer is a "third-party" service that wants to access protected resources from an OAuth service provider on behalf of an end user. It's kind of the OAuth client. Usually a consumer must be registered with the service provider by the developer of the consumer software. As part of that process, the service provider gives the consumer a *key* and a *secret* with which the consumer software can identify itself to the service. The consumer will include its key in each request to identify itself, but will use its secret only when signing requests, to prove that the request is from that particular registered consumer. Once registered, the consumer can then use its consumer credentials to ask the service provider for a request token, kicking off the OAuth authorization process. """ key = None secret = None def __init__(self, key, secret): self.key = key self.secret = secret if self.key is None or self.secret is None: raise ValueError("Key and secret must be set.") def __str__(self): data = { 'oauth_consumer_key': self.key, 'oauth_consumer_secret': self.secret } return urllib.urlencode(data) class Token(object): """An OAuth credential used to request authorization or a protected resource. Tokens in OAuth comprise a *key* and a *secret*. The key is included in requests to identify the token being used, but the secret is used only in the signature, to prove that the requester is who the server gave the token to. When first negotiating the authorization, the consumer asks for a *request token* that the live user authorizes with the service provider. The consumer then exchanges the request token for an *access token* that can be used to access protected resources. """ key = None secret = None callback = None callback_confirmed = None verifier = None def __init__(self, key, secret): self.key = key self.secret = secret if self.key is None or self.secret is None: raise ValueError("Key and secret must be set.") def set_callback(self, callback): self.callback = callback self.callback_confirmed = 'true' def set_verifier(self, verifier=None): if verifier is not None: self.verifier = verifier else: self.verifier = generate_verifier() def get_callback_url(self): if self.callback and self.verifier: # Append the oauth_verifier. parts = urlparse.urlparse(self.callback) scheme, netloc, path, params, query, fragment = parts[:6] if query: query = '%s&oauth_verifier=%s' % (query, self.verifier) else: query = 'oauth_verifier=%s' % self.verifier return urlparse.urlunparse((scheme, netloc, path, params, query, fragment)) return self.callback def to_string(self): """Returns this token as a plain string, suitable for storage. The resulting string includes the token's secret, so you should never send or store this string where a third party can read it. """ data = { 'oauth_token': self.key, 'oauth_token_secret': self.secret, } if self.callback_confirmed is not None: data['oauth_callback_confirmed'] = self.callback_confirmed return urllib.urlencode(data) @staticmethod def from_string(s): """Deserializes a token from a string like one returned by `to_string()`.""" if not len(s): raise ValueError("Invalid parameter string.") params = parse_qs(s, keep_blank_values=False) if not len(params): raise ValueError("Invalid parameter string.") try: key = params['oauth_token'][0] except Exception: raise ValueError("'oauth_token' not found in OAuth request.") try: secret = params['oauth_token_secret'][0] except Exception: raise ValueError("'oauth_token_secret' not found in " "OAuth request.") token = Token(key, secret) try: token.callback_confirmed = params['oauth_callback_confirmed'][0] except KeyError: pass # 1.0, no callback confirmed. return token def __str__(self): return self.to_string() def setter(attr): name = attr.__name__ def getter(self): try: return self.__dict__[name] except KeyError: raise AttributeError(name) def deleter(self): del self.__dict__[name] return property(getter, attr, deleter) class Request(dict): """The parameters and information for an HTTP request, suitable for authorizing with OAuth credentials. When a consumer wants to access a service's protected resources, it does so using a signed HTTP request identifying itself (the consumer) with its key, and providing an access token authorized by the end user to access those resources. """ http_method = HTTP_METHOD http_url = None version = VERSION def __init__(self, method=HTTP_METHOD, url=None, parameters=None): if method is not None: self.method = method if url is not None: self.url = url if parameters is not None: self.update(parameters) @setter def url(self, value): parts = urlparse.urlparse(value) scheme, netloc, path = parts[:3] # Exclude default port numbers. if scheme == 'http' and netloc[-3:] == ':80': netloc = netloc[:-3] elif scheme == 'https' and netloc[-4:] == ':443': netloc = netloc[:-4] if scheme != 'http' and scheme != 'https': raise ValueError("Unsupported URL %s (%s)." % (value, scheme)) value = '%s://%s%s' % (scheme, netloc, path) self.__dict__['url'] = value @setter def method(self, value): self.__dict__['method'] = value.upper() def _get_timestamp_nonce(self): return self['oauth_timestamp'], self['oauth_nonce'] def get_nonoauth_parameters(self): """Get any non-OAuth parameters.""" return dict([(k, v) for k, v in self.iteritems() if not k.startswith('oauth_')]) def to_header(self, realm=''): """Serialize as a header for an HTTPAuth request.""" oauth_params = ((k, v) for k, v in self.items() if k.startswith('oauth_')) stringy_params = ((k, escape(str(v))) for k, v in oauth_params) header_params = ('%s="%s"' % (k, v) for k, v in stringy_params) params_header = ', '.join(header_params) auth_header = 'OAuth realm="%s"' % realm if params_header: auth_header = "%s, %s" % (auth_header, params_header) return {'Authorization': auth_header} def to_postdata(self): """Serialize as post data for a POST request.""" return self.encode_postdata(self) def encode_postdata(self, data): # tell urlencode to deal with sequence values and map them correctly # to resulting querystring. for example self["k"] = ["v1", "v2"] will # result in 'k=v1&k=v2' and not k=%5B%27v1%27%2C+%27v2%27%5D return urllib.urlencode(data, True) def to_url(self): """Serialize as a URL for a GET request.""" return '%s?%s' % (self.url, self.to_postdata()) def get_parameter(self, parameter): ret = self.get(parameter) if ret is None: raise Error('Parameter not found: %s' % parameter) return ret def get_normalized_parameters(self): """Return a string that contains the parameters that must be signed.""" items = [(k, v) for k, v in self.items() if k != 'oauth_signature'] encoded_str = urllib.urlencode(sorted(items), True) # Encode signature parameters per Oauth Core 1.0 protocol # spec draft 7, section 3.6 # (http://tools.ietf.org/html/draft-hammer-oauth-07#section-3.6) # Spaces must be encoded with "%20" instead of "+" return encoded_str.replace('+', '%20') def sign_request(self, signature_method, consumer, token): """Set the signature parameter to the result of sign.""" if 'oauth_consumer_key' not in self: self['oauth_consumer_key'] = consumer.key if token and 'oauth_token' not in self: self['oauth_token'] = token.key self['oauth_signature_method'] = signature_method.name self['oauth_signature'] = signature_method.sign(self, consumer, token) @classmethod def make_timestamp(cls): """Get seconds since epoch (UTC).""" return str(int(time.time())) @classmethod def make_nonce(cls): """Generate pseudorandom number.""" return str(random.randint(0, 100000000)) @classmethod def from_request(cls, http_method, http_url, headers=None, parameters=None, query_string=None): """Combines multiple parameter sources.""" if parameters is None: parameters = {} # Headers if headers and 'Authorization' in headers: auth_header = headers['Authorization'] # Check that the authorization header is OAuth. if auth_header[:6] == 'OAuth ': auth_header = auth_header[6:] try: # Get the parameters from the header. header_params = cls._split_header(auth_header) parameters.update(header_params) except: raise Error('Unable to parse OAuth parameters from ' 'Authorization header.') # GET or POST query string. if query_string: query_params = cls._split_url_string(query_string) parameters.update(query_params) # URL parameters. param_str = urlparse.urlparse(http_url)[4] # query url_params = cls._split_url_string(param_str) parameters.update(url_params) if parameters: return cls(http_method, http_url, parameters) return None @classmethod def from_consumer_and_token(cls, consumer, token=None, http_method=HTTP_METHOD, http_url=None, parameters=None): if not parameters: parameters = {} defaults = { 'oauth_consumer_key': consumer.key, 'oauth_timestamp': cls.make_timestamp(), 'oauth_nonce': cls.make_nonce(), 'oauth_version': cls.version, } defaults.update(parameters) parameters = defaults if token: parameters['oauth_token'] = token.key return Request(http_method, http_url, parameters) @classmethod def from_token_and_callback(cls, token, callback=None, http_method=HTTP_METHOD, http_url=None, parameters=None): if not parameters: parameters = {} parameters['oauth_token'] = token.key if callback: parameters['oauth_callback'] = callback return cls(http_method, http_url, parameters) @staticmethod def _split_header(header): """Turn Authorization: header into parameters.""" params = {} parts = header.split(',') for param in parts: # Ignore realm parameter. if param.find('realm') > -1: continue # Remove whitespace. param = param.strip() # Split key-value. param_parts = param.split('=', 1) # Remove quotes and unescape the value. params[param_parts[0]] = urllib.unquote(param_parts[1].strip('\"')) return params @staticmethod def _split_url_string(param_str): """Turn URL string into parameters.""" parameters = parse_qs(param_str, keep_blank_values=False) for k, v in parameters.iteritems(): parameters[k] = urllib.unquote(v[0]) return parameters class Server(object): """A skeletal implementation of a service provider, providing protected resources to requests from authorized consumers. This class implements the logic to check requests for authorization. You can use it with your web server or web framework to protect certain resources with OAuth. """ timestamp_threshold = 300 # In seconds, five minutes. version = VERSION signature_methods = None def __init__(self, signature_methods=None): self.signature_methods = signature_methods or {} def add_signature_method(self, signature_method): self.signature_methods[signature_method.name] = signature_method return self.signature_methods def verify_request(self, request, consumer, token): """Verifies an api call and checks all the parameters.""" version = self._get_version(request) self._check_signature(request, consumer, token) parameters = request.get_nonoauth_parameters() return parameters def build_authenticate_header(self, realm=''): """Optional support for the authenticate header.""" return {'WWW-Authenticate': 'OAuth realm="%s"' % realm} def _get_version(self, request): """Verify the correct version request for this server.""" try: version = request.get_parameter('oauth_version') except: version = VERSION if version and version != self.version: raise Error('OAuth version %s not supported.' % str(version)) return version def _get_signature_method(self, request): """Figure out the signature with some defaults.""" try: signature_method = request.get_parameter('oauth_signature_method') except: signature_method = SIGNATURE_METHOD try: # Get the signature method object. signature_method = self.signature_methods[signature_method] except: signature_method_names = ', '.join(self.signature_methods.keys()) raise Error('Signature method %s not supported try one of the following: %s' % (signature_method, signature_method_names)) return signature_method def _get_verifier(self, request): return request.get_parameter('oauth_verifier') def _check_signature(self, request, consumer, token): timestamp, nonce = request._get_timestamp_nonce() self._check_timestamp(timestamp) signature_method = self._get_signature_method(request) try: signature = request.get_parameter('oauth_signature') except: raise MissingSignature('Missing oauth_signature.') # Validate the signature. valid = signature_method.check(request, consumer, token, signature) if not valid: key, base = signature_method.signing_base(request, consumer, token) raise Error('Invalid signature. Expected signature base ' 'string: %s' % base) built = signature_method.sign(request, consumer, token) def _check_timestamp(self, timestamp): """Verify that timestamp is recentish.""" timestamp = int(timestamp) now = int(time.time()) lapsed = now - timestamp if lapsed > self.timestamp_threshold: raise Error('Expired timestamp: given %d and now %s has a ' 'greater difference than threshold %d' % (timestamp, now, self.timestamp_threshold)) class Client(httplib2.Http): """OAuthClient is a worker to attempt to execute a request.""" def __init__(self, consumer, token=None, cache=None, timeout=None, proxy_info=None): if consumer is not None and not isinstance(consumer, Consumer): raise ValueError("Invalid consumer.") if token is not None and not isinstance(token, Token): raise ValueError("Invalid token.") self.consumer = consumer self.token = token self.method = SignatureMethod_HMAC_SHA1() httplib2.Http.__init__(self, cache=cache, timeout=timeout, proxy_info=proxy_info) def set_signature_method(self, method): if not isinstance(method, SignatureMethod): raise ValueError("Invalid signature method.") self.method = method def request(self, uri, method="GET", body=None, headers=None, redirections=httplib2.DEFAULT_MAX_REDIRECTS, connection_type=None, force_auth_header=False): if not isinstance(headers, dict): headers = {} if body and method == "POST": parameters = dict(parse_qsl(body)) elif method == "GET": parsed = urlparse.urlparse(uri) parameters = parse_qs(parsed.query) else: parameters = None req = Request.from_consumer_and_token(self.consumer, token=self.token, http_method=method, http_url=uri, parameters=parameters) req.sign_request(self.method, self.consumer, self.token) if force_auth_header: # ensure we always send Authorization headers.update(req.to_header()) if method == "POST": if not force_auth_header: body = req.to_postdata() else: body = req.encode_postdata(req.get_nonoauth_parameters()) headers['Content-Type'] = 'application/x-www-form-urlencoded' elif method == "GET": if not force_auth_header: uri = req.to_url() else: if not force_auth_header: # don't call update twice. headers.update(req.to_header()) return httplib2.Http.request(self, uri, method=method, body=body, headers=headers, redirections=redirections, connection_type=connection_type) class SignatureMethod(object): """A way of signing requests. The OAuth protocol lets consumers and service providers pick a way to sign requests. This interface shows the methods expected by the other `oauth` modules for signing requests. Subclass it and implement its methods to provide a new way to sign requests. """ def signing_base(self, request, consumer, token): """Calculates the string that needs to be signed. This method returns a 2-tuple containing the starting key for the signing and the message to be signed. The latter may be used in error messages to help clients debug their software. """ raise NotImplementedError def sign(self, request, consumer, token): """Returns the signature for the given request, based on the consumer and token also provided. You should use your implementation of `signing_base()` to build the message to sign. Otherwise it may be less useful for debugging. """ raise NotImplementedError def check(self, request, consumer, token, signature): """Returns whether the given signature is the correct signature for the given consumer and token signing the given request.""" built = self.sign(request, consumer, token) return built == signature class SignatureMethod_HMAC_SHA1(SignatureMethod): name = 'HMAC-SHA1' def signing_base(self, request, consumer, token): sig = ( escape(request.method), escape(request.url), escape(request.get_normalized_parameters()), ) key = '%s&' % escape(consumer.secret) if token: key += escape(token.secret) raw = '&'.join(sig) return key, raw def sign(self, request, consumer, token): """Builds the base signature string.""" key, raw = self.signing_base(request, consumer, token) # HMAC object. try: import hashlib # 2.5 hashed = hmac.new(key, raw, hashlib.sha1) except ImportError: import sha # Deprecated hashed = hmac.new(key, raw, sha) # Calculate the digest base 64. return binascii.b2a_base64(hashed.digest())[:-1] class SignatureMethod_PLAINTEXT(SignatureMethod): name = 'PLAINTEXT' def signing_base(self, request, consumer, token): """Concatenates the consumer key and secret with the token's secret.""" sig = '%s&' % escape(consumer.secret) if token: sig = sig + escape(token.secret) return sig, sig def sign(self, request, consumer, token): key, raw = self.signing_base(request, consumer, token) return raw
b0nk/botxxy
src/oauth2.py
Python
gpl-2.0
23,431
0.001536
import ctypes libc = ctypes.CDLL("/usr/lib/libc.dylib") print(libc.rand()) print(libc.time()) cPrintF = libc.printf value = b"I'm a C function!" print(value) printValue = ctypes.c_char_p(value) print(printValue.value) print(printValue) cPrintF("%s", printValue)
torchhound/projects
python/ffi.py
Python
gpl-3.0
264
0
#!/usr/bin/env python """ A convinience wrapper around mysql connector. This file is part of open-ihm. open-ihm 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. open-ihm 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 open-ihm. If not, see <http://www.gnu.org/licenses/>. """ import includes.mysql.connector as connector import data.database # refactored to remove duplicate code while # providing same interface as before. class Database(data.database.Database): pass
snim2mirror/openihm
src/openihm/model/database.py
Python
lgpl-3.0
949
0.002107
#!/usr/bin/env python import sys sys.path.extend(['.', '..']) import unittest suite = unittest.TestLoader().loadTestsFromNames( [ 'test_c_lexer', 'test_c_ast', 'test_general', 'test_c_parser', ] ) unittest.TextTestRunner(verbosity=1).run(suite)
kk1987/pycparser
tests/all_tests.py
Python
bsd-3-clause
294
0.006803
# -*- coding: utf-8 -*- from operator import attrgetter from pyangbind.lib.yangtypes import RestrictedPrecisionDecimalType from pyangbind.lib.yangtypes import RestrictedClassType from pyangbind.lib.yangtypes import TypedListType from pyangbind.lib.yangtypes import YANGBool from pyangbind.lib.yangtypes import YANGListType from pyangbind.lib.yangtypes import YANGDynClass from pyangbind.lib.yangtypes import ReferenceType from pyangbind.lib.base import PybindBase from collections import OrderedDict from decimal import Decimal from bitarray import bitarray import six # PY3 support of some PY2 keywords (needs improved) if six.PY3: import builtins as __builtin__ long = int elif six.PY2: import __builtin__ from . import state class hostname(PybindBase): """ This class was auto-generated by the PythonClass plugin for PYANG from YANG module openconfig-network-instance - based on the path /network-instances/network-instance/protocols/protocol/isis/levels/level/link-state-database/lsp/tlvs/tlv/hostname. Each member element of the container is represented as a class variable - with a specific YANG type. YANG Description: This container defines TLV 137. """ __slots__ = ("_path_helper", "_extmethods", "__state") _yang_name = "hostname" _pybind_generated_by = "container" def __init__(self, *args, **kwargs): self._path_helper = False self._extmethods = False self.__state = YANGDynClass( base=state.state, is_container="container", yang_name="state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace="http://openconfig.net/yang/network-instance", defining_module="openconfig-network-instance", yang_type="container", is_config=False, ) load = kwargs.pop("load", None) if args: if len(args) > 1: raise TypeError("cannot create a YANG container with >1 argument") all_attr = True for e in self._pyangbind_elements: if not hasattr(args[0], e): all_attr = False break if not all_attr: raise ValueError("Supplied object did not have the correct attributes") for e in self._pyangbind_elements: nobj = getattr(args[0], e) if nobj._changed() is False: continue setmethod = getattr(self, "_set_%s" % e) if load is None: setmethod(getattr(args[0], e)) else: setmethod(getattr(args[0], e), load=load) def _path(self): if hasattr(self, "_parent"): return self._parent._path() + [self._yang_name] else: return [ "network-instances", "network-instance", "protocols", "protocol", "isis", "levels", "level", "link-state-database", "lsp", "tlvs", "tlv", "hostname", ] def _get_state(self): """ Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state (container) YANG Description: State parameters of ISIS TLV 137. """ return self.__state def _set_state(self, v, load=False): """ Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state (container) If this variable is read-only (config: false) in the source YANG file, then _set_state is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_state() directly. YANG Description: State parameters of ISIS TLV 137. """ if hasattr(v, "_utype"): v = v._utype(v) try: t = YANGDynClass( v, base=state.state, is_container="container", yang_name="state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace="http://openconfig.net/yang/network-instance", defining_module="openconfig-network-instance", yang_type="container", is_config=False, ) except (TypeError, ValueError): raise ValueError( { "error-string": """state must be of a type compatible with container""", "defined-type": "container", "generated-type": """YANGDynClass(base=state.state, is_container='container', yang_name="state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='container', is_config=False)""", } ) self.__state = t if hasattr(self, "_set"): self._set() def _unset_state(self): self.__state = YANGDynClass( base=state.state, is_container="container", yang_name="state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace="http://openconfig.net/yang/network-instance", defining_module="openconfig-network-instance", yang_type="container", is_config=False, ) state = __builtin__.property(_get_state) _pyangbind_elements = OrderedDict([("state", state)]) from . import state class hostname(PybindBase): """ This class was auto-generated by the PythonClass plugin for PYANG from YANG module openconfig-network-instance-l2 - based on the path /network-instances/network-instance/protocols/protocol/isis/levels/level/link-state-database/lsp/tlvs/tlv/hostname. Each member element of the container is represented as a class variable - with a specific YANG type. YANG Description: This container defines TLV 137. """ __slots__ = ("_path_helper", "_extmethods", "__state") _yang_name = "hostname" _pybind_generated_by = "container" def __init__(self, *args, **kwargs): self._path_helper = False self._extmethods = False self.__state = YANGDynClass( base=state.state, is_container="container", yang_name="state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace="http://openconfig.net/yang/network-instance", defining_module="openconfig-network-instance", yang_type="container", is_config=False, ) load = kwargs.pop("load", None) if args: if len(args) > 1: raise TypeError("cannot create a YANG container with >1 argument") all_attr = True for e in self._pyangbind_elements: if not hasattr(args[0], e): all_attr = False break if not all_attr: raise ValueError("Supplied object did not have the correct attributes") for e in self._pyangbind_elements: nobj = getattr(args[0], e) if nobj._changed() is False: continue setmethod = getattr(self, "_set_%s" % e) if load is None: setmethod(getattr(args[0], e)) else: setmethod(getattr(args[0], e), load=load) def _path(self): if hasattr(self, "_parent"): return self._parent._path() + [self._yang_name] else: return [ "network-instances", "network-instance", "protocols", "protocol", "isis", "levels", "level", "link-state-database", "lsp", "tlvs", "tlv", "hostname", ] def _get_state(self): """ Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state (container) YANG Description: State parameters of ISIS TLV 137. """ return self.__state def _set_state(self, v, load=False): """ Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state (container) If this variable is read-only (config: false) in the source YANG file, then _set_state is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_state() directly. YANG Description: State parameters of ISIS TLV 137. """ if hasattr(v, "_utype"): v = v._utype(v) try: t = YANGDynClass( v, base=state.state, is_container="container", yang_name="state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace="http://openconfig.net/yang/network-instance", defining_module="openconfig-network-instance", yang_type="container", is_config=False, ) except (TypeError, ValueError): raise ValueError( { "error-string": """state must be of a type compatible with container""", "defined-type": "container", "generated-type": """YANGDynClass(base=state.state, is_container='container', yang_name="state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='http://openconfig.net/yang/network-instance', defining_module='openconfig-network-instance', yang_type='container', is_config=False)""", } ) self.__state = t if hasattr(self, "_set"): self._set() def _unset_state(self): self.__state = YANGDynClass( base=state.state, is_container="container", yang_name="state", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace="http://openconfig.net/yang/network-instance", defining_module="openconfig-network-instance", yang_type="container", is_config=False, ) state = __builtin__.property(_get_state) _pyangbind_elements = OrderedDict([("state", state)])
napalm-automation/napalm-yang
napalm_yang/models/openconfig/network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/__init__.py
Python
apache-2.0
11,660
0.001286
from steps.bdd_test_util import cli_call def after_scenario(context, scenario): if 'doNotDecompose' in scenario.tags: print("Not going to decompose after scenario {0}, with yaml '{1}'".format(scenario.name, context.compose_yaml)) else: if 'compose_yaml' in context: print("Decomposing with yaml '{0}' after scenario {1}, ".format(context.compose_yaml, scenario.name)) context.compose_output, context.compose_error, context.compose_returncode = \ cli_call(context, ["docker-compose", "-f", context.compose_yaml, "kill"], expect_success=True) context.compose_output, context.compose_error, context.compose_returncode = \ cli_call(context, ["docker-compose", "-f", context.compose_yaml, "rm","-f"], expect_success=True) # now remove any other containers (chaincodes) context.compose_output, context.compose_error, context.compose_returncode = \ cli_call(context, ["docker", "ps", "-qa"], expect_success=True) if context.compose_returncode == 0: # Remove each container for containerId in context.compose_output.splitlines(): #print("docker rm {0}".format(containerId)) context.compose_output, context.compose_error, context.compose_returncode = \ cli_call(context, ["docker", "rm", containerId], expect_success=True)
ghaskins/obc-peer
openchain/peer/bddtests/environment.py
Python
apache-2.0
1,357
0.034635
# -*- coding: utf-8 -*- # # 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. # from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals from airflow.utils import timezone from datetime import datetime, timedelta from dateutil.relativedelta import relativedelta # flake8: noqa: F401 for doctest import six from croniter import croniter cron_presets = { '@hourly': '0 * * * *', '@daily': '0 0 * * *', '@weekly': '0 0 * * 0', '@monthly': '0 0 1 * *', '@yearly': '0 0 1 1 *', } def date_range(start_date, end_date=None, num=None, delta=None): """ Get a set of dates as a list based on a start, end and delta, delta can be something that can be added to ``datetime.datetime`` or a cron expression as a ``str`` :param start_date: anchor date to start the series from :type start_date: datetime.datetime :param end_date: right boundary for the date range :type end_date: datetime.datetime :param num: alternatively to end_date, you can specify the number of number of entries you want in the range. This number can be negative, output will always be sorted regardless :type num: int >>> date_range(datetime(2016, 1, 1), datetime(2016, 1, 3), delta=timedelta(1)) [datetime.datetime(2016, 1, 1, 0, 0), datetime.datetime(2016, 1, 2, 0, 0), datetime.datetime(2016, 1, 3, 0, 0)] >>> date_range(datetime(2016, 1, 1), datetime(2016, 1, 3), delta='0 0 * * *') [datetime.datetime(2016, 1, 1, 0, 0), datetime.datetime(2016, 1, 2, 0, 0), datetime.datetime(2016, 1, 3, 0, 0)] >>> date_range(datetime(2016, 1, 1), datetime(2016, 3, 3), delta="0 0 0 * *") [datetime.datetime(2016, 1, 1, 0, 0), datetime.datetime(2016, 2, 1, 0, 0), datetime.datetime(2016, 3, 1, 0, 0)] """ if not delta: return [] if end_date and start_date > end_date: raise Exception("Wait. start_date needs to be before end_date") if end_date and num: raise Exception("Wait. Either specify end_date OR num") if not end_date and not num: end_date = timezone.utcnow() delta_iscron = False tz = start_date.tzinfo if isinstance(delta, six.string_types): delta_iscron = True start_date = timezone.make_naive(start_date, tz) cron = croniter(delta, start_date) elif isinstance(delta, timedelta): delta = abs(delta) dates = [] if end_date: if timezone.is_naive(start_date): end_date = timezone.make_naive(end_date, tz) while start_date <= end_date: if timezone.is_naive(start_date): dates.append(timezone.make_aware(start_date, tz)) else: dates.append(start_date) if delta_iscron: start_date = cron.get_next(datetime) else: start_date += delta else: for _ in range(abs(num)): if timezone.is_naive(start_date): dates.append(timezone.make_aware(start_date, tz)) else: dates.append(start_date) if delta_iscron: if num > 0: start_date = cron.get_next(datetime) else: start_date = cron.get_prev(datetime) else: if num > 0: start_date += delta else: start_date -= delta return sorted(dates) def round_time(dt, delta, start_date=timezone.make_aware(datetime.min)): """ Returns the datetime of the form start_date + i * delta which is closest to dt for any non-negative integer i. Note that delta may be a datetime.timedelta or a dateutil.relativedelta >>> round_time(datetime(2015, 1, 1, 6), timedelta(days=1)) datetime.datetime(2015, 1, 1, 0, 0) >>> round_time(datetime(2015, 1, 2), relativedelta(months=1)) datetime.datetime(2015, 1, 1, 0, 0) >>> round_time(datetime(2015, 9, 16, 0, 0), timedelta(1), datetime(2015, 9, 14, 0, 0)) datetime.datetime(2015, 9, 16, 0, 0) >>> round_time(datetime(2015, 9, 15, 0, 0), timedelta(1), datetime(2015, 9, 14, 0, 0)) datetime.datetime(2015, 9, 15, 0, 0) >>> round_time(datetime(2015, 9, 14, 0, 0), timedelta(1), datetime(2015, 9, 14, 0, 0)) datetime.datetime(2015, 9, 14, 0, 0) >>> round_time(datetime(2015, 9, 13, 0, 0), timedelta(1), datetime(2015, 9, 14, 0, 0)) datetime.datetime(2015, 9, 14, 0, 0) """ if isinstance(delta, six.string_types): # It's cron based, so it's easy tz = start_date.tzinfo start_date = timezone.make_naive(start_date, tz) cron = croniter(delta, start_date) prev = cron.get_prev(datetime) if prev == start_date: return timezone.make_aware(start_date, tz) else: return timezone.make_aware(prev, tz) # Ignore the microseconds of dt dt -= timedelta(microseconds=dt.microsecond) # We are looking for a datetime in the form start_date + i * delta # which is as close as possible to dt. Since delta could be a relative # delta we don't know its exact length in seconds so we cannot rely on # division to find i. Instead we employ a binary search algorithm, first # finding an upper and lower limit and then disecting the interval until # we have found the closest match. # We first search an upper limit for i for which start_date + upper * delta # exceeds dt. upper = 1 while start_date + upper * delta < dt: # To speed up finding an upper limit we grow this exponentially by a # factor of 2 upper *= 2 # Since upper is the first value for which start_date + upper * delta # exceeds dt, upper // 2 is below dt and therefore forms a lower limited # for the i we are looking for lower = upper // 2 # We now continue to intersect the interval between # start_date + lower * delta and start_date + upper * delta # until we find the closest value while True: # Invariant: start + lower * delta < dt <= start + upper * delta # If start_date + (lower + 1)*delta exceeds dt, then either lower or # lower+1 has to be the solution we are searching for if start_date + (lower + 1) * delta >= dt: # Check if start_date + (lower + 1)*delta or # start_date + lower*delta is closer to dt and return the solution if ( (start_date + (lower + 1) * delta) - dt <= dt - (start_date + lower * delta)): return start_date + (lower + 1) * delta else: return start_date + lower * delta # We intersect the interval and either replace the lower or upper # limit with the candidate candidate = lower + (upper - lower) // 2 if start_date + candidate * delta >= dt: upper = candidate else: lower = candidate # in the special case when start_date > dt the search for upper will # immediately stop for upper == 1 which results in lower = upper // 2 = 0 # and this function returns start_date. def infer_time_unit(time_seconds_arr): """ Determine the most appropriate time unit for an array of time durations specified in seconds. e.g. 5400 seconds => 'minutes', 36000 seconds => 'hours' """ if len(time_seconds_arr) == 0: return 'hours' max_time_seconds = max(time_seconds_arr) if max_time_seconds <= 60 * 2: return 'seconds' elif max_time_seconds <= 60 * 60 * 2: return 'minutes' elif max_time_seconds <= 24 * 60 * 60 * 2: return 'hours' else: return 'days' def scale_time_units(time_seconds_arr, unit): """ Convert an array of time durations in seconds to the specified time unit. """ if unit == 'minutes': return list(map(lambda x: x * 1.0 / 60, time_seconds_arr)) elif unit == 'hours': return list(map(lambda x: x * 1.0 / (60 * 60), time_seconds_arr)) elif unit == 'days': return list(map(lambda x: x * 1.0 / (24 * 60 * 60), time_seconds_arr)) return time_seconds_arr def days_ago(n, hour=0, minute=0, second=0, microsecond=0): """ Get a datetime object representing `n` days ago. By default the time is set to midnight. """ today = timezone.utcnow().replace( hour=hour, minute=minute, second=second, microsecond=microsecond) return today - timedelta(days=n) def parse_execution_date(execution_date_str): """ Parse execution date string to datetime object. """ return timezone.parse(execution_date_str)
sid88in/incubator-airflow
airflow/utils/dates.py
Python
apache-2.0
9,508
0.000947
# Copyright 2014 Amazon.com, Inc. or its affiliates. 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. A copy of # the License is located at # # http://aws.amazon.com/apache2.0/ # # or in the "license" file accompanying this file. This file 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. """Customizations for the cloudsearchdomain command. This module customizes the cloudsearchdomain command: * Add validation that --endpoint-url is required. """ def register_cloudsearchdomain(cli): cli.register_last('calling-command.cloudsearchdomain', validate_endpoint_url) def validate_endpoint_url(parsed_globals, **kwargs): if parsed_globals.endpoint_url is None: return ValueError( "--endpoint-url is required for cloudsearchdomain commands")
LockScreen/Backend
venv/lib/python2.7/site-packages/awscli/customizations/cloudsearchdomain.py
Python
mit
1,074
0.000931
#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Description: Plot the delay evolution during a run for multiple ones having the run_time (in seconds) shown on the X axis. @author: dspaccapeli """ #imports to manage the sql db import sqlite3 as lite import pandas as pd #to make the plot show-up from command line import matplotlib.pyplot as plt #to get multiple evolution of delay from random import shuffle #connect to the database db_connection = lite.connect('DATABASE_PATH') #open the cursor to start querying the database - read ops read_curs = db_connection.cursor() #this is line 550 route_id = 2550 #refine query hh_start = 15 hh_end = 2 wk_start = 1 wk_end = 5 direction = 1 #select all infos for stop equals _n_sqlite df = pd.read_sql_query("SELECT delay, sch_time-start_time as time, start_time as begin from hsl where route_id=%s and direction=%s or hour>=%s and hour<=%s order by time" % \ (route_id, direction, hh_start, hh_end), db_connection) #select a list of all the different start_time -> they identify daily departures for a bus (~run_code) unq_dep = df.begin.unique() #init 9 plots for count in [1, 2, 3, 4, 5, 6, 7, 8, 9]: #take a random run_code shuffle(unq_dep) i=0 for x in unq_dep: i+=1 #for each run_code temp = df[df['begin'] == x] #plot evolution of the delay plt.plot(temp['time'], temp['delay'], alpha=0.6) #plt.scatter(temp['time'], temp['delay'], alpha=0.7) #up to a max of 5 lines if i==10: break plt.suptitle('Delay progression between %s and %s during the week' % (hh_start, hh_end)) plt.xlabel('run time') plt.ylabel('delay') plt.savefig(str(count), ext="png") plt.clf() #uncomment if you want to do it cumulatively #plt.suptitle('Delay progression between %s and %s during the week' % (hh_start, hh_end)) #plt.xlabel('run time') #plt.ylabel('delay') #plt.savefig(str(count), ext="png") #plt.clf()
dspaccapeli/bus-arrival
visualization/plot_delay_evo.py
Python
gpl-3.0
1,979
0.016675
# coding=utf-8 # Copyright 2018 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from __future__ import (absolute_import, division, generators, nested_scopes, print_function, unicode_literals, with_statement) import logging from pants.contrib.node.subsystems.command import command_gen LOG = logging.getLogger(__name__) PACKAGE_MANAGER_NPM = 'npm' PACKAGE_MANAGER_YARNPKG = 'yarnpkg' PACKAGE_MANAGER_YARNPKG_ALIAS = 'yarn' VALID_PACKAGE_MANAGERS = [PACKAGE_MANAGER_NPM, PACKAGE_MANAGER_YARNPKG, PACKAGE_MANAGER_YARNPKG_ALIAS] # TODO: Change to enum type when migrated to Python 3.4+ class PackageInstallationTypeOption(object): PROD = 'prod' DEV = 'dev' PEER = 'peer' BUNDLE = 'bundle' OPTIONAL = 'optional' NO_SAVE = 'not saved' class PackageInstallationVersionOption(object): EXACT = 'exact' TILDE = 'tilde' class PackageManager(object): """Defines node package manager functionalities.""" def __init__(self, name, tool_installations): self.name = name self.tool_installations = tool_installations def _get_installation_args(self, install_optional, production_only, force): """Returns command line args for installing package. :param install_optional: True to request install optional dependencies. :param production_only: True to only install production dependencies, i.e. ignore devDependencies. :param force: True to force re-download dependencies. :rtype: list of strings """ raise NotImplementedError def _get_run_script_args(self): """Returns command line args to run a package.json script. :rtype: list of strings """ raise NotImplementedError def _get_add_package_args(self, package, type_option, version_option): """Returns command line args to add a node pacakge. :rtype: list of strings """ raise NotImplementedError() def run_command(self, args=None, node_paths=None): """Returns a command that when executed will run an arbitury command via package manager.""" return command_gen( self.tool_installations, self.name, args=args, node_paths=node_paths ) def install_module( self, install_optional=False, production_only=False, force=False, node_paths=None): """Returns a command that when executed will install node package. :param install_optional: True to install optional dependencies. :param production_only: True to only install production dependencies, i.e. ignore devDependencies. :param force: True to force re-download dependencies. :param node_paths: A list of path that should be included in $PATH when running installation. """ args=self._get_installation_args( install_optional=install_optional, production_only=production_only, force=force) return self.run_command(args=args, node_paths=node_paths) def run_script(self, script_name, script_args=None, node_paths=None): """Returns a command to execute a package.json script. :param script_name: Name of the script to name. Note that script name 'test' can be used to run node tests. :param script_args: Args to be passed to package.json script. :param node_paths: A list of path that should be included in $PATH when running the script. """ # TODO: consider add a pants.util function to manipulate command line. package_manager_args = self._get_run_script_args() package_manager_args.append(script_name) if script_args: package_manager_args.append('--') package_manager_args.extend(script_args) return self.run_command(args=package_manager_args, node_paths=node_paths) def add_package( self, package, node_paths=None, type_option=PackageInstallationTypeOption.PROD, version_option=None): """Returns a command that when executed will add a node package to current node module. :param package: string. A valid npm/yarn package description. The accepted forms are package-name, package-name@version, package-name@tag, file:/folder, file:/path/to.tgz https://url/to.tgz :param node_paths: A list of path that should be included in $PATH when running the script. :param type_option: A value from PackageInstallationTypeOption that indicates the type of package to be installed. Default to 'prod', which is a production dependency. :param version_option: A value from PackageInstallationVersionOption that indicates how to match version. Default to None, which uses package manager default. """ args=self._get_add_package_args( package, type_option=type_option, version_option=version_option) return self.run_command(args=args, node_paths=node_paths) def run_cli(self, cli, args=None, node_paths=None): """Returns a command that when executed will run an installed cli via package manager.""" cli_args = [cli] if args: cli_args.append('--') cli_args.extend(args) return self.run_command(args=cli_args, node_paths=node_paths) class PackageManagerYarnpkg(PackageManager): def __init__(self, tool_installation): super(PackageManagerYarnpkg, self).__init__(PACKAGE_MANAGER_YARNPKG, tool_installation) def _get_run_script_args(self): return ['run'] def _get_installation_args(self, install_optional, production_only, force): return_args = ['--non-interactive'] if not install_optional: return_args.append('--ignore-optional') if production_only: return_args.append('--production=true') if force: return_args.append('--force') return return_args def _get_add_package_args(self, package, type_option, version_option): return_args = ['add', package] package_type_option = { PackageInstallationTypeOption.PROD: '', # Yarn save production is the default. PackageInstallationTypeOption.DEV: '--dev', PackageInstallationTypeOption.PEER: '--peer', PackageInstallationTypeOption.OPTIONAL: '--optional', PackageInstallationTypeOption.BUNDLE: None, PackageInstallationTypeOption.NO_SAVE: None, }.get(type_option) if package_type_option is None: logging.warning('{} does not support {} packages, ignored.'.format(self.name, type_option)) elif package_type_option: # Skip over '' entries return_args.append(package_type_option) package_version_option = { PackageInstallationVersionOption.EXACT: '--exact', PackageInstallationVersionOption.TILDE: '--tilde', }.get(version_option) if package_version_option is None: LOG.warning( '{} does not support install with {} version, ignored'.format(self.name, version_option)) elif package_version_option: # Skip over '' entries return_args.append(package_version_option) return return_args class PackageManagerNpm(PackageManager): def __init__(self, tool_installation): super(PackageManagerNpm, self).__init__(PACKAGE_MANAGER_NPM, tool_installation) def _get_run_script_args(self): return ['run-script'] def _get_installation_args(self, install_optional, production_only, force): return_args = ['install'] if not install_optional: return_args.append('--no-optional') if production_only: return_args.append('--production') if force: return_args.append('--force') return return_args def _get_add_package_args(self, package, type_option, version_option): return_args = ['install', package] package_type_option = { PackageInstallationTypeOption.PROD: '--save-prod', PackageInstallationTypeOption.DEV: '--save-dev', PackageInstallationTypeOption.PEER: None, PackageInstallationTypeOption.OPTIONAL: '--save-optional', PackageInstallationTypeOption.BUNDLE: '--save-bundle', PackageInstallationTypeOption.NO_SAVE: '--no-save', }.get(type_option) if package_type_option is None: logging.warning('{} does not support {} packages, ignored.'.format(self.name, type_option)) elif package_type_option: # Skip over '' entries return_args.append(package_type_option) package_version_option = { PackageInstallationVersionOption.EXACT: '--save-exact', PackageInstallationVersionOption.TILDE: None, }.get(version_option) if package_version_option is None: LOG.warning( '{} does not support install with {} version, ignored.'.format(self.name, version_option)) elif package_version_option: # Skip over '' entries return_args.append(package_version_option) return return_args def run_cli(self, cli, args=None, node_paths=None): raise RuntimeError('npm does not support run cli directly. Please use Yarn instead.')
UnrememberMe/pants
contrib/node/src/python/pants/contrib/node/subsystems/package_managers.py
Python
apache-2.0
8,798
0.007729
#!/usr/bin/env python """Shared classes between the client and the server for plist parsing.""" import calendar import datetime from binplist import binplist from grr.lib import lexer from grr.lib import objectfilter class PlistFilterParser(objectfilter.Parser): """Plist specific filter parser. Because we will be filtering dictionaries and the path components will be matched against dictionary keys, we must be more permissive with attribute names. This parser allows path components to be enclosed in double quotes to allow for spaces, dots or even raw hex-escaped data in them, such as: "My\x20first\x20path component".2nd."TH.IRD" contains "Google" We store the attribute name as a list of paths into the object instead of as a simple string that will be chunked in objectfilter. """ tokens = [ # Operators and related tokens lexer.Token("INITIAL", r"\@[\w._0-9]+", "ContextOperator,PushState", "CONTEXTOPEN"), lexer.Token("INITIAL", r"[^\s\(\)]", "PushState,PushBack", "ATTRIBUTE"), lexer.Token("INITIAL", r"\(", "PushState,BracketOpen", None), lexer.Token("INITIAL", r"\)", "BracketClose", "BINARY"), # Context lexer.Token("CONTEXTOPEN", r"\(", "BracketOpen", "INITIAL"), # Double quoted string lexer.Token("STRING", "\"", "PopState,StringFinish", None), lexer.Token("STRING", r"\\x(..)", "HexEscape", None), lexer.Token("STRING", r"\\(.)", "StringEscape", None), lexer.Token("STRING", r"[^\\\"]+", "StringInsert", None), # Single quoted string lexer.Token("SQ_STRING", "'", "PopState,StringFinish", None), lexer.Token("SQ_STRING", r"\\x(..)", "HexEscape", None), lexer.Token("SQ_STRING", r"\\(.)", "StringEscape", None), lexer.Token("SQ_STRING", r"[^\\']+", "StringInsert", None), # Basic expression lexer.Token("ATTRIBUTE", r"\.", "AddAttributePath", "ATTRIBUTE"), lexer.Token("ATTRIBUTE", r"\s+", "AddAttributePath", "OPERATOR"), lexer.Token("ATTRIBUTE", "\"", "PushState,StringStart", "STRING"), lexer.Token("ATTRIBUTE", r"[\w_0-9\-]+", "StringStart,StringInsert", "ATTRIBUTE"), lexer.Token("OPERATOR", r"(\w+|[<>!=]=?)", "StoreOperator", "ARG"), lexer.Token("ARG", r"(\d+\.\d+)", "InsertFloatArg", "ARG"), lexer.Token("ARG", r"(0x\d+)", "InsertInt16Arg", "ARG"), lexer.Token("ARG", r"(\d+)", "InsertIntArg", "ARG"), lexer.Token("ARG", "\"", "PushState,StringStart", "STRING"), lexer.Token("ARG", "'", "PushState,StringStart", "SQ_STRING"), # When the last parameter from arg_list has been pushed # State where binary operators are supported (AND, OR) lexer.Token("BINARY", r"(?i)(and|or|\&\&|\|\|)", "BinaryOperator", "INITIAL"), # - We can also skip spaces lexer.Token("BINARY", r"\s+", None, None), # - But if it's not "and" or just spaces we have to go back lexer.Token("BINARY", ".", "PushBack,PopState", None), # Skip whitespace. lexer.Token(".", r"\s+", None, None), ] def StringFinish(self, **_): """StringFinish doesn't act on ATTRIBUTEs here.""" if self.state == "ARG": return self.InsertArg(string=self.string) def AddAttributePath(self, **_): """Adds a path component to the current attribute.""" attribute_path = self.current_expression.attribute if not attribute_path: attribute_path = [] attribute_path.append(self.string) self.current_expression.SetAttribute(attribute_path) class PlistExpander(objectfilter.ValueExpander): """A custom expander specific to plists.""" def _GetValue(self, obj, attr_name): try: return obj.get(attr_name, None) except AttributeError: # This is no dictionary... are we a list of dictionaries? return [item.get(attr_name, None) for item in obj] def _AtNonLeaf(self, attr_value, path): """Makes dictionaries expandable when dealing with plists.""" if isinstance(attr_value, dict): for value in self.Expand(attr_value, path[1:]): yield value else: for v in objectfilter.ValueExpander._AtNonLeaf(self, attr_value, path): yield v class PlistFilterImplementation(objectfilter.BaseFilterImplementation): FILTERS = {} FILTERS.update(objectfilter.BaseFilterImplementation.FILTERS) FILTERS.update({"ValueExpander": PlistExpander}) def PlistValueToPlainValue(plist): """Takes the plist contents generated by binplist and returns a plain dict. binplist uses rich types to express some of the plist types. We need to convert them to types that RDFValueArray will be able to transport. Args: plist: A plist to convert. Returns: A simple python type. """ if isinstance(plist, dict): ret_value = dict() for key, value in plist.items(): ret_value[key] = PlistValueToPlainValue(value) return ret_value elif isinstance(plist, list): return [PlistValueToPlainValue(value) for value in plist] elif isinstance(plist, binplist.RawValue): return plist.value elif (isinstance(plist, binplist.CorruptReference) or isinstance(plist, binplist.UnknownObject)): return None elif isinstance(plist, datetime.datetime): return (calendar.timegm(plist.utctimetuple()) * 1000000) + plist.microsecond return plist
darrenbilby/grr
lib/plist.py
Python
apache-2.0
5,402
0.004813
from math import cos, sin, pi from example_util import get_filename from glc import Gif def draw(l, surf, ctx, t): xpos = cos(t * 2 * pi) * 100 + surf.get_width() * 0.5 ypos = sin(t * 2 * pi) * 100 + surf.get_height() * 0.5 w, h = 100, 100 ctx.set_source_rgb(0, 0, 0) ctx.translate(xpos, ypos) ctx.translate(-w * 0.5, -h * 0.5) ctx.rectangle(0, 0, w, w) ctx.fill() with Gif(get_filename(__file__), after_render=draw) as a: a.save()
leovoel/glc.py
examples/custom_rendering.py
Python
mit
473
0.002114
""" Copyright (c) 2012-2013 RockStor, Inc. <http://rockstor.com> This file is part of RockStor. RockStor 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. RockStor 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/>. """ from rest_framework.views import APIView from rest_framework.response import Response from rest_framework.authentication import (BasicAuthentication, SessionAuthentication) from django.db import transaction from storageadmin.auth import DigestAuthentication from storageadmin.models import (Share, SambaShare, NFSExport, Disk, IscsiTarget) from storageadmin.util import handle_exception from storageadmin.serializers import IscsiSerializer from system.iscsi import export_iscsi from fs.btrfs import mount_share import logging logger = logging.getLogger(__name__) class ShareIscsiView(APIView): def get(self, request, sname): try: share = Share.objects.get(name=sname) if (IscsiTarget.objects.filter(share=share).exists()): iscsi_o = IscsiTarget.objects.get(share=share) iscsi_serializer = IscsiSerializer(iscsi_o) return Response(iscsi_serializer.data) return Response() except Exception, e: handle_exception(e, request) @transaction.commit_on_success def post(self, request, sname): try: share = Share.objects.get(name=sname) if (SambaShare.objects.filter(share=share).exists()): raise Exception('Already exported via Samba') if (NFSExport.objects.filter(share=share).exists()): raise Exception('Already exported via nfs') if (IscsiTarget.objects.filter(share=share).exists()): raise Exception('Already exported via iscsi') options = { 'tname': 'fooscsi', 'tid': -1, 'dev_name': 'iscsi.img', 'dev_size': 10, } if ('tname' in request.data): options['tname'] = request.data['tname'] if ('tid' in request.data): try: options['tid'] = int(request.data['tid']) except: raise Exception('tid must be an integer') pool_device = Disk.objects.filter(pool=share.pool)[0].name mnt_pt = '/mnt2/' + share.name mount_share(share.name, pool_device, mnt_pt) dev_name = mnt_pt + '/' + options['dev_name'] export_iscsi(options['tid'], options['tname'], options['tid'], dev_name, options['dev_size']) iscsi_target = IscsiTarget(share=share, tid=options['tid'], tname=options['tname'], dev_name=dev_name, dev_size=options['dev_size']) iscsi_target.save() iscsi_serializer = IscsiSerializer(iscsi_target) return Response(iscsi_serializer.data) except Exception, e: handle_exception(e, request) @transaction.commit_on_success def delete(self, request, sname): try: share = Share.objects.get(name=sname) iscsi_target = IscsiTarget.objects.get(share=share) iscsi_target.delete() return Response() except Exception, e: handle_exception(e, request)
sbrichards/rockstor-core
src/rockstor/storageadmin/views/share_iscsi.py
Python
gpl-3.0
4,001
0.00025
# small script for from optparse import OptionParser import sqlite3 import time import string import arnovich.core as core def parse_command_args(): parser = OptionParser() parser.add_option("-t", "--ticker", action="append", type="string", dest="tickers") parser.add_option("--from", action="store", type="string", dest="fromdate", default="") parser.add_option("--to", action="store", type="string", dest="todate", default="") parser.add_option("--db", action="store", dest="dbfile") parser.add_option("--wait", action="store", type="int", dest="wait", default=1) (options, args) = parser.parse_args() return (options.dbfile, options.tickers, options.fromdate, options.todate, options.wait) def find_dates(dbfile, tickers, fromdate, todate, wait): if fromdate != "": fromtime = time.mktime(time.strptime(fromdate, "%Y-%m-%d %H:%M:%S")) if todate != "": totime = time.mktime(time.strptime(todate, "%Y-%m-%d %H:%M:%S")) connection = core.connection() sql_tickers = string.join(tickers, "\",\"") conn = sqlite3.connect(dbfile) c = conn.cursor() d = conn.cursor() c.execute("select ticker_id, ticker from stocks_static_data where ticker in (\""+sql_tickers+"\")") prevtime = 0 for ticker_id in c: #should check if it already exists using get_ticker srv_id = connection.add_ticker(str(ticker_id[1])) srv_id_opt = connection.add_ticker(str(ticker_id[1])+"_options") if (fromdate == "") or (todate == ""): d.execute("select date, data from stocks_data where ticker_id="+str(ticker_id[0])+" ORDER BY date") else: d.execute("select date, data from stocks_data where ticker_id="+str(ticker_id[0])+" and (date > "+str(fromtime)+" AND date < "+str(totime)+")") for r in d: rowdate = str(r[0]) rowdata = str(r[1]) rowtime = float(r[0]) if prevtime == 0: prevtime = rowtime connection.push_ticker(srv_id, rowdata) vcursor = conn.cursor() vcursor.execute("select data from options_data where ticker_id="+str(ticker_id[0])+" and date="+rowdate) for row in vcursor: connection.push_ticker(srv_id_opt, str(row[0])) #TODO make this better: take exec time into consideration time.sleep((rowtime-prevtime)/wait) prevtime = rowtime c.close() def main(): (dbfile, tickers, fromdate, todate, wait) = parse_command_args() find_dates(dbfile, tickers, fromdate, todate, wait) if __name__ == "__main__": main()
arnovich/core
test/yahoo/py/extract_to_srv.py
Python
bsd-3-clause
2,381
0.025619
class Solution: # @param {integer} s # @param {integer[]} nums # @return {integer} def minSubArrayLen(self, s, nums): i = 0 j = -1 n = len(nums) t = 0 min_len = sys.maxint while(i<n and j <n): if t < s: j += 1 if j >=n : break t += nums[j] else: if min_len > (j-i+1): min_len = j-i+1 t -= nums[i] i += 1 if min_len == sys.maxint: return 0 else: return min_len
saai/codingbitch
twoPointers/minSubArrayLen.py
Python
mit
623
0.008026
__version__ = "0.0.2a3"
trueneu/swiss-knife
swk_plugins/swk_casp/swk_casp/version.py
Python
gpl-3.0
24
0
from __future__ import division import numpy as np from numpy.lib.stride_tricks import as_strided as ast ### striding data for efficient AR computations def AR_striding(data,nlags): # I had some trouble with views and as_strided, so copy if not contiguous data = np.asarray(data) if not data.flags.c_contiguous: data = data.copy(order='C') if data.ndim == 1: data = np.reshape(data,(-1,1)) sz = data.dtype.itemsize return ast( data, shape=(data.shape[0]-nlags,data.shape[1]*(nlags+1)), strides=(data.shape[1]*sz,sz)) def undo_AR_striding(strided_data,nlags): sz = strided_data.dtype.itemsize return ast( strided_data, shape=(strided_data.shape[0]+nlags,strided_data.shape[1]//(nlags+1)), strides=(strided_data.shape[1]//(nlags+1)*sz,sz)) ### analyzing AR coefficient matrices def canonical_matrix(A): # NOTE: throws away affine part D, nlags, _ = dimensions(A) mat = np.zeros((D*nlags,D*nlags)) mat[:-D,D:] = np.eye(D*(nlags-1)) mat[-D:,:] = A[:,:D*nlags] return mat def eval_siso_transfer_function(A,from_idx,to_idx,freqs): D, _, _ = dimensions(A) assert 0 <= from_idx < D and 0 <= to_idx < D bigA = canonical_matrix(A) I = np.eye(bigA.shape[0]) zs = np.exp(1j*np.array(freqs)) return np.array( [np.linalg.inv(z*I-bigA)[-D:,-2*D:-D][to_idx,from_idx] for z in zs]) def is_affine(A): return bool(A.shape[1] % A.shape[0]) def is_stable(A): bigA = canonical_matrix(A) return np.all(np.abs(np.linalg.eigvals(bigA)) < 1.) def dimensions(A): if is_affine(A): A = A[:,:-1] D, nlags = A.shape[0], A.shape[1] // A.shape[0] return D, nlags, is_affine(A)
mattjj/pyhsmm-autoregressive
autoregressive/util.py
Python
gpl-2.0
1,782
0.016835
import unittest import numpy as np import pyoptima as opt class SimulatedAnnealingTest(unittest.TestCase): def test_with_parabola(self): """ Test with a simple parabolic function with 2 variables """ def neighbour_func(params): new_params = params params['x0'] += np.random.uniform(-1., 1.) params['x1'] += np.random.uniform(-1., 1.) return new_params hyper_params = { 'temperature_func': lambda t, i: t/np.log(i+2), 'neighbour_func': neighbour_func, 'initial_temp': 1000000.0 } params = {} params["x0"] = np.random.uniform(-10., 10.) params["x1"] = np.random.uniform(-10., 10.) s = opt.SimulatedAnnealing(params, hyper_params) s.optimize(opt.parabola, 100000) bst_solution = s.get_best_parameters() self.assertAlmostEqual(bst_solution['x0'], 0, 2) self.assertAlmostEqual(bst_solution['x1'], 0, 2) if __name__ == "__main__": unittest.main()
samueljackson92/metaopt
python_tests/simulated_annealing_test.py
Python
mit
1,038
0.000963
import angr import claripy import os test_location = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', '..', 'binaries', 'tests') def test_i386(): p = angr.Project(os.path.join(test_location, 'i386', 'test_strcasecmp'), auto_load_libs=False) arg1 = claripy.BVS('arg1', 20*8) s = p.factory.entry_state(args=("test_strcasecmp", arg1)) sm = p.factory.simulation_manager(s) sm.explore() sm.move('deadended', 'found', filter_func=lambda s: b"Welcome" in s.posix.dumps(1)) assert len(sm.found) == 1 f = sm.found[0] sol = f.solver.eval(arg1, cast_to=bytes) assert b'\x00' in sol assert sol[:sol.index(b'\x00')].lower() == b'letmein' assert b'wchar works' in f.posix.dumps(1) if __name__ == "__main__": test_i386()
angr/angr
tests/test_strcasecmp.py
Python
bsd-2-clause
780
0.00641
from django.contrib import admin from priorityDB.models import * # Register your models here # For more information on this file, see # https://docs.djangoproject.com/en/dev/intro/tutorial02/ class TaskHistoryInline(admin.StackedInline): model = TaskHistory extra = 0 class EventAdmin(admin.ModelAdmin): inlines = [TaskHistoryInline] admin.site.register(Event, EventAdmin) admin.site.register(Task)
lowellbander/ngVote
priorityDB/priorityDB/admin.py
Python
gpl-2.0
418
0.014354
# # Copyright (c) 2015 Autodesk 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. # """ This script illustrates how we handle process level sanity checks. This is an optional feature which lets you customize how you want ochopod to know what you're running is healthy. You could curl the process or run some script for instance. Too many sanity check failures will turn the pod off (which can be seen in the CLI for instance). Just start a local standalone Zookeeper server and run "python sanity.py". """ from ochopod.bindings.generic.marathon import Pod from ochopod.models.piped import Actor as Piped if __name__ == '__main__': class Strategy(Piped): # # - by default ochopod will only allow for one single sanity check to fail before turning off the pod # - you can specify both how many times you are ready to fail and how much time should go by in between # - here we want to tolerate up to 3 sanity check failures in a row with 5 seconds between each # checks = 3 check_every = 5.0 def sanity_check(self, _): # # - this optional callback will be invoked by ochopod on a regular basis # - you can do whatever you want inside and the goal is to not throw # - you can for instance simply assert if something is not right # - let's make it fail for the sake of illustration # - the callback will be invoked (and will blow up) every 5 seconds up to 3 times # assert 0, 'let us fail the sanity check just for fun' def configure(self, _): # # - just go to sleep, the point is not to run anything meaningful # - the sanity-check will keep failing until the pod turns off # return 'sleep 3600', {} # # - if you run this script locally you will notice the pod will turn off after around 15 seconds # - simply type CTRL-C to exit # Pod().boot(Strategy, local=1)
gomezsan/ochopod
examples/sanity.py
Python
apache-2.0
2,544
0.003931
import gamerocket from flask import Flask, request, render_template app = Flask(__name__) gamerocket.Configuration.configure(gamerocket.Environment.Development, apiKey = "your_apiKey", secretKey = "your_secretKey") @app.route("/") def form(): return render_template("form.html") @app.route("/create_player", methods=["POST"]) def create_player(): result = gamerocket.Player.create({ "name":request.form["name"], "locale":request.form["locale"] }) if result.is_success: return "<h1>Success! Player ID: " + result.player.id + "</h1>" else: return "<h1>Error " + result.error + ": " + result.error_description + "</h1>" if __name__ == '__main__': app.run(debug=True)
workbandits/gamerocket-python-guide
1_create_player/src/app.py
Python
mit
837
0.016726
''' Simple parser that extracts a webpage's content and hyperlinks. ''' import urllib2 import re class Parser(): def __init__(self): pass def parse(self, url): f = urllib2.urlopen(url) text = f.read() # get page's contents. #use re.findall to get all the links links = re.findall('href=[\'"]?([^\'" >]+)', text) return text, links
nyu-dl/WebNav
simple_parser.py
Python
bsd-3-clause
399
0.010025
# 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. from . import ObjectCreationParameters __author__ = 'Shamal Faily' class ResponseParameters(ObjectCreationParameters.ObjectCreationParameters): def __init__(self,respName,respRisk,tags,cProps,rType): ObjectCreationParameters.ObjectCreationParameters.__init__(self) self.theName = respName self.theTags = tags self.theRisk = respRisk self.theEnvironmentProperties = cProps self.theResponseType = rType def name(self): return self.theName def tags(self): return self.theTags def risk(self): return self.theRisk def environmentProperties(self): return self.theEnvironmentProperties def responseType(self): return self.theResponseType
nathanbjenx/cairis
cairis/core/ResponseParameters.py
Python
apache-2.0
1,469
0.008169
# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import functools from typing import Any, Callable, Dict, Generic, Optional, TypeVar import warnings from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse from azure.core.rest import HttpRequest from azure.core.tracing.decorator import distributed_trace from azure.mgmt.core.exceptions import ARMErrorFormat from msrest import Serializer from .. import models as _models from .._vendor import _convert_request, _format_url_section T = TypeVar('T') ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False def build_get_request( subscription_id: str, resource_group_name: str, spark_configuration_name: str, workspace_name: str, **kwargs: Any ) -> HttpRequest: api_version = "2021-06-01-preview" accept = "application/json" # Construct URL url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Synapse/workspaces/{workspaceName}/sparkconfigurations/{sparkConfigurationName}') path_format_arguments = { "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str', min_length=1), "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1), "sparkConfigurationName": _SERIALIZER.url("spark_configuration_name", spark_configuration_name, 'str'), "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'), } url = _format_url_section(url, **path_format_arguments) # Construct parameters query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') # Construct headers header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') return HttpRequest( method="GET", url=url, params=query_parameters, headers=header_parameters, **kwargs ) class SparkConfigurationOperations(object): """SparkConfigurationOperations operations. You should not instantiate this class directly. Instead, you should create a Client instance that instantiates it for you and attaches it as an attribute. :ivar models: Alias to model classes used in this operation group. :type models: ~azure.mgmt.synapse.models :param client: Client for service requests. :param config: Configuration of service client. :param serializer: An object model serializer. :param deserializer: An object model deserializer. """ models = _models def __init__(self, client, config, serializer, deserializer): self._client = client self._serialize = serializer self._deserialize = deserializer self._config = config @distributed_trace def get( self, resource_group_name: str, spark_configuration_name: str, workspace_name: str, **kwargs: Any ) -> "_models.SparkConfigurationResource": """Get SparkConfiguration by name. Get SparkConfiguration by name in a workspace. :param resource_group_name: The name of the resource group. The name is case insensitive. :type resource_group_name: str :param spark_configuration_name: SparkConfiguration name. :type spark_configuration_name: str :param workspace_name: The name of the workspace. :type workspace_name: str :keyword callable cls: A custom type or function that will be passed the direct response :return: SparkConfigurationResource, or the result of cls(response) :rtype: ~azure.mgmt.synapse.models.SparkConfigurationResource :raises: ~azure.core.exceptions.HttpResponseError """ cls = kwargs.pop('cls', None) # type: ClsType["_models.SparkConfigurationResource"] error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {})) request = build_get_request( subscription_id=self._config.subscription_id, resource_group_name=resource_group_name, spark_configuration_name=spark_configuration_name, workspace_name=workspace_name, template_url=self.get.metadata['url'], ) request = _convert_request(request) request.url = self._client.format_url(request.url) pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) deserialized = self._deserialize('SparkConfigurationResource', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Synapse/workspaces/{workspaceName}/sparkconfigurations/{sparkConfigurationName}'} # type: ignore
Azure/azure-sdk-for-python
sdk/synapse/azure-mgmt-synapse/azure/mgmt/synapse/operations/_spark_configuration_operations.py
Python
mit
6,172
0.004213
# -*- coding: utf-8 -*- # <Lettuce - Behaviour Driven Development for python> # Copyright (C) <2010-2011> Gabriel Falcão <gabriel@nacaolivre.org> # # 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/>. from django.http import HttpResponse def index(request): return HttpResponse('OK')
scaphe/lettuce-dirty
tests/integration/django/couves/leaves/views.py
Python
gpl-3.0
872
0.001148
# # THIS IS WORK IN PROGRESS # # The Python Imaging Library # $Id: PcfFontFile.py 2134 2004-10-06 08:55:20Z fredrik $ # # portable compiled font file parser # # history: # 1997-08-19 fl created # 2003-09-13 fl fixed loading of unicode fonts # # Copyright (c) 1997-2003 by Secret Labs AB. # Copyright (c) 1997-2003 by Fredrik Lundh. # # See the README file for information on usage and redistribution. # import Image import FontFile import string # -------------------------------------------------------------------- # declarations PCF_MAGIC = 0x70636601 # "\x01fcp" PCF_PROPERTIES = (1<<0) PCF_ACCELERATORS = (1<<1) PCF_METRICS = (1<<2) PCF_BITMAPS = (1<<3) PCF_INK_METRICS = (1<<4) PCF_BDF_ENCODINGS = (1<<5) PCF_SWIDTHS = (1<<6) PCF_GLYPH_NAMES = (1<<7) PCF_BDF_ACCELERATORS = (1<<8) BYTES_PER_ROW = [ lambda bits: ((bits+7) >> 3), lambda bits: ((bits+15) >> 3) & ~1, lambda bits: ((bits+31) >> 3) & ~3, lambda bits: ((bits+63) >> 3) & ~7, ] def l16(c): return ord(c[0]) + (ord(c[1])<<8) def l32(c): return ord(c[0]) + (ord(c[1])<<8) + (ord(c[2])<<16) + (ord(c[3])<<24) def b16(c): return ord(c[1]) + (ord(c[0])<<8) def b32(c): return ord(c[3]) + (ord(c[2])<<8) + (ord(c[1])<<16) + (ord(c[0])<<24) def sz(s, o): return s[o:string.index(s, "\0", o)] ## # Font file plugin for the X11 PCF format. class PcfFontFile(FontFile.FontFile): name = "name" def __init__(self, fp): magic = l32(fp.read(4)) if magic != PCF_MAGIC: raise SyntaxError, "not a PCF file" FontFile.FontFile.__init__(self) count = l32(fp.read(4)) self.toc = {} for i in range(count): type = l32(fp.read(4)) self.toc[type] = l32(fp.read(4)), l32(fp.read(4)), l32(fp.read(4)) self.fp = fp self.info = self._load_properties() metrics = self._load_metrics() bitmaps = self._load_bitmaps(metrics) encoding = self._load_encoding() # # create glyph structure for ch in range(256): ix = encoding[ch] if ix is not None: x, y, l, r, w, a, d, f = metrics[ix] glyph = (w, 0), (l, d-y, x+l, d), (0, 0, x, y), bitmaps[ix] self.glyph[ch] = glyph def _getformat(self, tag): format, size, offset = self.toc[tag] fp = self.fp fp.seek(offset) format = l32(fp.read(4)) if format & 4: i16, i32 = b16, b32 else: i16, i32 = l16, l32 return fp, format, i16, i32 def _load_properties(self): # # font properties properties = {} fp, format, i16, i32 = self._getformat(PCF_PROPERTIES) nprops = i32(fp.read(4)) # read property description p = [] for i in range(nprops): p.append((i32(fp.read(4)), ord(fp.read(1)), i32(fp.read(4)))) if nprops & 3: fp.seek(4 - (nprops & 3), 1) # pad data = fp.read(i32(fp.read(4))) for k, s, v in p: k = sz(data, k) if s: v = sz(data, v) properties[k] = v return properties def _load_metrics(self): # # font metrics metrics = [] fp, format, i16, i32 = self._getformat(PCF_METRICS) append = metrics.append if (format & 0xff00) == 0x100: # "compressed" metrics for i in range(i16(fp.read(2))): left = ord(fp.read(1)) - 128 right = ord(fp.read(1)) - 128 width = ord(fp.read(1)) - 128 ascent = ord(fp.read(1)) - 128 descent = ord(fp.read(1)) - 128 xsize = right - left ysize = ascent + descent append( (xsize, ysize, left, right, width, ascent, descent, 0) ) else: # "jumbo" metrics for i in range(i32(fp.read(4))): left = i16(fp.read(2)) right = i16(fp.read(2)) width = i16(fp.read(2)) ascent = i16(fp.read(2)) descent = i16(fp.read(2)) attributes = i16(fp.read(2)) xsize = right - left ysize = ascent + descent append( (xsize, ysize, left, right, width, ascent, descent, attributes) ) return metrics def _load_bitmaps(self, metrics): # # bitmap data bitmaps = [] fp, format, i16, i32 = self._getformat(PCF_BITMAPS) nbitmaps = i32(fp.read(4)) if nbitmaps != len(metrics): raise IOError, "Wrong number of bitmaps" offsets = [] for i in range(nbitmaps): offsets.append(i32(fp.read(4))) bitmapSizes = [] for i in range(4): bitmapSizes.append(i32(fp.read(4))) byteorder = format & 4 # non-zero => MSB bitorder = format & 8 # non-zero => MSB padindex = format & 3 bitmapsize = bitmapSizes[padindex] offsets.append(bitmapsize) data = fp.read(bitmapsize) pad = BYTES_PER_ROW[padindex] mode = "1;R" if bitorder: mode = "1" for i in range(nbitmaps): x, y, l, r, w, a, d, f = metrics[i] b, e = offsets[i], offsets[i+1] bitmaps.append( Image.fromstring("1", (x, y), data[b:e], "raw", mode, pad(x)) ) return bitmaps def _load_encoding(self): # map character code to bitmap index encoding = [None] * 256 fp, format, i16, i32 = self._getformat(PCF_BDF_ENCODINGS) firstCol, lastCol = i16(fp.read(2)), i16(fp.read(2)) firstRow, lastRow = i16(fp.read(2)), i16(fp.read(2)) default = i16(fp.read(2)) nencoding = (lastCol - firstCol + 1) * (lastRow - firstRow + 1) for i in range(nencoding): encodingOffset = i16(fp.read(2)) if encodingOffset != 0xFFFF: try: encoding[i+firstCol] = encodingOffset except IndexError: break # only load ISO-8859-1 glyphs return encoding
KAMI911/loec
examples/Sharpen/binaries-windows-python26/PcfFontFile.py
Python
gpl-3.0
6,642
0.004968