code
stringlengths 3
1.05M
| repo_name
stringlengths 5
104
| path
stringlengths 4
251
| language
stringclasses 1
value | license
stringclasses 15
values | size
int64 3
1.05M
|
|---|---|---|---|---|---|
# -*- coding: utf-8 -*-
#
import qrcode
try:
#pylint: disable = E, W, R, C
from PyQt6.QtGui import QImage, QPixmap,QPainter # @UnusedImport @Reimport @UnresolvedImport
from PyQt6.QtCore import Qt # @UnusedImport @Reimport @UnresolvedImport
except Exception:
#pylint: disable = E, W, R, C
from PyQt5.QtGui import QImage, QPixmap,QPainter # @UnusedImport @Reimport @UnresolvedImport
from PyQt5.QtCore import Qt # @UnusedImport @Reimport @UnresolvedImport
##########################################################################
##################### QR Image #####################################
##########################################################################
class QRImage(qrcode.image.base.BaseImage):
def new_image(self, **_kwargs):
img = QImage(self.pixel_size, self.pixel_size, QImage.Format.Format_RGB16)
img.fill(Qt.GlobalColor.white)
return img
def pixmap(self):
return QPixmap.fromImage(self.get_image())
def drawrect(self, row, col):
painter = QPainter(self.get_image())
painter.fillRect(
(col + self.border) * self.box_size,
(row + self.border) * self.box_size,
self.box_size, self.box_size,
Qt.GlobalColor.black)
def save(self, stream, kind=None):
pass
def process(self):
pass
def drawrect_context(self, row, col, active, context):
pass
def QRlabel(url_str):
qr = qrcode.QRCode(
version=None, # 1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=4,
border=1,
image_factory=QRImage)
qr.add_data(url_str)
qr.make(fit=True)
return qr | artisan-roaster-scope/artisan | src/artisanlib/qrcode.py | Python | gpl-3.0 | 1,715 |
import cv2
import numpy as np
from matplotlib import pyplot as plt
from time import sleep
from camera import Camera
from front_camera import FrontCamera
from rear_camera import RearCamera
run_front = True
run_rear = True
white = (255, 255, 255)
black = (0, 0, 0)
if run_front:
front_camera = Camera(src=1)
front_cam_processing = FrontCamera(front_camera)
if run_rear:
back_camera = Camera(src=0)
rear_cam_processing = RearCamera(back_camera)
def drawPoints(image, point_array):
for point in point_array:
cv2.circle(image, point, 2, white, -1)
def main():
while(True):
sleep(.1)
# points = []
# points.append((20,20))
# points.append((100, 100))
# drawPoints(front, points)
# edges = cv2.Canny(back, 220, 210)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
if __name__ == "__main__":
main()
| jbpacker/lolcam | run.py | Python | mit | 938 |
import logging
try:
import torch
from transformers import pipeline
except ImportError:
# No installation required if not using this function
pass
from nlpaug.model.lang_models import LanguageModels
class FmTransformers(LanguageModels):
def __init__(self, model_path='bert-base-uncased', model_type='bert', top_k=None, device='cuda',
max_length=300, batch_size=32, silence=True):
super().__init__(device, model_type=model_type, top_k=top_k, silence=silence)
try:
from transformers import pipeline
except ModuleNotFoundError:
raise ModuleNotFoundError('Missed transformers library. Install transfomers by `pip install transformers`')
self.max_length = max_length
self.batch_size = batch_size
self.model_path = model_path
device = self.convert_device(device)
top_k = top_k if top_k else 5
if silence:
# Transformers thrown an warning regrading to weight initialization. It is expected
orig_log_level = logging.getLogger('transformers.' + 'modeling_utils').getEffectiveLevel()
logging.getLogger('transformers.' + 'modeling_utils').setLevel(logging.ERROR)
self.model = pipeline("fill-mask", model=model_path, device=device, top_k=top_k)
logging.getLogger('transformers.' + 'modeling_utils').setLevel(orig_log_level)
else:
self.model = pipeline("fill-mask", model=model_path, device=device, top_k=top_k)
def to(self, device):
self.model.model.to(device)
def get_device(self):
return str(self.model.device)
def get_tokenizer(self):
return self.model.tokenizer
def get_model(self):
return self.model.model
def get_max_num_token(self):
return self.model.model.config.max_position_embeddings - 2 * 5
def is_skip_candidate(self, candidate):
return candidate.startswith(self.get_subword_prefix())
def token2id(self, token):
# Iseue 181: TokenizerFast have convert_tokens_to_ids but not convert_tokens_to_id
if 'TokenizerFast' in self.tokenizer.__class__.__name__:
# New transformers API
return self.model.tokenizer.convert_tokens_to_ids(token)
else:
# Old transformers API
return self.model.tokenizer._convert_token_to_id(token)
def id2token(self, _id):
return self.model.tokenizer._convert_id_to_token(_id)
def predict(self, texts, target_words=None, n=1):
results = []
predict_results = []
with torch.no_grad():
for i in range(0, len(texts), self.batch_size):
predict_result = self.model(texts[i:i+self.batch_size], num_workers=1)
if isinstance(predict_result, list) and len(predict_result) > 0:
if isinstance(predict_result[0], list):
predict_results.extend(predict_result)
else:
predict_results.extend([predict_result])
for result in predict_results:
temp_results = []
for r in result:
token = r['token_str']
if self.model_type in ['bert'] and token.startswith('##'):
continue
# subword came without space for roberta but not normal subowrd prefix
if self.model_type in ['roberta', 'bart'] and not token.startswith(' '):
continue
temp_results.append(token)
results.append(temp_results)
return results
| makcedward/nlpaug | nlpaug/model/lang_models/fill_mask_transformers.py | Python | mit | 3,614 |
import unittest
import os
import copy
import scipy
import SloppyCell.Utility as Utility
from SloppyCell.ReactionNetworks import *
import SloppyCell.daskr
from SloppyCell.daskr import daeint
# Load the fast reaction example from the SBML semantic test suite.
# To avoid extra dependencies on libsbml, we use verions built by SloppyCell.
from AlgTestNets import algebraic_net, algebraic_net_manual
tlist_algebraic_net = scipy.array([0] + [0.8*x for x in range(1, 51)])
class test_crossReferences(unittest.TestCase):
# Introducing two helper functions for the integration test, which is
# repeated a few times below.
def integration_tests(self, net):
""" integrates the network to timepoints with known data which we test """
traj = Dynamics.integrate(net, tlist_algebraic_net)
self.data_test_cases(traj)
def data_test_cases(self, traj):
""" do the actual data comparison """
self.assertAlmostEqual(traj.get_var_val('X0',4.8),
0.618783392, 5)
self.assertAlmostEqual(traj.get_var_val('X1',21.6),
0.653837775, 5)
self.assertAlmostEqual(traj.get_var_val('T', 29.6),
0.138253942, 5)
self.assertAlmostEqual(traj.get_var_val('S1', 40.0),
0.018207409, 5)
self.assertAlmostEqual(traj.get_var_val('S2', 16.8),
0.210750878, 5)
def test_manual_cross_refs(self):
""" Test that a network with manual call to makeCrossReferences gets \
correct reults """
net = algebraic_net_manual.copy()
net._makeCrossReferences()
self.integration_tests(net)
def test_manual_without_makeCrossReferences(self):
""" Test that after setting _manualCrossReferences_flag to True the \
compilation will fail if makeCrossReferences is NOT called """
net = algebraic_net_manual.copy()
self.assertRaises(AttributeError, Dynamics.integrate, net, tlist_algebraic_net)
def test_manual_without_makeCrossReferences_2(self):
""" Test that after setting _manualCrossReferences_flag to True the \
compilation will fail if makeCrossReferences is NOT called. Also test that after \
makeCrossReferences() is subsequently called the integration works."""
net = algebraic_net_manual.copy()
self.assertRaises(AttributeError, Dynamics.integrate, net, tlist_algebraic_net)
net._makeCrossReferences()
self.integration_tests(net)
def test_manual_off(self):
""" Test that after setting _manualCrossReferences_flag to True and then back \
integration still works """
net = algebraic_net.copy()
self.assertEqual(net._manualCrossReferences_flag, False)
net._manualCrossReferences(flag=True)
self.assertEqual(net._manualCrossReferences_flag, True)
net._manualCrossReferences(flag=False)
self.assertEqual(net._manualCrossReferences_flag, False)
self.integration_tests(net)
def test_manual_call_makeCrossReferences(self):
""" Test that for a network where cross references are manual, once \
_makeCrossReferences is called then it will be automatic."""
net = algebraic_net_manual.copy()
self.assertEqual(algebraic_net_manual._manualCrossReferences_flag, True)
self.assertEqual(net._manualCrossReferences_flag, True)
net._makeCrossReferences()
self.assertEqual(len(net.GetParameters()), 3)
self.assertEqual(net._manualCrossReferences_flag, False)
# Try adding a parameter to make sure the cross references are made automatically.
net.addParameter('k_new', 1e-3)
self.assertEqual(len(net.GetParameters()), 4)
self.integration_tests(net)
################################################################################
suite = unittest.makeSuite(test_crossReferences)
if __name__ == '__main__':
unittest.main()
| GutenkunstLab/SloppyCell | test/test_crossReferences.py | Python | bsd-3-clause | 4,044 |
# Copyright (c) 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.
import functools
from oslo_log import log as logging
from webob import exc
from murano.common.i18n import _, _LI
from murano.db import models
from murano.db.services import sessions
from murano.db import session as db_session
from murano.services import states
LOG = logging.getLogger(__name__)
def check_env(request, environment_id):
unit = db_session.get_session()
environment = unit.query(models.Environment).get(environment_id)
if environment is None:
msg = _('Environment with id {0}'
' not found').format(environment_id)
LOG.warning(msg)
raise exc.HTTPNotFound(explanation=msg)
if hasattr(request, 'context'):
if environment.tenant_id != request.context.tenant:
msg = _('User is not authorized to access'
' these tenant resources')
LOG.warning(msg)
raise exc.HTTPForbidden(explanation=msg)
return environment
def check_session(request, environment_id, session, session_id):
"""Validate, that a session is ok."""
if session is None:
msg = _('Session <SessionId {id}> is not found').format(id=session_id)
LOG.error(msg)
raise exc.HTTPNotFound(explanation=msg)
if session.environment_id != environment_id:
msg = _('Session <SessionId {session_id}> is not tied '
'with Environment <EnvId {environment_id}>').format(
session_id=session_id,
environment_id=environment_id)
LOG.error(msg)
raise exc.HTTPNotFound(explanation=msg)
check_env(request, environment_id)
def verify_env(func):
@functools.wraps(func)
def __inner(self, request, environment_id, *args, **kwargs):
check_env(request, environment_id)
return func(self, request, environment_id, *args, **kwargs)
return __inner
def verify_env_template(func):
@functools.wraps(func)
def __inner(self, request, env_template_id, *args, **kwargs):
unit = db_session.get_session()
template = unit.query(models.EnvironmentTemplate).get(env_template_id)
if template is None:
LOG.info(_LI("Environment Template with id '{0}' not found").
format(env_template_id))
raise exc.HTTPNotFound()
if hasattr(request, 'context'):
if template.tenant_id != request.context.tenant:
LOG.info(_LI('User is not authorized to access '
'this tenant resources'))
raise exc.HTTPUnauthorized()
return func(self, request, env_template_id, *args, **kwargs)
return __inner
def verify_session(func):
@functools.wraps(func)
def __inner(self, request, *args, **kwargs):
if hasattr(request, 'context') and not request.context.session:
LOG.info(_LI('Session is required for this call'))
raise exc.HTTPForbidden()
session_id = request.context.session
unit = db_session.get_session()
session = unit.query(models.Session).get(session_id)
if session is None:
LOG.info(_LI('Session <SessionId {0}> '
'is not found').format(session_id))
raise exc.HTTPForbidden()
if not sessions.SessionServices.validate(session):
LOG.info(_LI('Session <SessionId {0}> '
'is invalid').format(session_id))
raise exc.HTTPForbidden()
if session.state == states.SessionState.DEPLOYING:
LOG.info(_LI('Session <SessionId {0}> is already in '
'deployment state').format(session_id))
raise exc.HTTPForbidden()
return func(self, request, *args, **kwargs)
return __inner
| sajuptpm/murano | murano/utils.py | Python | apache-2.0 | 4,377 |
# Copyright 2012 United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration.
# All Rights Reserved.
#
# Copyright 2012 Nebula, 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.
"""
Middleware provided and used by Horizon.
"""
import json
import logging
from django.conf import settings
from django.contrib.auth import REDIRECT_FIELD_NAME
from django.contrib.auth.views import redirect_to_login
from django.contrib import messages as django_messages
from django import http
from django import shortcuts
from django.utils.encoding import iri_to_uri
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _
from openstack_auth import views as auth_views
from horizon import exceptions
from horizon.utils import functions as utils
LOG = logging.getLogger(__name__)
class HorizonMiddleware(object):
"""The main Horizon middleware class. Required for use of Horizon."""
logout_reason = None
def _logout(self, request, login_url=None, message=None, status='success'):
"""Logout a user and display a logout message."""
response = auth_views.logout(request, login_url)
if message is not None:
self.logout_reason = message
utils.add_logout_reason(request, response, message, status)
return response
def process_request(self, request):
"""Adds data necessary for Horizon to function to the request."""
request.horizon = {'dashboard': None,
'panel': None,
'async_messages': []}
if not hasattr(request, "user") or not request.user.is_authenticated():
# proceed no further if the current request is already known
# not to be authenticated
# it is CRITICAL to perform this check as early as possible
# to avoid creating too many sessions
return None
if request.is_ajax():
# if the request is Ajax we do not want to proceed, as clients can
# 1) create pages with constant polling, which can create race
# conditions when a page navigation occurs
# 2) might leave a user seemingly left logged in forever
# 3) thrashes db backed session engines with tons of changes
return None
# If we use cookie-based sessions, check that the cookie size does not
# reach the max size accepted by common web browsers.
if (
settings.SESSION_ENGINE ==
'django.contrib.sessions.backends.signed_cookies'
):
max_cookie_size = getattr(
settings, 'SESSION_COOKIE_MAX_SIZE', None)
session_cookie_name = getattr(
settings, 'SESSION_COOKIE_NAME', None)
session_key = request.COOKIES.get(session_cookie_name)
if max_cookie_size is not None and session_key is not None:
cookie_size = sum((
len(key) + len(value)
for key, value in request.COOKIES.items()
))
if cookie_size >= max_cookie_size:
LOG.error(
'Total Cookie size for user_id: %(user_id)s is '
'%(cookie_size)sB >= %(max_cookie_size)sB. '
'You need to configure file-based or database-backed '
'sessions instead of cookie-based sessions: '
'http://docs.openstack.org/developer/horizon/topics/'
'deployment.html#session-storage',
{
'user_id': request.session.get(
'user_id', 'Unknown'),
'cookie_size': cookie_size,
'max_cookie_size': max_cookie_size,
}
)
tz = request.session.get('django_timezone')
if tz:
timezone.activate(tz)
def process_exception(self, request, exception):
"""Catches internal Horizon exception classes such as NotAuthorized,
NotFound and Http302 and handles them gracefully.
"""
if isinstance(exception, (exceptions.NotAuthorized,
exceptions.NotAuthenticated)):
auth_url = settings.LOGIN_URL
next_url = iri_to_uri(request.get_full_path())
if next_url != auth_url:
field_name = REDIRECT_FIELD_NAME
else:
field_name = None
login_url = request.build_absolute_uri(auth_url)
response = redirect_to_login(next_url, login_url=login_url,
redirect_field_name=field_name)
if isinstance(exception, exceptions.NotAuthorized):
logout_reason = _("Unauthorized. Please try logging in again.")
utils.add_logout_reason(request, response, logout_reason,
'error')
# delete messages, created in get_data() method
# since we are going to redirect user to the login page
response.delete_cookie('messages')
if request.is_ajax():
response_401 = http.HttpResponse(status=401)
response_401['X-Horizon-Location'] = response['location']
return response_401
return response
# If an internal "NotFound" error gets this far, return a real 404.
if isinstance(exception, exceptions.NotFound):
raise http.Http404(exception)
if isinstance(exception, exceptions.Http302):
# TODO(gabriel): Find a way to display an appropriate message to
# the user *on* the login form...
return shortcuts.redirect(exception.location)
@staticmethod
def copy_headers(src, dst, headers):
for header in headers:
dst[header] = src[header]
def process_response(self, request, response):
"""Convert HttpResponseRedirect to HttpResponse if request is via ajax
to allow ajax request to redirect url
"""
if request.is_ajax() and hasattr(request, 'horizon'):
queued_msgs = request.horizon['async_messages']
if type(response) == http.HttpResponseRedirect:
# Drop our messages back into the session as per usual so they
# don't disappear during the redirect. Not that we explicitly
# use django's messages methods here.
for tag, message, extra_tags in queued_msgs:
getattr(django_messages, tag)(request, message, extra_tags)
if response['location'].startswith(settings.LOGOUT_URL):
redirect_response = http.HttpResponse(status=401)
# This header is used for handling the logout in JS
redirect_response['logout'] = True
if self.logout_reason is not None:
utils.add_logout_reason(
request, redirect_response, self.logout_reason,
'error')
else:
redirect_response = http.HttpResponse()
# Use a set while checking if we want a cookie's attributes
# copied
cookie_keys = {'max_age', 'expires', 'path', 'domain',
'secure', 'httponly', 'logout_reason'}
# Copy cookies from HttpResponseRedirect towards HttpResponse
for cookie_name, cookie in response.cookies.items():
cookie_kwargs = dict((
(key, value) for key, value in cookie.items()
if key in cookie_keys and value
))
redirect_response.set_cookie(
cookie_name, cookie.value, **cookie_kwargs)
redirect_response['X-Horizon-Location'] = response['location']
upload_url_key = 'X-File-Upload-URL'
if upload_url_key in response:
self.copy_headers(response, redirect_response,
(upload_url_key, 'X-Auth-Token'))
return redirect_response
if queued_msgs:
# TODO(gabriel): When we have an async connection to the
# client (e.g. websockets) this should be pushed to the
# socket queue rather than being sent via a header.
# The header method has notable drawbacks (length limits,
# etc.) and is not meant as a long-term solution.
response['X-Horizon-Messages'] = json.dumps(queued_msgs)
return response
| kogotko/carburetor | horizon/middleware/base.py | Python | apache-2.0 | 9,397 |
# Authors: Chris Holdgraf <[email protected]>
#
# License: BSD (3-clause)
import os.path as op
import pytest
import numpy as np
from numpy import einsum
from numpy.fft import rfft, irfft
from numpy.testing import assert_array_equal, assert_allclose, assert_equal
from mne.utils import requires_sklearn
from mne.decoding import ReceptiveField, TimeDelayingRidge
from mne.decoding.receptive_field import (_delay_time_series, _SCORERS,
_times_to_delays, _delays_to_slice)
from mne.decoding.time_delaying_ridge import (_compute_reg_neighbors,
_compute_corrs)
data_dir = op.join(op.dirname(__file__), '..', '..', 'io', 'tests', 'data')
raw_fname = op.join(data_dir, 'test_raw.fif')
event_name = op.join(data_dir, 'test-eve.fif')
tmin, tmax = -0.1, 0.5
event_id = dict(aud_l=1, vis_l=3)
# Loading raw data
n_jobs_test = (1, 'cuda')
def test_compute_reg_neighbors():
"""Test fast calculation of laplacian regularizer."""
for reg_type in (
('ridge', 'ridge'),
('ridge', 'laplacian'),
('laplacian', 'ridge'),
('laplacian', 'laplacian')):
for n_ch_x, n_delays in (
(1, 1), (1, 2), (2, 1), (1, 3), (3, 1), (1, 4), (4, 1),
(2, 2), (2, 3), (3, 2), (3, 3),
(2, 4), (4, 2), (3, 4), (4, 3), (4, 4),
(5, 4), (4, 5), (5, 5),
(20, 9), (9, 20)):
for normed in (True, False):
reg_direct = _compute_reg_neighbors(
n_ch_x, n_delays, reg_type, 'direct', normed=normed)
reg_csgraph = _compute_reg_neighbors(
n_ch_x, n_delays, reg_type, 'csgraph', normed=normed)
assert_allclose(
reg_direct, reg_csgraph, atol=1e-7,
err_msg='%s: %s' % (reg_type, (n_ch_x, n_delays)))
@requires_sklearn
def test_rank_deficiency():
"""Test signals that are rank deficient."""
# See GH#4253
from sklearn.linear_model import Ridge
N = 256
fs = 1.
tmin, tmax = -50, 100
reg = 0.1
rng = np.random.RandomState(0)
eeg = rng.randn(N, 1)
eeg *= 100
eeg = rfft(eeg, axis=0)
eeg[N // 4:] = 0 # rank-deficient lowpass
eeg = irfft(eeg, axis=0)
win = np.hanning(N // 8)
win /= win.mean()
y = np.apply_along_axis(np.convolve, 0, eeg, win, mode='same')
y += rng.randn(*y.shape) * 100
for est in (Ridge(reg), reg):
rf = ReceptiveField(tmin, tmax, fs, estimator=est, patterns=True)
rf.fit(eeg, y)
pred = rf.predict(eeg)
assert_equal(y.shape, pred.shape)
corr = np.corrcoef(y.ravel(), pred.ravel())[0, 1]
assert corr > 0.995
def test_time_delay():
"""Test that time-delaying w/ times and samples works properly."""
# Explicit delays + sfreq
X = np.random.RandomState(0).randn(1000, 2)
assert (X == 0).sum() == 0 # need this for later
test_tlims = [
((1, 2), 1),
((1, 1), 1),
((0, 2), 1),
((0, 1), 1),
((0, 0), 1),
((-1, 2), 1),
((-1, 1), 1),
((-1, 0), 1),
((-1, -1), 1),
((-2, 2), 1),
((-2, 1), 1),
((-2, 0), 1),
((-2, -1), 1),
((-2, -1), 1),
((0, .2), 10),
((-.1, .1), 10)]
for (tmin, tmax), isfreq in test_tlims:
# sfreq must be int/float
with pytest.raises(TypeError, match='`sfreq` must be an instance of'):
_delay_time_series(X, tmin, tmax, sfreq=[1])
# Delays must be int/float
with pytest.raises(TypeError, match='.*complex.*'):
_delay_time_series(X, np.complex128(tmin), tmax, 1)
# Make sure swapaxes works
start, stop = int(round(tmin * isfreq)), int(round(tmax * isfreq)) + 1
n_delays = stop - start
X_delayed = _delay_time_series(X, tmin, tmax, isfreq)
assert_equal(X_delayed.shape, (1000, 2, n_delays))
# Make sure delay slice is correct
delays = _times_to_delays(tmin, tmax, isfreq)
assert_array_equal(delays, np.arange(start, stop))
keep = _delays_to_slice(delays)
expected = np.where((X_delayed != 0).all(-1).all(-1))[0]
got = np.arange(len(X_delayed))[keep]
assert_array_equal(got, expected)
assert X_delayed[keep].shape[-1] > 0
assert (X_delayed[keep] == 0).sum() == 0
del_zero = int(round(-tmin * isfreq))
for ii in range(-2, 3):
idx = del_zero + ii
err_msg = '[%s,%s] (%s): %s %s' % (tmin, tmax, isfreq, ii, idx)
if 0 <= idx < X_delayed.shape[-1]:
if ii == 0:
assert_array_equal(X_delayed[:, :, idx], X,
err_msg=err_msg)
elif ii < 0: # negative delay
assert_array_equal(X_delayed[:ii, :, idx], X[-ii:, :],
err_msg=err_msg)
assert_array_equal(X_delayed[ii:, :, idx], 0.)
else:
assert_array_equal(X_delayed[ii:, :, idx], X[:-ii, :],
err_msg=err_msg)
assert_array_equal(X_delayed[:ii, :, idx], 0.)
@pytest.mark.parametrize('n_jobs', n_jobs_test)
@requires_sklearn
def test_receptive_field_basic(n_jobs):
"""Test model prep and fitting."""
from sklearn.linear_model import Ridge
# Make sure estimator pulling works
mod = Ridge()
rng = np.random.RandomState(1337)
# Test the receptive field model
# Define parameters for the model and simulate inputs + weights
tmin, tmax = -10., 0
n_feats = 3
rng = np.random.RandomState(0)
X = rng.randn(10000, n_feats)
w = rng.randn(int((tmax - tmin) + 1) * n_feats)
# Delay inputs and cut off first 4 values since they'll be cut in the fit
X_del = np.concatenate(
_delay_time_series(X, tmin, tmax, 1.).transpose(2, 0, 1), axis=1)
y = np.dot(X_del, w)
# Fit the model and test values
feature_names = ['feature_%i' % ii for ii in [0, 1, 2]]
rf = ReceptiveField(tmin, tmax, 1, feature_names, estimator=mod,
patterns=True)
rf.fit(X, y)
assert_array_equal(rf.delays_, np.arange(tmin, tmax + 1))
y_pred = rf.predict(X)
assert_allclose(y[rf.valid_samples_], y_pred[rf.valid_samples_], atol=1e-2)
scores = rf.score(X, y)
assert scores > .99
assert_allclose(rf.coef_.T.ravel(), w, atol=1e-3)
# Make sure different input shapes work
rf.fit(X[:, np.newaxis:], y[:, np.newaxis])
rf.fit(X, y[:, np.newaxis])
with pytest.raises(ValueError, match='If X has 3 .* y must have 2 or 3'):
rf.fit(X[..., np.newaxis], y)
with pytest.raises(ValueError, match='X must be shape'):
rf.fit(X[:, 0], y)
with pytest.raises(ValueError, match='X and y do not have the same n_epo'):
rf.fit(X[:, np.newaxis], np.tile(y[:, np.newaxis, np.newaxis],
[1, 2, 1]))
with pytest.raises(ValueError, match='X and y do not have the same n_tim'):
rf.fit(X, y[:-2])
with pytest.raises(ValueError, match='n_features in X does not match'):
rf.fit(X[:, :1], y)
# auto-naming features
feature_names = ['feature_%s' % ii for ii in [0, 1, 2]]
rf = ReceptiveField(tmin, tmax, 1, estimator=mod,
feature_names=feature_names)
assert_equal(rf.feature_names, feature_names)
rf = ReceptiveField(tmin, tmax, 1, estimator=mod)
rf.fit(X, y)
assert_equal(rf.feature_names, None)
# Float becomes ridge
rf = ReceptiveField(tmin, tmax, 1, ['one', 'two', 'three'], estimator=0)
str(rf) # repr works before fit
rf.fit(X, y)
assert isinstance(rf.estimator_, TimeDelayingRidge)
str(rf) # repr works after fit
rf = ReceptiveField(tmin, tmax, 1, ['one'], estimator=0)
rf.fit(X[:, [0]], y)
str(rf) # repr with one feature
# Should only accept estimators or floats
with pytest.raises(ValueError, match='`estimator` must be a float or'):
ReceptiveField(tmin, tmax, 1, estimator='foo').fit(X, y)
with pytest.raises(ValueError, match='`estimator` must be a float or'):
ReceptiveField(tmin, tmax, 1, estimator=np.array([1, 2, 3])).fit(X, y)
with pytest.raises(ValueError, match='tmin .* must be at most tmax'):
ReceptiveField(5, 4, 1).fit(X, y)
# scorers
for key, val in _SCORERS.items():
rf = ReceptiveField(tmin, tmax, 1, ['one'],
estimator=0, scoring=key, patterns=True)
rf.fit(X[:, [0]], y)
y_pred = rf.predict(X[:, [0]]).T.ravel()[:, np.newaxis]
assert_allclose(val(y[:, np.newaxis], y_pred,
multioutput='raw_values'),
rf.score(X[:, [0]], y), rtol=1e-2)
with pytest.raises(ValueError, match='inputs must be shape'):
_SCORERS['corrcoef'](y.ravel(), y_pred, multioutput='raw_values')
# Need correct scorers
with pytest.raises(ValueError, match='scoring must be one of'):
ReceptiveField(tmin, tmax, 1., scoring='foo').fit(X, y)
@pytest.mark.parametrize('n_jobs', n_jobs_test)
def test_time_delaying_fast_calc(n_jobs):
"""Test time delaying and fast calculations."""
X = np.array([[1, 2, 3], [5, 7, 11]]).T
# all negative
smin, smax = 1, 2
X_del = _delay_time_series(X, smin, smax, 1.)
# (n_times, n_features, n_delays) -> (n_times, n_features * n_delays)
X_del.shape = (X.shape[0], -1)
expected = np.array([[0, 1, 2], [0, 0, 1], [0, 5, 7], [0, 0, 5]]).T
assert_allclose(X_del, expected)
Xt_X = np.dot(X_del.T, X_del)
expected = [[5, 2, 19, 10], [2, 1, 7, 5], [19, 7, 74, 35], [10, 5, 35, 25]]
assert_allclose(Xt_X, expected)
x_xt = _compute_corrs(X, np.zeros((X.shape[0], 1)), smin, smax + 1)[0]
assert_allclose(x_xt, expected)
# all positive
smin, smax = -2, -1
X_del = _delay_time_series(X, smin, smax, 1.)
X_del.shape = (X.shape[0], -1)
expected = np.array([[3, 0, 0], [2, 3, 0], [11, 0, 0], [7, 11, 0]]).T
assert_allclose(X_del, expected)
Xt_X = np.dot(X_del.T, X_del)
expected = [[9, 6, 33, 21], [6, 13, 22, 47],
[33, 22, 121, 77], [21, 47, 77, 170]]
assert_allclose(Xt_X, expected)
x_xt = _compute_corrs(X, np.zeros((X.shape[0], 1)), smin, smax + 1)[0]
assert_allclose(x_xt, expected)
# both sides
smin, smax = -1, 1
X_del = _delay_time_series(X, smin, smax, 1.)
X_del.shape = (X.shape[0], -1)
expected = np.array([[2, 3, 0], [1, 2, 3], [0, 1, 2],
[7, 11, 0], [5, 7, 11], [0, 5, 7]]).T
assert_allclose(X_del, expected)
Xt_X = np.dot(X_del.T, X_del)
expected = [[13, 8, 3, 47, 31, 15],
[8, 14, 8, 29, 52, 31],
[3, 8, 5, 11, 29, 19],
[47, 29, 11, 170, 112, 55],
[31, 52, 29, 112, 195, 112],
[15, 31, 19, 55, 112, 74]]
assert_allclose(Xt_X, expected)
x_xt = _compute_corrs(X, np.zeros((X.shape[0], 1)), smin, smax + 1)[0]
assert_allclose(x_xt, expected)
# slightly harder to get the non-Toeplitz correction correct
X = np.array([[1, 2, 3, 5]]).T
smin, smax = 0, 3
X_del = _delay_time_series(X, smin, smax, 1.)
X_del.shape = (X.shape[0], -1)
expected = np.array([[1, 2, 3, 5], [0, 1, 2, 3],
[0, 0, 1, 2], [0, 0, 0, 1]]).T
assert_allclose(X_del, expected)
Xt_X = np.dot(X_del.T, X_del)
expected = [[39, 23, 13, 5], [23, 14, 8, 3], [13, 8, 5, 2], [5, 3, 2, 1]]
assert_allclose(Xt_X, expected)
x_xt = _compute_corrs(X, np.zeros((X.shape[0], 1)), smin, smax + 1)[0]
assert_allclose(x_xt, expected)
# even worse
X = np.array([[1, 2, 3], [5, 7, 11]]).T
smin, smax = 0, 2
X_del = _delay_time_series(X, smin, smax, 1.)
X_del.shape = (X.shape[0], -1)
expected = np.array([[1, 2, 3], [0, 1, 2], [0, 0, 1],
[5, 7, 11], [0, 5, 7], [0, 0, 5]]).T
assert_allclose(X_del, expected)
Xt_X = np.dot(X_del.T, X_del)
expected = np.array([[14, 8, 3, 52, 31, 15],
[8, 5, 2, 29, 19, 10],
[3, 2, 1, 11, 7, 5],
[52, 29, 11, 195, 112, 55],
[31, 19, 7, 112, 74, 35],
[15, 10, 5, 55, 35, 25]])
assert_allclose(Xt_X, expected)
x_xt = _compute_corrs(X, np.zeros((X.shape[0], 1)), smin, smax + 1)[0]
assert_allclose(x_xt, expected)
# And a bunch of random ones for good measure
rng = np.random.RandomState(0)
X = rng.randn(25, 3)
y = np.empty((25, 2))
vals = (0, -1, 1, -2, 2, -11, 11)
for smax in vals:
for smin in vals:
if smin > smax:
continue
for ii in range(X.shape[1]):
kernel = rng.randn(smax - smin + 1)
kernel -= np.mean(kernel)
y[:, ii % y.shape[-1]] = np.convolve(X[:, ii], kernel, 'same')
x_xt, x_yt, n_ch_x, _, _ = _compute_corrs(X, y, smin, smax + 1)
X_del = _delay_time_series(X, smin, smax, 1., fill_mean=False)
x_yt_true = einsum('tfd,to->ofd', X_del, y)
x_yt_true = np.reshape(x_yt_true, (x_yt_true.shape[0], -1)).T
assert_allclose(x_yt, x_yt_true, atol=1e-7, err_msg=(smin, smax))
X_del.shape = (X.shape[0], -1)
x_xt_true = np.dot(X_del.T, X_del).T
assert_allclose(x_xt, x_xt_true, atol=1e-7, err_msg=(smin, smax))
@pytest.mark.parametrize('n_jobs', n_jobs_test)
@requires_sklearn
def test_receptive_field_1d(n_jobs):
"""Test that the fast solving works like Ridge."""
from sklearn.linear_model import Ridge
rng = np.random.RandomState(0)
x = rng.randn(500, 1)
for delay in range(-2, 3):
y = np.zeros(500)
slims = [(-2, 4)]
if delay == 0:
y[:] = x[:, 0]
elif delay < 0:
y[:delay] = x[-delay:, 0]
slims += [(-4, -1)]
else:
y[delay:] = x[:-delay, 0]
slims += [(1, 2)]
for ndim in (1, 2):
y.shape = (y.shape[0],) + (1,) * (ndim - 1)
for slim in slims:
smin, smax = slim
lap = TimeDelayingRidge(smin, smax, 1., 0.1, 'laplacian',
fit_intercept=False, n_jobs=n_jobs)
for estimator in (Ridge(alpha=0.), Ridge(alpha=0.1), 0., 0.1,
lap):
for offset in (-100, 0, 100):
model = ReceptiveField(smin, smax, 1.,
estimator=estimator,
n_jobs=n_jobs)
use_x = x + offset
model.fit(use_x, y)
if estimator is lap:
continue # these checks are too stringent
assert_allclose(model.estimator_.intercept_, -offset,
atol=1e-1)
assert_array_equal(model.delays_,
np.arange(smin, smax + 1))
expected = (model.delays_ == delay).astype(float)
expected = expected[np.newaxis] # features
if y.ndim == 2:
expected = expected[np.newaxis] # outputs
assert_equal(model.coef_.ndim, ndim + 1)
assert_allclose(model.coef_, expected, atol=1e-3)
start = model.valid_samples_.start or 0
stop = len(use_x) - (model.valid_samples_.stop or 0)
assert stop - start >= 495
assert_allclose(
model.predict(use_x)[model.valid_samples_],
y[model.valid_samples_], atol=1e-2)
score = np.mean(model.score(use_x, y))
assert score > 0.9999
@pytest.mark.parametrize('n_jobs', n_jobs_test)
@requires_sklearn
def test_receptive_field_nd(n_jobs):
"""Test multidimensional support."""
from sklearn.linear_model import Ridge
# multidimensional
rng = np.random.RandomState(3)
x = rng.randn(1000, 3)
y = np.zeros((1000, 2))
smin, smax = 0, 5
# This is a weird assignment, but it's just a way to distribute some
# unique values at various delays, and "expected" explains how they
# should appear in the resulting RF
for ii in range(1, 5):
y[ii:, ii % 2] += (-1) ** ii * ii * x[:-ii, ii % 3]
y -= np.mean(y, axis=0)
x -= np.mean(x, axis=0)
x_off = x + 1e3
expected = [
[[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 4, 0],
[0, 0, 2, 0, 0, 0]],
[[0, 0, 0, -3, 0, 0],
[0, -1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0]],
]
tdr_l = TimeDelayingRidge(smin, smax, 1., 0.1, 'laplacian', n_jobs=n_jobs)
tdr_nc = TimeDelayingRidge(smin, smax, 1., 0.1, n_jobs=n_jobs,
edge_correction=False)
for estimator, atol in zip((Ridge(alpha=0.), 0., 0.01, tdr_l, tdr_nc),
(1e-3, 1e-3, 1e-3, 5e-3, 5e-2)):
model = ReceptiveField(smin, smax, 1.,
estimator=estimator)
model.fit(x, y)
assert_array_equal(model.delays_,
np.arange(smin, smax + 1))
assert_allclose(model.coef_, expected, atol=atol)
tdr = TimeDelayingRidge(smin, smax, 1., 0.01, reg_type='foo',
n_jobs=n_jobs)
model = ReceptiveField(smin, smax, 1., estimator=tdr)
with pytest.raises(ValueError, match='reg_type entries must be one of'):
model.fit(x, y)
tdr = TimeDelayingRidge(smin, smax, 1., 0.01, reg_type=['laplacian'],
n_jobs=n_jobs)
model = ReceptiveField(smin, smax, 1., estimator=tdr)
with pytest.raises(ValueError, match='reg_type must have two elements'):
model.fit(x, y)
model = ReceptiveField(smin, smax, 1, estimator=tdr, fit_intercept=False)
with pytest.raises(ValueError, match='fit_intercept'):
model.fit(x, y)
# Now check the intercept_
tdr = TimeDelayingRidge(smin, smax, 1., 0., n_jobs=n_jobs)
tdr_no = TimeDelayingRidge(smin, smax, 1., 0., fit_intercept=False,
n_jobs=n_jobs)
for estimator in (Ridge(alpha=0.), tdr,
Ridge(alpha=0., fit_intercept=False), tdr_no):
# first with no intercept in the data
model = ReceptiveField(smin, smax, 1., estimator=estimator)
model.fit(x, y)
assert_allclose(model.estimator_.intercept_, 0., atol=1e-7,
err_msg=repr(estimator))
assert_allclose(model.coef_, expected, atol=1e-3,
err_msg=repr(estimator))
y_pred = model.predict(x)
assert_allclose(y_pred[model.valid_samples_],
y[model.valid_samples_],
atol=1e-2, err_msg=repr(estimator))
score = np.mean(model.score(x, y))
assert score > 0.9999
# now with an intercept in the data
model.fit(x_off, y)
if estimator.fit_intercept:
val = [-6000, 4000]
itol = 0.5
ctol = 5e-4
else:
val = itol = 0.
ctol = 2.
assert_allclose(model.estimator_.intercept_, val, atol=itol,
err_msg=repr(estimator))
assert_allclose(model.coef_, expected, atol=ctol, rtol=ctol,
err_msg=repr(estimator))
if estimator.fit_intercept:
ptol = 1e-2
stol = 0.999999
else:
ptol = 10
stol = 0.6
y_pred = model.predict(x_off)[model.valid_samples_]
assert_allclose(y_pred, y[model.valid_samples_],
atol=ptol, err_msg=repr(estimator))
score = np.mean(model.score(x_off, y))
assert score > stol, estimator
model = ReceptiveField(smin, smax, 1., fit_intercept=False)
model.fit(x_off, y)
assert_allclose(model.estimator_.intercept_, 0., atol=1e-7)
score = np.mean(model.score(x_off, y))
assert score > 0.6
def _make_data(n_feats, n_targets, n_samples, tmin, tmax):
rng = np.random.RandomState(0)
X = rng.randn(n_samples, n_feats)
w = rng.randn(int((tmax - tmin) + 1) * n_feats, n_targets)
# Delay inputs
X_del = np.concatenate(
_delay_time_series(X, tmin, tmax, 1.).transpose(2, 0, 1), axis=1)
y = np.dot(X_del, w)
return X, y
@requires_sklearn
def test_inverse_coef():
"""Test inverse coefficients computation."""
from sklearn.linear_model import Ridge
tmin, tmax = 0., 10.
n_feats, n_targets, n_samples = 3, 2, 1000
n_delays = int((tmax - tmin) + 1)
# Check coefficient dims, for all estimator types
X, y = _make_data(n_feats, n_targets, n_samples, tmin, tmax)
tdr = TimeDelayingRidge(tmin, tmax, 1., 0.1, 'laplacian')
for estimator in (0., 0.01, Ridge(alpha=0.), tdr):
rf = ReceptiveField(tmin, tmax, 1., estimator=estimator,
patterns=True)
rf.fit(X, y)
inv_rf = ReceptiveField(tmin, tmax, 1., estimator=estimator,
patterns=True)
inv_rf.fit(y, X)
assert_array_equal(rf.coef_.shape, rf.patterns_.shape,
(n_targets, n_feats, n_delays))
assert_array_equal(inv_rf.coef_.shape, inv_rf.patterns_.shape,
(n_feats, n_targets, n_delays))
# we should have np.dot(patterns.T,coef) ~ np.eye(n)
c0 = rf.coef_.reshape(n_targets, n_feats * n_delays)
c1 = rf.patterns_.reshape(n_targets, n_feats * n_delays)
assert_allclose(np.dot(c0, c1.T), np.eye(c0.shape[0]), atol=0.2)
@requires_sklearn
def test_linalg_warning():
"""Test that warnings are issued when no regularization is applied."""
from sklearn.linear_model import Ridge
n_feats, n_targets, n_samples = 5, 60, 50
X, y = _make_data(n_feats, n_targets, n_samples, tmin, tmax)
for estimator in (0., Ridge(alpha=0.)):
rf = ReceptiveField(tmin, tmax, 1., estimator=estimator)
with pytest.warns((RuntimeWarning, UserWarning),
match='[Singular|scipy.linalg.solve]'):
rf.fit(y, X)
| rkmaddox/mne-python | mne/decoding/tests/test_receptive_field.py | Python | bsd-3-clause | 22,664 |
# -*- coding: utf-8 -*-
###############################################################################
#
# SegmentationForVisitorsTodayViaSearch
# Retrieves segmentation data for visitors today who arrived via a search.
#
# Python versions 2.6, 2.7, 3.x
#
# Copyright 2014, Temboo 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 temboo.core.choreography import Choreography
from temboo.core.choreography import InputSet
from temboo.core.choreography import ResultSet
from temboo.core.choreography import ChoreographyExecution
import json
class SegmentationForVisitorsTodayViaSearch(Choreography):
def __init__(self, temboo_session):
"""
Create a new instance of the SegmentationForVisitorsTodayViaSearch Choreo. A TembooSession object, containing a valid
set of Temboo credentials, must be supplied.
"""
super(SegmentationForVisitorsTodayViaSearch, self).__init__(temboo_session, '/Library/Clicky/SegmentationForVisitorsTodayViaSearch')
def new_input_set(self):
return SegmentationForVisitorsTodayViaSearchInputSet()
def _make_result_set(self, result, path):
return SegmentationForVisitorsTodayViaSearchResultSet(result, path)
def _make_execution(self, session, exec_id, path):
return SegmentationForVisitorsTodayViaSearchChoreographyExecution(session, exec_id, path)
class SegmentationForVisitorsTodayViaSearchInputSet(InputSet):
"""
An InputSet with methods appropriate for specifying the inputs to the SegmentationForVisitorsTodayViaSearch
Choreo. The InputSet object is used to specify input parameters when executing this Choreo.
"""
def set_Limit(self, value):
"""
Set the value of the Limit input for this Choreo. ((optional, integer) The number of records you want to retrieve. Defaults to 30.)
"""
super(SegmentationForVisitorsTodayViaSearchInputSet, self)._set_input('Limit', value)
def set_Output(self, value):
"""
Set the value of the Output input for this Choreo. ((optional, string) What format you want the returned data to be in. Accepted values: xml, php, json, csv. Defaults to 'xml'.)
"""
super(SegmentationForVisitorsTodayViaSearchInputSet, self)._set_input('Output', value)
def set_SiteID(self, value):
"""
Set the value of the SiteID input for this Choreo. ((required, integer) Your request must include the site's ID that you want to access data from. Available from your site preferences page.)
"""
super(SegmentationForVisitorsTodayViaSearchInputSet, self)._set_input('SiteID', value)
def set_SiteKey(self, value):
"""
Set the value of the SiteKey input for this Choreo. ((required, string) The unique key assigned to you when you first register with Clicky. Available from your site preferences page.)
"""
super(SegmentationForVisitorsTodayViaSearchInputSet, self)._set_input('SiteKey', value)
def set_Type(self, value):
"""
Set the value of the Type input for this Choreo. ((optional, string) The type of data you want to retrieve. Defaults to "segmentation".)
"""
super(SegmentationForVisitorsTodayViaSearchInputSet, self)._set_input('Type', value)
class SegmentationForVisitorsTodayViaSearchResultSet(ResultSet):
"""
A ResultSet with methods tailored to the values returned by the SegmentationForVisitorsTodayViaSearch Choreo.
The ResultSet object is used to retrieve the results of a Choreo execution.
"""
def getJSONFromString(self, str):
return json.loads(str)
def get_Response(self):
"""
Retrieve the value for the "Response" output from this Choreo execution. (The response from Clicky formatted as specified in the Output parameter. Default is XML.)
"""
return self._output.get('Response', None)
class SegmentationForVisitorsTodayViaSearchChoreographyExecution(ChoreographyExecution):
def _make_result_set(self, response, path):
return SegmentationForVisitorsTodayViaSearchResultSet(response, path)
| jordanemedlock/psychtruths | temboo/core/Library/Clicky/SegmentationForVisitorsTodayViaSearch.py | Python | apache-2.0 | 4,690 |
# simpleSQL.py
#
# simple demo of using the parsing library to do simple-minded SQL parsing
# could be extended to include where clauses etc.
#
# Copyright (c) 2003, Paul McGuire
#
from pyparsing import Literal, CaselessLiteral, Word, Upcase, delimitedList, Optional, \
Combine, Group, alphas, nums, alphanums, ParseException, Forward, oneOf, quotedString, \
ZeroOrMore, restOfLine, Keyword
def test( str ):
print str,"->"
try:
tokens = simpleSQL.parseString( str )
print "tokens = ", tokens
print "tokens.columns =", tokens.columns
print "tokens.tables =", tokens.tables
print "tokens.where =", tokens.where
except ParseException, err:
print " "*err.loc + "^\n" + err.msg
print err
print
# define SQL tokens
selectStmt = Forward()
selectToken = Keyword("select", caseless=True)
fromToken = Keyword("from", caseless=True)
ident = Word( alphas, alphanums + "_$" ).setName("identifier")
columnName = Upcase( delimitedList( ident, ".", combine=True ) )
columnNameList = Group( delimitedList( columnName ) )
tableName = Upcase( delimitedList( ident, ".", combine=True ) )
tableNameList = Group( delimitedList( tableName ) )
whereExpression = Forward()
and_ = Keyword("and", caseless=True)
or_ = Keyword("or", caseless=True)
in_ = Keyword("in", caseless=True)
E = CaselessLiteral("E")
binop = oneOf("= != < > >= <= eq ne lt le gt ge", caseless=True)
arithSign = Word("+-",exact=1)
realNum = Combine( Optional(arithSign) + ( Word( nums ) + "." + Optional( Word(nums) ) |
( "." + Word(nums) ) ) +
Optional( E + Optional(arithSign) + Word(nums) ) )
intNum = Combine( Optional(arithSign) + Word( nums ) +
Optional( E + Optional("+") + Word(nums) ) )
columnRval = realNum | intNum | quotedString | columnName # need to add support for alg expressions
whereCondition = Group(
( columnName + binop + columnRval ) |
( columnName + in_ + "(" + delimitedList( columnRval ) + ")" ) |
( columnName + in_ + "(" + selectStmt + ")" ) |
( "(" + whereExpression + ")" )
)
whereExpression << whereCondition + ZeroOrMore( ( and_ | or_ ) + whereExpression )
# define the grammar
selectStmt << ( selectToken +
( '*' | columnNameList ).setResultsName( "columns" ) +
fromToken +
tableNameList.setResultsName( "tables" ) +
Optional( Group( CaselessLiteral("where") + whereExpression ), "" ).setResultsName("where") )
simpleSQL = selectStmt
# define Oracle comment format, and ignore them
oracleSqlComment = "--" + restOfLine
simpleSQL.ignore( oracleSqlComment )
test( "SELECT * from XYZZY, ABC" )
test( "select * from SYS.XYZZY" )
test( "Select A from Sys.dual" )
test( "Select A,B,C from Sys.dual" )
test( "Select A, B, C from Sys.dual" )
test( "Select A, B, C from Sys.dual, Table2 " )
test( "Xelect A, B, C from Sys.dual" )
test( "Select A, B, C frox Sys.dual" )
test( "Select" )
test( "Select &&& frox Sys.dual" )
test( "Select A from Sys.dual where a in ('RED','GREEN','BLUE')" )
test( "Select A from Sys.dual where a in ('RED','GREEN','BLUE') and b in (10,20,30)" )
test( "Select A,b from table1,table2 where table1.id eq table2.id -- test out comparison operators" )
"""
Test output:
>pythonw -u simpleSQL.py
SELECT * from XYZZY, ABC ->
tokens = ['select', '*', 'from', ['XYZZY', 'ABC']]
tokens.columns = *
tokens.tables = ['XYZZY', 'ABC']
select * from SYS.XYZZY ->
tokens = ['select', '*', 'from', ['SYS.XYZZY']]
tokens.columns = *
tokens.tables = ['SYS.XYZZY']
Select A from Sys.dual ->
tokens = ['select', ['A'], 'from', ['SYS.DUAL']]
tokens.columns = ['A']
tokens.tables = ['SYS.DUAL']
Select A,B,C from Sys.dual ->
tokens = ['select', ['A', 'B', 'C'], 'from', ['SYS.DUAL']]
tokens.columns = ['A', 'B', 'C']
tokens.tables = ['SYS.DUAL']
Select A, B, C from Sys.dual ->
tokens = ['select', ['A', 'B', 'C'], 'from', ['SYS.DUAL']]
tokens.columns = ['A', 'B', 'C']
tokens.tables = ['SYS.DUAL']
Select A, B, C from Sys.dual, Table2 ->
tokens = ['select', ['A', 'B', 'C'], 'from', ['SYS.DUAL', 'TABLE2']]
tokens.columns = ['A', 'B', 'C']
tokens.tables = ['SYS.DUAL', 'TABLE2']
Xelect A, B, C from Sys.dual ->
^
Expected 'select'
Expected 'select' (0), (1,1)
Select A, B, C frox Sys.dual ->
^
Expected 'from'
Expected 'from' (15), (1,16)
Select ->
^
Expected '*'
Expected '*' (6), (1,7)
Select &&& frox Sys.dual ->
^
Expected '*'
Expected '*' (7), (1,8)
>Exit code: 0
""" | dbbhattacharya/kitsune | vendor/packages/pyparsing/examples/simpleSQL.py | Python | bsd-3-clause | 4,698 |
#********************************************************************************
#--------------------------------------------------------------------------------
#
# Significance Labs
# Brooklyn, NYC
#
# Author: Alexandra Berke (aberke)
# Written: Summer 2014
#
#
#
# util file
#
#
#--------------------------------------------------------------------------------
#*********************************************************************************
from flask import Response
import json
from bson import ObjectId
from datetime import datetime
import error_codes
from functools import wraps
from flask import request, current_app
def jsonp(func):
"""
Taken from: https://gist.github.com/1094140
Wraps JSONified output for JSONP requests.
"""
@wraps(func)
def decorated_function(*args, **kwargs):
callback = request.args.get('callback', False)
if callback:
data = str(func(*args, **kwargs).data)
content = str(callback) + '(' + data + ')'
mimetype = 'application/javascript'
return current_app.response_class(content, mimetype=mimetype)
else:
return func(*args, **kwargs)
return decorated_function
class JSONEncoder(json.JSONEncoder):
# Custom JSONJSONencoder because by default, json cannot handle datetimes or ObjectIds """
def default(self, o):
if isinstance(o, datetime):
return str(o)
if isinstance(o, ObjectId):
return str(o)
return json.JSONEncoder.default(self, o)
def decode(self, data):
if not type(data) == dict:
return data
if '_id' in data:
data['_id'] = ObjectId(data['_id'])
if '_cleaner' in data:
data['_cleaner'] = ObjectId(data['_cleaner'])
if '_list' in data:
data['_list'] = ObjectId(data['_list'])
if '_room' in data:
data['_room'] = ObjectId(data['_room'])
return data
def load(self, data):
if not data:
return None
return self.decode(json.loads(data))
JSONencoder = JSONEncoder()
class APIexception(Exception):
code = 0
message = None
original_message = None
def yell(self, message):
print("\n************ ERROR **************\n" + str(message) + "\n************* ERROR *************\n")
def __init__(self, message='', code=0):
if not code in error_codes.map:
self.yell('Invalid error code: ' + str(code))
code = 0
self.code = code
self.original_message = message
self.message = error_codes.map[code]
Exception.__init__(self, message)
yellERROR("Original message: {0}\nMessage: {1}".format(self.original_message, self.message)) # yell the error for logs
def respond500(exception):
"""
@param {int} code: error code for which to find error string in error_codes map
@param {str} err: optional error message to YELL to server for logs
Philosophy:
Return a small set of error strings
- These strings are keywords in the translations spreadsheet that have translations
Use:
When endpoints are hit with bad data or cause accidental exceptions to occur
It catches accidentally raised Exceptions
- In this case, expects code==0
- Returns nicely formatted response to user rather than cryptic mongo/python error
It it called directly when endpoint receives invalid data
- Expects code in error_codes map
"""
if not isinstance(exception, APIexception):
exception = APIexception(message=exception.message)
data = json.dumps({ 'message': exception.message, 'code': exception.code })
response_headers = {'Content-Type': 'application/json'}
return Response(data, 500, response_headers)
def respond200():
return Response(status=200)
def dumpJSON(data):
if not isinstance(data, str):
data = JSONencoder.encode(data)
response_headers = {'Content-Type': 'application/json'}
return Response(data, 200, response_headers)
def yellERROR(msg=None):
print("\n************ ERROR **************\n" + str(msg) + "\n************* ERROR *************\n") | cromulus/check-list | app/lib/util.py | Python | mit | 3,902 |
#!/usr/bin/env python
# encoding: utf-8
"""
Created by Jeff Verkoeyen on 2011-06-07.
Copyright 2011 Jeff Verkoeyen
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 exposed interfaces for the ios module.
from pbxproj import pbxproj
from relpath import relpath
| jyotiness/ARTSDK | thirdparty/nimbus/scripts/ios/__init__.py | Python | mit | 747 |
#/###################/#
# Import modules
#
#ImportModules
import ShareYourSystem as SYS
#/###################/#
# Build the model
#
#Define
MyTransferer=SYS.TransfererClass(
).stationarize(
_MeanWeightVariable=[
[0.,-10.],
[10.,0.]
],
_RateVariable = [5.,5.],
_InteractionStr = "Spike"
).stabilize(
_ComputeBool=False
).transfer(
_ColorStrsList = ["red","blue"]
).view(
).pyplot(
).show(
)
#print
print('MyTransferer is ')
SYS._print(MyTransferer)
| Ledoux/ShareYourSystem | Pythonlogy/ShareYourSystem/Specials/_Lifers/Transferer/tests/test_13_transfer_lif_ExampleCell.py | Python | mit | 480 |
# Generated by Django 2.2.13 on 2020-07-06 15:28
from __future__ import unicode_literals
from django.db import migrations
import re
PERMISSIONS = ['view', 'add', 'change', 'delete']
MODELS = {'core': ['Annotation',
'Attachment',
'Build',
'Environment',
'Metric',
'Status',
'Suite',
'TestRun'],
'ci': ['TestJob']}
def split_on_upper_and_make_lower(name):
split = re.findall('[A-Z][^A-Z]*', name)
return [w.lower() for w in split]
def create_squad_group_and_add_users(apps, schema_editor):
Group = apps.get_model('auth', 'Group')
Permission = apps.get_model('auth', 'Permission')
ContentType = apps.get_model('contenttypes', 'ContentType')
squad_group, created = Group.objects.get_or_create(name='squad')
for app, model in MODELS.items():
for m in model:
ct = ContentType.objects.get_for_model(apps.get_model(app, m))
for permission in PERMISSIONS:
split_words = split_on_upper_and_make_lower(m)
perm_name = 'Can {}' + (' {}' * len(split_words))
name = perm_name.format(permission, *split_words)
codename = '_'.join([permission, m.lower()])
try:
perm = Permission.objects.get(name=name, codename=codename, content_type=ct)
except Permission.DoesNotExist:
perm = Permission.objects.create(name=name, codename=codename, content_type=ct)
squad_group.permissions.add(perm)
User = apps.get_model('auth', 'User')
for user in User.objects.all():
squad_group.user_set.add(user)
class Migration(migrations.Migration):
dependencies = [
('core', '0130_project_status_baseline_next'),
]
operations = [
migrations.RunPython(
create_squad_group_and_add_users,
reverse_code=migrations.RunPython.noop
)
]
| Linaro/squad | squad/core/migrations/0131_create_squad_auth_group_and_add_users.py | Python | agpl-3.0 | 2,033 |
import sys
import os
import inspect
from PyQt5 import QtWidgets, QtCore, QtGui
import plugnplay
from uptime import boottime
from TardisUtil import TardisOptions, TimeSubmitter
class TardisDiff(QtWidgets.QMainWindow):
def __init__(self):
super(TardisDiff, self).__init__()
self.difference = 0
self.clipboard = QtWidgets.QApplication.clipboard()
# Set hot keys
QtWidgets.QShortcut(QtGui.QKeySequence("Ctrl+Shift+C"), self,
self.setClipboard)
QtWidgets.QShortcut(QtGui.QKeySequence("Ctrl+Shift+T"), self,
self.notify_time_submitters)
self.options = TardisOptions()
# Get plugins
plugnplay.plugin_dirs = ['./plugins', ]
plugnplay.load_plugins()
# Get directory path
# From: http://stackoverflow.com/a/22881871/1963958
if getattr(sys, 'frozen', False): # py2exe, PyInstaller, cx_Freeze
script_path = os.path.abspath(sys.executable)
else:
script_path = inspect.getabsfile(TardisDiff)
script_path = os.path.realpath(script_path)
script_path = os.path.dirname(script_path)
# Google for a fancy tardis icon until I've made one
self.setWindowIcon(QtGui.QIcon(
os.path.join(script_path, 'icon', 'tardis-by-camilla-isabell-kasbo.ico')))
self.initUI()
def initUI(self):
# Create and initialize UI elements
self.contentWidget = QtWidgets.QWidget()
self.gridLayout = QtWidgets.QGridLayout(self.contentWidget)
self.formLayout = QtWidgets.QFormLayout()
self.timeEdit1 = QtWidgets.QTimeEdit(self.contentWidget)
self.timeEdit2 = QtWidgets.QTimeEdit(self.contentWidget)
self.timeEditBreakTime = QtWidgets.QTimeEdit(self.contentWidget)
self.timeEditBreakTime.setDisplayFormat("h:mm")
self.timeEditBreakTime.setCurrentSection(
QtWidgets.QDateTimeEdit.MinuteSection)
self.timeEditBreakTime.setTime(QtCore.QTime(0, 30))
self.label_timeDiffOut = QtWidgets.QLabel(self.contentWidget)
self.button_time1_now = QtWidgets.QPushButton(
"Now", self.contentWidget)
self.button_time2_now = QtWidgets.QPushButton(
"Now", self.contentWidget)
self.label_timeDiffOut.setText("")
self.timeEdit1.setTime(self.getStartTime())
self.timeEdit2.setTime(QtCore.QTime.currentTime())
# Add UI elements
row1 = QtWidgets.QHBoxLayout()
row1.addWidget(self.timeEdit1)
row1.addWidget(self.button_time1_now)
row2 = QtWidgets.QHBoxLayout()
row2.addWidget(self.timeEdit2)
row2.addWidget(self.button_time2_now)
self.formLayout.addRow("Time 1:", row1)
self.formLayout.addRow("Time 2:", row2)
self.formLayout.addRow("Break Time:", self.timeEditBreakTime)
self.formLayout.addRow("Difference:", self.label_timeDiffOut)
self.gridLayout.addLayout(self.formLayout, 0, 0, 1, 1)
self.setCentralWidget(self.contentWidget)
self.statusBar()
# connect slots
self.timeEdit1.timeChanged.connect(self.inputChanged)
self.timeEdit2.timeChanged.connect(self.inputChanged)
self.timeEditBreakTime.timeChanged.connect(self.inputChanged)
self.button_time1_now.pressed.connect(self.reset_time1)
self.button_time2_now.pressed.connect(self.reset_time2)
self.setWindowTitle('TardisDiff')
self.inputChanged()
self.show()
def inputChanged(self):
"""
Checks both time inputs and the break time
input to determine the difference.
Then calls the method to update the ui.
"""
time1 = self.timeEdit1.time()
time2 = self.timeEdit2.time()
breakTime = self.timeEditBreakTime.time().secsTo(QtCore.QTime(0, 0))
self.difference = (time1.secsTo(time2) + breakTime) / 3600
self.difference = round(self.difference, 2)
self.label_timeDiffOut.setText(str(self.difference))
def reset_time1(self):
self.timeEdit1.setTime(QtCore.QTime.currentTime())
def reset_time2(self):
self.timeEdit2.setTime(QtCore.QTime.currentTime())
def setClipboard(self):
"""Sets the current diff text to clipboard"""
self.clipboard.setText(str(self.difference))
self.statusBar().showMessage("Copied to clipboard.")
def getStartTime(self):
return TardisDiff.getBootTimeAsQTime()\
if self.options.isStartTimeAuto()\
else QtCore.QTime.fromString(self.options.getStartTime())
def notify_time_submitters(self):
TimeSubmitter.submit_time(self.difference)
@staticmethod
def getBootTimeAsQTime():
return QtCore.QDateTime(boottime()).time()
def main():
app = QtWidgets.QApplication(sys.argv)
ed = TardisDiff()
sys.exit(app.exec_())
if __name__ == '__main__':
main()
| git-commit/TardisDiff | TardisDiff.py | Python | isc | 4,981 |
# F3AT - Flumotion Asynchronous Autonomous Agent Toolkit
# Copyright (C) 2010,2011 Flumotion Services, S.A.
# All rights reserved.
# 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.
# See "LICENSE.GPL" in the source distribution for more information.
# Headers in this file shall remain intact.
import json
from zope.interface import implements
from feat.common import defer, serialization, error, log
from feat.common.serialization import json as feat_json
from feat.common.container import AsyncDict
from feat.web import document
from feat.models.interface import IModel, IReference
from feat.models.interface import IErrorPayload
from feat.models.interface import IActionPayload, IMetadata, IAttribute
from feat.models.interface import IValueCollection, IValueOptions, IValueRange
from feat.models.interface import IEncodingInfo, ValueTypes
from feat.models.interface import Unauthorized
MIME_TYPE = "application/json"
class ActionPayload(dict):
implements(IActionPayload)
def render_metadata(obj):
result = []
if IMetadata.providedBy(obj):
metadata = IMetadata(obj)
for metaitem in metadata.iter_meta():
m = {"name": metaitem.name,
"value": metaitem.value}
if metaitem.scheme is not None:
m["scheme"] = metaitem.scheme
result.append(m)
return result
def render_model_items(model, context):
return model.fetch_items().addCallback(render_items, context)
def render_items(items, context):
result = AsyncDict()
for item in items:
result.add(item.name, render_item(item, context))
return result.wait()
def render_model_actions(model, context):
return model.fetch_actions().addCallback(render_actions, context)
def render_actions(actions, context):
result = AsyncDict()
for action in actions:
result.add(action.name, render_action(action, context))
return result.wait()
def render_item(item, context):
result = AsyncDict()
result.add_if_not_none("label", item.label)
result.add_if_not_none("desc", item.desc)
result.add_if_true("metadata", render_metadata(item))
result.add_result("href", item.reference, "resolve", context)
args = (context, result)
return item.fetch().addCallbacks(render_attribute, filter_errors,
callbackArgs=args, errbackArgs=args)
def render_attribute(model, context, result=None):
if not IAttribute.providedBy(model):
return result and result.wait()
result = result or AsyncDict()
subcontext = context.descend(model)
attr = IAttribute(model)
result.add("info", render_value_info(attr.value_info))
result.add_if_true("readable", attr.is_readable)
result.add_if_true("writable", attr.is_writable)
result.add_if_true("deletable", attr.is_deletable)
if attr.is_readable:
if attr.value_info.value_type is not ValueTypes.binary:
d = attr.fetch_value()
d.addCallback(render_value, subcontext)
result.add("value", d)
return result.wait()
def filter_errors(failure, context, result):
failure.trap(Unauthorized)
return result and result.wait()
def render_action(action, context):
result = AsyncDict()
result.add_if_not_none("label", action.label)
result.add_if_not_none("desc", action.desc)
result.add_if_true("metadata", render_metadata(action))
result.add("method", context.get_action_method(action).name)
result.add_if_true("idempotent", bool(action.is_idempotent))
result.add("category", action.category.name)
result.add_result("href", action.reference, "resolve", context)
if action.result_info is not None:
result.add("result", render_value_info(action.result_info))
if action.parameters:
result.add("params", render_params(action.parameters))
return result.wait()
def render_value_info(value):
result = AsyncDict()
result.add("type", value.value_type.name)
if value.use_default:
result.add("default", value.default)
result.add_if_not_none("label", value.label)
result.add_if_not_none("desc", value.desc)
result.add_if_true("metadata", render_metadata(value))
if IEncodingInfo.providedBy(value):
encinfo = IEncodingInfo(value)
result.add_if_not_none("mimetype", encinfo.mime_type)
result.add_if_not_none("encoding", encinfo.encoding)
if IValueCollection.providedBy(value):
coll = IValueCollection(value)
allowed = [render_value_info(v) for v in coll.allowed_types]
result.add("allowed", defer.join(*allowed))
result.add("ordered", coll.is_ordered)
result.add_if_not_none("min_size", coll.min_size)
result.add_if_not_none("max_size", coll.max_size)
if IValueRange.providedBy(value):
vrange = IValueRange(value)
result.add("minimum", vrange.minimum)
result.add("maximum", vrange.maximum)
result.add_if_not_none("increment", vrange.increment)
if IValueOptions.providedBy(value):
options = IValueOptions(value)
result.add("restricted", options.is_restricted)
result.add("options", [{"label": o.label, "value": o.value}
for o in options.iter_options()])
return result.wait()
def render_params(params):
result = AsyncDict()
for param in params:
result.add(param.name, render_param(param))
return result.wait()
def render_param(param):
result = AsyncDict()
result.add("required", param.is_required)
result.add("info", render_value_info(param.value_info))
result.add_if_not_none("label", param.label)
result.add_if_not_none("desc", param.desc)
return result.wait()
def render_value(value, context):
if IReference.providedBy(value):
return value.resolve(context)
return value
def render_verbose(model, context):
result = AsyncDict()
result.add("identity", model.identity)
result.add_if_not_none("name", model.name)
result.add_if_not_none("label", model.label)
result.add_if_not_none("desc", model.desc)
result.add_result("href", model.reference, "resolve", context)
result.add_if_true("metadata", render_metadata(model))
result.add_if_true("items", render_model_items(model, context))
result.add_if_true("actions", render_model_actions(model, context))
return render_attribute(model, context, result)
def render_compact_model(model, context):
if IAttribute.providedBy(model):
attr = IAttribute(model)
if attr.is_readable:
d = attr.fetch_value()
d.addCallback(render_value, context)
return d
return defer.succeed(None)
if render_as_list(model):
return render_model_as_list(model, context)
result = AsyncDict()
if model.reference:
result.add_result("href", model.reference, "resolve", context)
d = model.fetch_items()
d.addCallback(render_compact_items, context, result)
return d
def render_compact_items(items, context, result):
for item in items:
if render_inline(item):
d = item.fetch()
d.addCallback(render_inline_model, context)
result.add(item.name, d)
elif iattribute_meta(item) and not prevent_inline(item):
d = item.fetch()
d.addCallback(render_compact_attribute, item, context)
result.add(item.name, d)
elif item.reference is not None:
result.add(item.name, item.reference.resolve(context))
return result.wait()
def _parse_meta(meta_items):
return [i.strip() for i in meta_items.value.split(",")]
def get_parsed_meta(meta):
if not IMetadata.providedBy(meta):
return []
parsed = [_parse_meta(i) for i in meta.get_meta('json')]
return parsed
def iattribute_meta(meta):
parsed = get_parsed_meta(meta)
return ['attribute'] in parsed
def render_inline(meta):
parsed = get_parsed_meta(meta)
return ['render-inline'] in parsed
def render_as_list(meta):
parsed = get_parsed_meta(meta)
return ['render-as-list'] in parsed
def prevent_inline(meta):
parsed = get_parsed_meta(meta)
return ['prevent-inline'] in parsed
def render_compact_attribute(submodel, item, context):
attr = IAttribute(submodel)
if attr.value_info.value_type is ValueTypes.binary:
if item.reference is not None:
return item.reference.resolve(context)
elif attr.is_readable:
d = attr.fetch_value()
d.addCallback(render_value, context)
return d
def filter_model_errors(failure, item, context):
failure.trap(Unauthorized)
if item.reference is not None:
return item.reference.resolve(context)
return failure
def render_json(data, doc):
if doc.encoding == 'nested-json':
doc.write(data)
else:
enc = CustomJSONEncoder(encoding=doc.encoding)
doc.write(enc.encode(data))
def write_model(doc, obj, *args, **kwargs):
context = kwargs["context"]
verbose = "format" in kwargs and "verbose" in kwargs["format"]
if verbose:
d = render_verbose(obj, context)
else:
d = render_compact_model(obj, context)
return d.addCallback(render_json, doc)
class NestedJson(document.BaseDocument):
'''
This is an implementation used to represent nested documents which
are rendered inline. It is used in CustomJSONEncoder to injects
preserialized parts of resulting json into the structure.
'''
implements(document.IWritableDocument)
def __init__(self):
document.BaseDocument.__init__(self, MIME_TYPE, 'nested-json')
self._data = None
def get_data(self):
return self._data
### IWriter ###
def write(self, data):
self._data = data
def writelines(self, sequence):
raise NotImplementedError("This should not be used for NestedJson")
def render_inline_model(obj, context, *args, **kwargs):
obj = IModel(obj)
doc = NestedJson()
d = document.write(doc, obj, context=context)
d.addCallback(defer.override_result, doc)
return d
def render_model_as_list(obj, context):
def got_items(items):
defers = list()
for item in items:
d = item.fetch()
d.addCallbacks(render_inline_model, filter_model_errors,
callbackArgs=(context, ),
errbackArgs=(item, context))
defers.append(d)
return defer.DeferredList(defers, consumeErrors=True)
d = obj.fetch_items()
d.addCallback(got_items)
d.addCallback(unpack_deferred_list_result)
d.addCallback(list)
return d
def unpack_deferred_list_result(results):
for successful, result in results:
if not successful:
error.handle_failure(None, result, "Failed rendering inline model")
continue
yield result
def write_reference(doc, obj, *args, **kwargs):
context = kwargs["context"]
result = obj.resolve(context)
render_json({u"type": u"reference", u"href": result}, doc)
def write_error(doc, obj, *args, **kwargs):
result = {}
result[u"type"] = u"error"
result[u"error"] = unicode(obj.error_type.name)
if obj.error_code is not None:
result[u"code"] = int(obj.error_code)
if obj.message is not None:
result[u"message"] = obj.message
if obj.subjects is not None:
result[u"subjects"] = list(obj.subjects)
if obj.reasons:
result[u"reasons"] = dict([k, str(v)]
for k, v in obj.reasons.iteritems())
if obj.debug is not None:
result[u"debug"] = obj.debug
if obj.stamp:
result[u"stamp"] = obj.stamp
log.debug('application/json',
'Wrote error response with debug stamp: %s', obj.stamp)
log.debug('application/json', 'Error: %s', result[u'error'])
if obj.message:
log.debug('application/json', 'Message: %s', obj.message)
render_json(result, doc)
def write_anything(doc, obj, *args, **kwargs):
render_json(obj, doc)
def read_action(doc, *args, **kwargs):
data = doc.read()
if not data:
return ActionPayload()
try:
params = json.loads(data)
except ValueError, e:
raise document.DocumentFormatError("Invalid JSON document: %s"
% (e, ))
if not isinstance(params, dict):
return ActionPayload([(u"value", params)])
return ActionPayload(params)
document.register_writer(write_model, MIME_TYPE, IModel)
document.register_writer(write_error, MIME_TYPE, IErrorPayload)
document.register_writer(write_reference, MIME_TYPE, IReference)
# document.register_writer(write_serializable, MIME_TYPE,
# serialization.ISerializable)
document.register_writer(write_anything, MIME_TYPE, None)
document.register_reader(read_action, MIME_TYPE, IActionPayload)
### private ###
class CustomJSONEncoder(json.JSONEncoder):
def __init__(self, context=None, encoding=None):
kwargs = {"indent": 2}
if encoding is not None:
kwargs["encoding"] = encoding
json.JSONEncoder.__init__(self, **kwargs)
self._serializer = feat_json.PreSerializer()
def default(self, obj):
if serialization.ISerializable.providedBy(obj):
return self._serializer.convert(obj)
if serialization.ISnapshotable.providedBy(obj):
return self._serializer.freeze(obj)
if isinstance(obj, NestedJson):
# models marked with render-inline are rendered into a separate
# IWritableDocument instance, which is here injected into its
# placeholder in the resulting document
return obj.get_data()
return json.JSONEncoder.default(self, obj)
| f3at/feat | src/feat/models/applicationjson.py | Python | gpl-2.0 | 14,537 |
from mdt import CompartmentTemplate, FreeParameterTemplate
from mdt.model_building.parameter_functions.transformations import ScaleTransform
__author__ = 'Robbert Harms'
__date__ = "2015-06-21"
__maintainer__ = "Robbert Harms"
__email__ = "[email protected]"
class TimeDependentZeppelin(CompartmentTemplate):
"""Implements a Zeppelin (cylindrical symmetric Tensor) with time dependence in the perpendicular diffusivity.
The perpendicular diffusivity is calculated as:
.. math::
D_{h, \perp} = D_{h,\infty} + A \frac{\ln(\Delta/\delta) + 3/2}{\Delta - \delta/3}
For a detailed description please see equation 11 in [1].
References:
[1] De Santis, S., Jones D., Roebroeck A., 2016. Including diffusion time dependence in the extra-axonal space
improves in vivo estimates of axonal diameter and density in human white matter, NeuroImage 2016.
"""
parameters = ('g', 'b', 'd', 'd_bulk', 'theta', 'phi', 'time_dependent_characteristic_coefficient(A)',
'Delta', 'delta')
dependencies = ('Zeppelin',)
cl_code = '''
double dperp0 = d_bulk + A * (log(Delta/delta) + 3/2.0)/(Delta - delta/3.0);
return Zeppelin(g, b, d, dperp0, theta, phi);
'''
class time_dependent_characteristic_coefficient(FreeParameterTemplate):
"""The time dependent characteristic as used in the TimeDependentZeppelin model. Values are in m^2."""
init_value = 1e-6
lower_bound = 1e-7
upper_bound = 1e-5
parameter_transform = ScaleTransform(1e7)
sampling_proposal_std = 1e-7
| cbclab/MDT | mdt/data/components/standard/compartment_models/TimeDependentZeppelin.py | Python | lgpl-3.0 | 1,598 |
"""
Functions provided to user for saving / loading / combining times data objects.
"""
from __future__ import absolute_import
from timeit import default_timer as timer
try:
import cPickle as pickle
except:
import pickle
import copy
# import mmap
# import os
from gtimer.private import focus as f
from gtimer.private import collapse
from gtimer.local.times import Times
from gtimer.local import merge
__all__ = ['get_times', 'attach_subdivision', 'attach_par_subdivision',
'save_pkl', 'load_pkl']
# 'open_mmap', 'close_mmap', 'save_mmap', 'load_mmap']
def get_times():
"""
Produce a deepcopy of the current timing data (no risk of interference
with active timing or other operaitons).
Returns:
Times: gtimer timing data structure object.
"""
if f.root.stopped:
return copy.deepcopy(f.root.times)
else:
t = timer()
times = collapse.collapse_times()
f.root.self_cut += timer() - t
return times
def attach_par_subdivision(par_name, par_times):
"""
Manual assignment of a collection of (stopped) Times objects as a parallel
subdivision of a running timer.
Notes:
An example sequence of proper usage:
1. Stamp in master process.
2. Run timed sub-processes.
3. Get timing data from sub-processes into master.
4. Attach timing data (i.e. list of Times objects) in master using this method.
5. Stamp in master process.
To stamp in the master between steps 1 and 5, it is recommended to
subdivide() between steps 1 and 2, and end that subdivision before
attaching, or else the master stamp will not reflect the sub-process
time.
Args:
par_name (any): Identifier for the collection, passed through str()
par_times (list or tuple): Collection of Times data objects.
Raises:
TypeError: If par_times not a list or tuple of Times data objects.
"""
t = timer()
if not isinstance(par_times, (list, tuple)):
raise TypeError("Expected list or tuple for param 'par_times'.")
for times in par_times:
if not isinstance(times, Times):
raise TypeError("Expected each element of param 'par_times' to be Times object.")
assert times.total > 0., "An attached par subdivision has total time 0, appears empty."
par_name = str(par_name)
sub_with_max_tot = max(par_times, key=lambda x: x.total)
f.r.self_agg += sub_with_max_tot.self_agg
if par_name not in f.t.par_subdvsn_awaiting:
f.t.par_subdvsn_awaiting[par_name] = []
for times in par_times:
times_copy = copy.deepcopy(times)
times_copy.parent = f.r
times_copy.par_in_parent = par_name
f.t.par_subdvsn_awaiting[par_name].append(times_copy)
else:
for new_sub in par_times:
is_prev_sub = False
for old_sub in f.t.par_subdvsn_awaiting[par_name]:
if old_sub.name == new_sub.name:
is_prev_sub = True
break
if is_prev_sub:
merge.merge_times(old_sub, new_sub)
else:
new_sub_copy = copy.deepcopy(new_sub)
new_sub_copy.parent = f.r
new_sub_copy.par_in_parent = par_name
f.t.par_subdvsn_awaiting[par_name].append(new_sub_copy)
f.t.self_cut += timer() - t
def attach_subdivision(times):
"""
Manual assignment of a (stopped) times object as a subdivision of running
timer. Use cases are expected to be very limited (mainly provided as a
one-Times variant of attach_par_subdivision).
Notes:
As with any subdivision, the interval in the receiving timer is assumed to
totally subsume the time accumulated within the attached object--the total
in the receiver is not adjusted!
Args:
times (Times): Individual Times data object.
Raises:
TypeError: If times not a Times data object.
"""
t = timer()
if not isinstance(times, Times):
raise TypeError("Expected Times object for param 'times'.")
assert times.total > 0., "Attached subdivision has total time 0, appears empty."
name = times.name
f.r.self_agg += times.self_agg
if name not in f.t.subdvsn_awaiting:
times_copy = copy.deepcopy(times)
times_copy.parent = f.r
f.t.subdvsn_awaiting[name] = times_copy
else:
merge.merge_times(f.t.subdvsn_awaiting[name], times)
f.t.self_cut += timer() - t
def save_pkl(filename=None, times=None):
"""
Serialize and / or save a Times data object using pickle (cPickle).
Args:
filename (None, optional): Filename to dump to. If not provided,
returns serialized object.
times (None, optional): object to dump. If non provided, uses
current root.
Returns:
pkl: Pickled Times data object, only if no filename provided.
Raises:
TypeError: If 'times' is not a Times object or a list of tuple of
them.
"""
if times is None:
if not f.root.stopped:
times = collapse.collapse_times()
else:
times = f.root.times
else:
if isinstance(times, (list, tuple)):
for t in times:
if not isinstance(t, Times):
raise TypeError("Expected single Times instance or list/tuple of Times instances for param 'times'.")
elif not isinstance(times, Times):
raise TypeError("Expected single Times instance or list/tuple of Times instances for param 'times'.")
if filename is not None:
with open(str(filename), 'wb') as file:
pickle.dump(times, file)
else:
return pickle.dumps(times)
def load_pkl(filenames):
"""
Unpickle file contents.
Args:
filenames (str): Can be one or a list or tuple of filenames to retrieve.
Returns:
Times: A single object, or from a collection of filenames, a list of Times objects.
Raises:
TypeError: If any loaded object is not a Times object.
"""
if not isinstance(filenames, (list, tuple)):
filenames = [filenames]
times = []
for name in filenames:
name = str(name)
with open(name, 'rb') as file:
loaded_obj = pickle.load(file)
if not isinstance(loaded_obj, Times):
raise TypeError("At least one loaded object is not a Times data object.")
times.append(loaded_obj)
return times if len(times) > 1 else times[0]
#
# These are still under construction...not tested and probably not functional:
#
# def open_mmap(filenames, init_size=10000, write=True):
# """
# EXPERIMENTAL: UNTESTED OR NOT FUNCTIONING.
# Args:
# filenames (TYPE): Description
# init_size (int, optional): Description
# write (bool, optional): Description
# """
# if not isinstance(filenames, (list, tuple)):
# filenames = [filenames]
# files = list()
# mmaps = list()
# for name in filenames:
# name = str(name)
# if not os.path.isfile(name):
# with open(name, 'w') as f:
# f.write(init_size * b'\0')
# if write:
# access = mmap.ACCESS_COPY
# else:
# access = mmap.ACCESS_READ
# file = open(name, 'r+')
# mm = mmap.mmap(f.fileno(), 0, access=access)
# files.append(file)
# mmaps.append(mm)
# if len(files) > 1:
# return files, mmaps
# else:
# return file, mm
# def close_mmap(mmaps, files):
# """
# EXPERIMENTAL: UNTESTED OR NOT FUNCTIONING.
# Args:
# mmaps (TYPE): Description
# files (TYPE): Description
# """
# mmaps = list(mmaps)
# files = list(files)
# for mm in mmaps:
# mm.close()
# for file in files:
# file.close()
# def save_mmap(mm, file, times=None):
# """
# EXPERIMENTAL: UNTESTED OR NOT FUNCTIONING.
# Args:
# mm (TYPE): Description
# file (TYPE): Description
# times (None, optional): Description
# """
# if times is not None:
# assert isinstance(times, Times), "Input 'times' must be None or Times object."
# times_pkl = save_pkl(times)
# filesize = mm.size()
# data_len = len(times_pkl)
# if data_len > filesize:
# mm.close()
# file.seek(0, 2)
# file.write((data_len - filesize) * b'\0')
# mm = mmap.mmap(file.fileno(), data_len, access=mmap.ACCESS_COPY)
# mm.seek(0)
# mm.write(times_pkl)
# return mm, data_len
# def load_mmap(mmaps, files, write=False):
# """
# EXPERIMENTAL: UNTESTED OR NOT FUNCTIONING.
# Args:
# mmaps (TYPE): Description
# files (TYPE): Description
# write (bool, optional): Description
# """
# mmaps = list(mmaps)
# files = list(files)
# times = list()
# if write:
# access = mmap.ACCESS_COPY
# else:
# access = mmap.ACCESS_READ
# mmaps_new = list()
# for file, mm in zip(files, mmaps):
# size = os.path.getsize(f)
# if size > mm.size():
# mm.close()
# mm_new = mmap.mmap(file.fileno(), 0, access=access)
# mmaps_new.append(mm_new)
# mm_new.seek(0)
# times.append(pickle.loads(mm_new.read(size)))
# else:
# mmaps_new.append(mm)
# mm.seek(0)
# times.append(pickle.loads(mm.read(size)))
# if len(times) > 1:
# return times, mmaps_new
# else:
# return times[0], mmaps_new[0]
| astooke/gtimer | gtimer/public/io.py | Python | mit | 9,738 |
# coding=utf-8
# Copyright 2022 The TensorFlow Datasets Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from tensorflow_datasets.image_classification import binary_alpha_digits
import tensorflow_datasets.testing as tfds_test
class BinaryAlphaDigitsTest(tfds_test.DatasetBuilderTestCase):
DATASET_CLASS = binary_alpha_digits.BinaryAlphaDigits
SPLITS = {
"train": 2,
}
DL_EXTRACT_RESULT = {"train": "binaryalphadigs.mat"}
if __name__ == "__main__":
tfds_test.test_main()
| tensorflow/datasets | tensorflow_datasets/image_classification/binary_alpha_digits_test.py | Python | apache-2.0 | 998 |
import os
from setuptools import setup, find_packages
requirements_file = open('%s/requirements.txt' % os.path.dirname(os.path.realpath(__file__)), 'r')
install_requires = [line.rstrip() for line in requirements_file]
base_dir = os.path.dirname(os.path.abspath(__file__))
setup(
name="pyhttp",
version="1.0.0",
description="An object-oriented layer for the HTTP specification. It provides an abstraction for requests, responses, uploaded files, cookies, etc",
long_description="\n\n".join([
open(os.path.join(base_dir, "README.rst"), "r").read(),
]),
url="https://github.com/felixcarmona/pyhttp",
author="Felix Carmona",
author_email="[email protected]",
packages=find_packages(exclude=('pyhttp.tests', 'pyhttp.tests.*')),
zip_safe=False,
install_requires=install_requires,
test_suite="pyhttp.tests.get_tests",
) | felixcarmona/pyhttp | setup.py | Python | mit | 875 |
# -*- encoding: utf8 -*-
#
# The Qubes OS Project, http://www.qubes-os.org
#
# Copyright (C) 2017 Marek Marczykowski-Górecki
# <[email protected]>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, see <https://www.gnu.org/licenses/>.
''' Qubes block devices extensions '''
import re
import string
import lxml.etree
import qubes.devices
import qubes.ext
name_re = re.compile(r"^[a-z0-9-]{1,12}$")
device_re = re.compile(r"^[a-z0-9/-]{1,64}$")
# FIXME: any better idea of desc_re?
desc_re = re.compile(r"^.{1,255}$")
mode_re = re.compile(r"^[rw]$")
# all frontends, prefer xvdi
# TODO: get this from libvirt driver?
AVAILABLE_FRONTENDS = ['xvd'+c for c in
string.ascii_lowercase[8:]+string.ascii_lowercase[:8]]
SYSTEM_DISKS = ('xvda', 'xvdb', 'xvdc', 'xvdd')
class BlockDevice(qubes.devices.DeviceInfo):
def __init__(self, backend_domain, ident):
super(BlockDevice, self).__init__(backend_domain=backend_domain,
ident=ident)
self._description = None
self._mode = None
self._size = None
@property
def description(self):
'''Human readable device description'''
if self._description is None:
if not self.backend_domain.is_running():
return self.ident
safe_set = {ord(c) for c in
string.ascii_letters + string.digits + '()+,-.:=_/ '}
untrusted_desc = self.backend_domain.untrusted_qdb.read(
'/qubes-block-devices/{}/desc'.format(self.ident))
if not untrusted_desc:
return ''
desc = ''.join((chr(c) if c in safe_set else '_')
for c in untrusted_desc)
self._description = desc
return self._description
@property
def mode(self):
'''Device mode, either 'w' for read-write, or 'r' for read-only'''
if self._mode is None:
if not self.backend_domain.is_running():
return 'w'
untrusted_mode = self.backend_domain.untrusted_qdb.read(
'/qubes-block-devices/{}/mode'.format(self.ident))
if untrusted_mode is None:
self._mode = 'w'
elif untrusted_mode not in (b'w', b'r'):
self.backend_domain.log.warning(
'Device {} has invalid mode'.format(self.ident))
self._mode = 'w'
else:
self._mode = untrusted_mode.decode()
return self._mode
@property
def size(self):
'''Device size in bytes'''
if self._size is None:
if not self.backend_domain.is_running():
return None
untrusted_size = self.backend_domain.untrusted_qdb.read(
'/qubes-block-devices/{}/size'.format(self.ident))
if untrusted_size is None:
self._size = 0
elif not untrusted_size.isdigit():
self.backend_domain.log.warning(
'Device {} has invalid size'.format(self.ident))
self._size = 0
else:
self._size = int(untrusted_size)
return self._size
@property
def device_node(self):
'''Device node in backend domain'''
return '/dev/' + self.ident.replace('_', '/')
class BlockDeviceExtension(qubes.ext.Extension):
@qubes.ext.handler('domain-init', 'domain-load')
def on_domain_init_load(self, vm, event):
'''Initialize watching for changes'''
# pylint: disable=unused-argument,no-self-use
vm.watch_qdb_path('/qubes-block-devices')
@qubes.ext.handler('domain-qdb-change:/qubes-block-devices')
def on_qdb_change(self, vm, event, path):
'''A change in QubesDB means a change in device list'''
# pylint: disable=unused-argument,no-self-use
vm.fire_event('device-list-change:block')
def device_get(self, vm, ident):
# pylint: disable=no-self-use
'''Read information about device from QubesDB
:param vm: backend VM object
:param ident: device identifier
:returns BlockDevice'''
untrusted_qubes_device_attrs = vm.untrusted_qdb.list(
'/qubes-block-devices/{}/'.format(ident))
if not untrusted_qubes_device_attrs:
return None
return BlockDevice(vm, ident)
@qubes.ext.handler('device-list:block')
def on_device_list_block(self, vm, event):
# pylint: disable=unused-argument,no-self-use
if not vm.is_running():
return
untrusted_qubes_devices = vm.untrusted_qdb.list('/qubes-block-devices/')
untrusted_idents = set(untrusted_path.split('/', 3)[2]
for untrusted_path in untrusted_qubes_devices)
for untrusted_ident in untrusted_idents:
if not name_re.match(untrusted_ident):
msg = ("%s vm's device path name contains unsafe characters. "
"Skipping it.")
vm.log.warning(msg % vm.name)
continue
ident = untrusted_ident
device_info = self.device_get(vm, ident)
if device_info:
yield device_info
@qubes.ext.handler('device-get:block')
def on_device_get_block(self, vm, event, ident):
# pylint: disable=unused-argument,no-self-use
if not vm.is_running():
return
if not vm.app.vmm.offline_mode:
device_info = self.device_get(vm, ident)
if device_info:
yield device_info
@qubes.ext.handler('device-list-attached:block')
def on_device_list_attached(self, vm, event, **kwargs):
# pylint: disable=unused-argument,no-self-use
if not vm.is_running():
return
xml_desc = lxml.etree.fromstring(vm.libvirt_domain.XMLDesc())
for disk in xml_desc.findall('devices/disk'):
if disk.get('type') != 'block':
continue
dev_path_node = disk.find('source')
if dev_path_node is None:
continue
dev_path = dev_path_node.get('dev')
target_node = disk.find('target')
if target_node is not None:
frontend_dev = target_node.get('dev')
if not frontend_dev:
continue
if frontend_dev in SYSTEM_DISKS:
continue
else:
continue
backend_domain_node = disk.find('backenddomain')
if backend_domain_node is not None:
backend_domain = vm.app.domains[backend_domain_node.get('name')]
else:
backend_domain = vm.app.domains[0]
options = {}
read_only_node = disk.find('readonly')
if read_only_node is not None:
options['read-only'] = 'yes'
else:
options['read-only'] = 'no'
options['frontend-dev'] = frontend_dev
if disk.get('device') != 'disk':
options['devtype'] = disk.get('device')
if dev_path.startswith('/dev/'):
ident = dev_path[len('/dev/'):]
else:
ident = dev_path
ident = ident.replace('/', '_')
yield (BlockDevice(backend_domain, ident), options)
def find_unused_frontend(self, vm):
# pylint: disable=no-self-use
'''Find unused block frontend device node for <target dev=.../>
parameter'''
assert vm.is_running()
xml = vm.libvirt_domain.XMLDesc()
parsed_xml = lxml.etree.fromstring(xml)
used = [target.get('dev', None) for target in
parsed_xml.xpath("//domain/devices/disk/target")]
for dev in AVAILABLE_FRONTENDS:
if dev not in used:
return dev
return None
@qubes.ext.handler('device-pre-attach:block')
def on_device_pre_attached_block(self, vm, event, device, options):
# pylint: disable=unused-argument
# validate options
for option, value in options.items():
if option == 'frontend-dev':
if not value.startswith('xvd') and not value.startswith('sd'):
raise qubes.exc.QubesValueError(
'Invalid frontend-dev option value: ' + value)
elif option == 'read-only':
options[option] = (
'yes' if qubes.property.bool(None, None, value) else 'no')
elif option == 'devtype':
if value not in ('disk', 'cdrom'):
raise qubes.exc.QubesValueError(
'devtype option can only have '
'\'disk\' or \'cdrom\' value')
else:
raise qubes.exc.QubesValueError(
'Unsupported option {}'.format(option))
if 'read-only' not in options:
options['read-only'] = 'yes' if device.mode == 'r' else 'no'
if options.get('read-only', 'no') == 'no' and device.mode == 'r':
raise qubes.exc.QubesValueError(
'This device can be attached only read-only')
if not vm.is_running():
return
if not device.backend_domain.is_running():
raise qubes.exc.QubesVMNotRunningError(device.backend_domain,
'Domain {} needs to be running to attach device from '
'it'.format(device.backend_domain.name))
if 'frontend-dev' not in options:
options['frontend-dev'] = self.find_unused_frontend(vm)
vm.libvirt_domain.attachDevice(
vm.app.env.get_template('libvirt/devices/block.xml').render(
device=device, vm=vm, options=options))
@qubes.ext.handler('device-pre-detach:block')
def on_device_pre_detached_block(self, vm, event, device):
# pylint: disable=unused-argument,no-self-use
if not vm.is_running():
return
# need to enumerate attached device to find frontend_dev option (at
# least)
for attached_device, options in self.on_device_list_attached(vm, event):
if attached_device == device:
vm.libvirt_domain.detachDevice(
vm.app.env.get_template('libvirt/devices/block.xml').render(
device=device, vm=vm, options=options))
break
| woju/qubes-core-admin | qubes/ext/block.py | Python | lgpl-2.1 | 11,039 |
#!/usr/bin/env python
import logging
import os
import runpy
import shutil
import sys
import textwrap
import argparse
import config
from path import path
import utils
# Be a good neighbour.
if sys.platform == 'win32':
GLOBAL_CONFIG_FILE = 'tipfy.cfg'
else:
GLOBAL_CONFIG_FILE = '.tipfy.cfg'
MISSING_GAE_SDK_MSG = "%(script)r wasn't found. Add the App Engine SDK to " \
"sys.path or configure sys.path in tipfy.cfg."
class Action(object):
"""Base interface for custom actions."""
#: Action name.
name = None
#: ArgumentParser description.
description = None
#: ArgumentParser epilog.
epilog = None
def __init__(self, manager, name):
self.manager = manager
self.name = name
self.logger = logging.getLogger(name)
def __call__(self, argv):
raise NotImplementedError()
def get_config_section(self):
sections = [self.manager.app, 'tipfy']
return ['%s:%s' % (s, self.name) for s in sections if s]
def error(self, message, status=1):
"""Displays an error message and exits."""
self.logger.error(message)
sys.exit(status)
def run_hooks(self, import_names, args):
"""Executes a list of functions defined as strings. They are imported
dynamically so their modules must be in sys.path. If any of the
functions isn't found, none will be executed.
"""
# Import all first.
hooks = []
for import_name in import_names:
hook = utils.import_string(import_name, True)
if hook is None:
self.error('Could not import %r.' % import_name)
hooks.append(hook)
# Execute all.
for hook in hooks:
hook(self.manager, args)
class CreateAppAction(Action):
"""Creates a directory for a new tipfy app."""
description = 'Creates a directory for a new App Engine app.'
def get_parser(self):
parser = argparse.ArgumentParser(
description=self.description
)
parser.add_argument(
'app_dir',
help='App directory or directories.',
nargs='+'
)
parser.add_argument(
'-t', '--template',
dest='template',
help='App template, copied to the new project directory. '
'If not defined, the default app skeleton is used.'
)
return parser
def __call__(self, argv):
manager = self.manager
section = self.get_config_section()
parser = self.get_parser()
args = parser.parse_args(args=argv)
template_dir = args.template
if not template_dir:
# Try getting the template set in config.
template_dir = manager.config.get(section, 'appengine_stub')
if not template_dir:
# Use default template.
curr_dir = os.path.dirname(os.path.realpath(__file__))
template_dir = os.path.join(curr_dir, 'stubs', 'appengine')
template_dir = os.path.abspath(template_dir)
if not os.path.exists(template_dir):
self.error('Template directory not found: %r.' % template_dir)
for app_dir in args.app_dir:
app_dir = os.path.abspath(app_dir)
self.create_app(app_dir, template_dir)
def create_app(self, app_dir, template_dir):
if os.path.exists(app_dir):
self.error('Project directory already exists: %r.' % app_dir)
shutil.copytree(template_dir, app_dir)
class GaeSdkAction(Action):
"""This is just a wrapper for tools found in the Google App Engine SDK.
It delegates all arguments to the SDK script and no additional arguments
are parsed.
"""
def __call__(self, argv):
sys.argv = [self.name] + argv
try:
runpy.run_module(self.name, run_name='__main__', alter_sys=True)
except ImportError:
self.error(MISSING_GAE_SDK_MSG % dict(script=self.name))
class GaeSdkExtendedAction(Action):
"""Base class for actions that wrap the App Engine SDK scripts to make
them configurable or to add before/after hooks. It accepts all options
from the correspondent SDK scripts, but they can be configured in
tipfy.cfg.
"""
options = []
def get_base_gae_argv(self):
raise NotImplementedError()
def get_getopt_options(self):
for option in self.options:
if isinstance(option, tuple):
long_option, short_option = option
else:
long_option = option
short_option = None
is_bool = not long_option.endswith('=')
long_option = long_option.strip('=')
yield long_option, short_option, is_bool
def get_parser_from_getopt_options(self):
manager = self.manager
section = self.get_config_section()
usage = '%%(prog)s %(action)s [--config CONFIG] [--app APP] ' \
'[options]' % dict(action=self.name)
parser = argparse.ArgumentParser(
description=self.description,
usage=usage,
formatter_class=argparse.RawDescriptionHelpFormatter,
add_help=False
)
for long_option, short_option, is_bool in self.get_getopt_options():
args = ['--%s' % long_option]
kwargs = {}
if short_option:
args.append('-%s' % short_option)
if is_bool:
kwargs['action'] = 'store_true'
kwargs['default'] = manager.config.getboolean(section,
long_option)
else:
kwargs['default'] = manager.config.get(section, long_option)
parser.add_argument(*args, **kwargs)
# Add app path.
app_path = manager.config.get(section, 'path', '')
parser.add_argument('app', nargs='?', default=app_path)
return parser
def get_gae_argv(self, argv):
manager = self.manager
parser = self.get_parser_from_getopt_options()
args, extras = parser.parse_known_args(args=argv)
if args.help:
parser.print_help()
sys.exit(1)
gae_argv = self.get_base_gae_argv()
for long_option, short_option, is_bool in self.get_getopt_options():
value = getattr(args, long_option)
if value is not None:
if is_bool and value:
value = '--%s' % long_option
elif not is_bool:
value = '--%s=%s' % (long_option, value)
if value:
gae_argv.append(value)
# Add app path.
gae_argv.append(os.path.abspath(args.app))
return gae_argv
class GaeRunserverAction(GaeSdkExtendedAction):
"""
A convenient wrapper for "dev_appserver": starts the Google App Engine
development server using before and after hooks and allowing configurable
defaults.
Default values for each option can be defined in tipfy.cfg in the
"tipfy:runserver" section or for the current app, sufixed by ":runserver".
A special variable "app" is replaced by the value from the "--app"
argument:
[tipfy]
path = /path/to/%(app)s
[tipfy:runserver]
debug = true
datastore_path = /path/to/%(app)s.datastore
[my_app:runserver]
port = 8081
In this case, executing:
tipfy runserver --app=my_app
...will expand to:
dev_appserver --datastore_path=/path/to/my_app.datastore --debug --port=8081 /path/to/my_app
Define in "before" and "after" a list of functions to run before and after
the server executes. These functions are imported so they must be in
sys.path. For example:
[tipfy:runserver]
before =
hooks.before_runserver_1
hooks.before_runserver_2
after =
hooks.after_runserver_1
hooks.after_runserver_2
Then define in the module "hooks.py" some functions to be executed:
def before_runserver_1(manager, args):
print 'before_runserver_1!'
def after_runserver_1(manager, args):
print 'after_runserver_1!'
# ...
Use "tipfy dev_appserver --help" for a description of each option.
"""
description = textwrap.dedent(__doc__)
# All options from dev_appserver in a modified getopt style.
options = [
('address=', 'a'),
'admin_console_server=',
'admin_console_host=',
'allow_skipped_files',
'auth_domain=',
('clear_datastore', 'c'),
'blobstore_path=',
'datastore_path=',
'use_sqlite',
('debug', 'd'),
'debug_imports',
'enable_sendmail',
'disable_static_caching',
'show_mail_body',
('help', 'h'),
'history_path=',
'mysql_host=',
'mysql_port=',
'mysql_user=',
'mysql_password=',
('port=', 'p'),
'require_indexes',
'smtp_host=',
'smtp_password=',
'smtp_port=',
'smtp_user=',
'disable_task_running',
'task_retry_seconds=',
'template_dir=',
'trusted',
]
def get_base_gae_argv(self):
return ['dev_appserver']
def __call__(self, argv):
manager = self.manager
section = self.get_config_section()
before_hooks = manager.config.getlist(section, 'before', [])
after_hooks = manager.config.getlist(section, 'after', [])
# Assemble arguments.
sys.argv = self.get_gae_argv(argv)
# Execute before scripts.
self.run_hooks(before_hooks, argv)
script = 'dev_appserver'
try:
self.logger.info('Executing: %s' % ' '.join(sys.argv))
runpy.run_module(script, run_name='__main__', alter_sys=True)
except ImportError:
self.error(MISSING_GAE_SDK_MSG % dict(script=script))
finally:
# Execute after scripts.
self.run_hooks(after_hooks, argv)
class GaeDeployAction(GaeSdkExtendedAction):
"""
A convenient wrapper for "appcfg update": deploys to Google App Engine
using before and after hooks and allowing configurable defaults.
Default values for each option can be defined in tipfy.cfg in the
"tipfy:deploy" section or for the current app, sufixed by ":deploy".
A special variable "app" is replaced by the value from the "--app"
argument:
[tipfy]
path = /path/to/%(app)s
[tipfy:deploy]
verbose = true
[my_app:deploy]
email = [email protected]
no_cookies = true
In this case, executing:
tipfy deploy --app=my_app
...will expand to:
appcfg update --verbose [email protected] --no_cookies /path/to/my_app
Define in "before" and "after" a list of functions to run before and after
deployment. These functions are imported so they must be in sys.path.
For example:
[tipfy:deploy]
before =
hooks.before_deploy_1
hooks.before_deploy_2
after =
hooks.after_deploy_1
hooks.after_deploy_2
Then define in the module "hooks.py" some functions to be executed:
def before_deploy_1(manager, args):
print 'before_deploy_1!'
def after_deploy_1(manager, args):
print 'after_deploy_1!'
# ...
Use "tipfy appcfg update --help" for a description of each option.
"""
description = textwrap.dedent(__doc__)
# All options from appcfg update in a modified getopt style.
options = [
('help', 'h'),
('quiet', 'q'),
('verbose', 'v'),
'noisy',
('server=', 's'),
'insecure',
('email=', 'e'),
('host=', 'H'),
'no_cookies',
'passin',
('application=', 'A'),
('version=', 'V'),
('max_size=', 'S'),
'no_precompilation',
]
def get_base_gae_argv(self):
return ['appcfg', 'update']
def __call__(self, argv):
manager = self.manager
section = self.get_config_section()
before_hooks = manager.config.getlist(section, 'before', [])
after_hooks = manager.config.getlist(section, 'after', [])
# Assemble arguments.
sys.argv = self.get_gae_argv(argv)
# Execute before scripts.
self.run_hooks(before_hooks, argv)
script = 'appcfg'
try:
self.logger.info('Executing: %s' % ' '.join(sys.argv))
runpy.run_module(script, run_name='__main__', alter_sys=True)
except ImportError:
self.error(MISSING_GAE_SDK_MSG % dict(script=script))
finally:
# Execute after scripts.
self.run_hooks(after_hooks, argv)
class BuildAction(Action):
description = 'Installs packages in the app directory.'
cache_path = 'var/cache/packages'
pin_file = 'var/%(app)s_pinned_versions.txt'
def get_parser(self):
manager = self.manager
# XXX cache option
# XXX symlinks option
section = self.get_config_section()
parser = argparse.ArgumentParser(
description=self.description
)
parser.add_argument(
'--from_pin_file',
help='Install package versions defined in this pin file.',
default=manager.config.get(section, 'from_pin_file')
)
parser.add_argument(
'--pin_file',
help='Name of the file to save pinned versions.',
default=manager.config.get(section, 'pin_file', self.pin_file)
)
parser.add_argument(
'--no_pin_file',
help="Don't create a pin file after installing the packages.",
action='store_true',
default=manager.config.getboolean(section, 'no_pin_file', False)
)
parser.add_argument(
'--cache_path',
help='Directory to store package cache.',
default=manager.config.get(section, 'cache_path', self.cache_path)
)
parser.add_argument(
'--no_cache',
help="Don't use package cache.",
action='store_true',
default=manager.config.getboolean(section, 'no_cache', False)
)
parser.add_argument(
'--no_symlink',
help="Move packages to app directory instead of creating "
"symlinks. Always active on Windows.",
action='store_true',
default=manager.config.getboolean(section, 'no_symlink', False)
)
return parser
def __call__(self, argv):
manager = self.manager
if not manager.app:
self.error('Missing app. Use --app=APP_NAME to define the current '
'app.')
parser = self.get_parser()
args = parser.parse_args(args=argv)
if args.from_pin_file:
packages_to_install = self.read_pin_file(args.from_pin_file)
else:
packages_to_install = manager.config.getlist(section, 'packages',
[])
if not packages_to_install:
self.error('Missing list of packages to install.')
if sys.platform == 'win32':
args.no_symlink = True
packages = []
if not args.no_pin_file:
pin_file = args.pin_file % dict(app=manager.app)
self.save_pin_file(pin_file, packages)
def save_pin_file(self, pin_file, packages):
# XXX catch errors
f = open(pin_file, 'w+')
f.write('\n'.join(packages))
f.close()
def read_pin_file(self, pin_file):
# XXX catch errors
f = open(pin_file, 'r')
contents = f.read()
f.close()
packages = [line.strip() for line in contents.splitlines()]
return [line for line in packages if line]
def _get_package_finder(self):
# XXX make mirrors configurable
from pip.index import PackageFinder
find_links = []
use_mirrors = False
mirrors = []
index_urls = ['http://pypi.python.org/simple/']
return PackageFinder(find_links=find_links, index_urls=index_urls,
use_mirrors=use_mirrors, mirrors=mirrors)
class InstallAppengineSdkAction(Action):
"""Not implemented yet."""
description = 'Downloads and unzips the App Engine SDK.'
def get_parser(self):
parser = argparse.ArgumentParser(
description=self.description
)
parser.add_argument(
'--version', '-v',
help='SDK version. If not defined, downloads the latest stable '
'one.'
)
return parser
def __call__(self, argv):
manager = self.manager
parser = self.get_parser()
raise NotImplementedError()
class TestAction(Action):
"""Testing stuff."""
def __call__(self, argv):
manager = self.manager
print manager.app
class TipfyManager(object):
description = 'Tipfy Management Utilities.'
epilog = 'Use "%(prog)s action --help" for help on specific actions.'
# XXX Allow users to hook in custom actions.
actions = {
# Wrappers for App Engine SDK tools.
'appcfg': GaeSdkAction,
'bulkload_client': GaeSdkAction,
'bulkloader': GaeSdkAction,
'dev_appserver': GaeSdkAction,
'remote_api_shell': GaeSdkAction,
# For now these are App Engine specific.
'runserver': GaeRunserverAction,
'deploy': GaeDeployAction,
# Extra ones.
#'install_gae_sdk': InstallAppengineSdkAction(),
'create_app': CreateAppAction,
'build': BuildAction,
'test': TestAction,
}
def __init__(self):
pass
def __call__(self, argv):
parser = self.get_parser()
args, extras = parser.parse_known_args(args=argv)
# Load configuration.
self.parse_config(args.config)
# XXX load other actions based on definitions from config.
if args.action not in self.actions:
# Unknown action or --help.
return parser.print_help()
# Load config fom a specific app, if defined, or use default one.
self.app = args.app or self.config.get('tipfy', 'app')
# Fallback to the tipfy section.
self.config_section = ['tipfy']
if self.app:
self.config_section.insert(0, self.app)
# If app is set, an 'app' value can be used in expansions.
if self.app:
self.config.set('DEFAULT', 'app', self.app)
# Prepend configured paths to sys.path, if any.
sys.path[:0] = self.config.getlist(self.config_section, 'sys.path', [])
# Current cwd and app paths.
self.cwd_path = path.getcwd()
if self.app:
default_app_path = self.cwd_path.joinpath(self.app)
self.app_path = path(self.config.get(self.config_section, 'path',
default_app_path)).abspath()
else:
self.app_path = None
if args.help:
# Delegate help to action.
extras.append('--help')
action = self.actions[args.action](self, args.action)
return action(extras)
def get_parser(self):
actions = ', '.join(sorted(self.actions.keys()))
parser = argparse.ArgumentParser(
description=self.description,
epilog=self.epilog,
add_help=False
)
parser.add_argument(
'action',
help='Action to perform. Available actions are: %s.' % actions,
nargs='?'
)
parser.add_argument(
'--config',
default='tipfy.cfg',
help='Configuration file. If not provided, uses tipfy.cfg from '
'the current directory.'
)
parser.add_argument(
'--app',
help='App configuration to use.'
)
parser.add_argument(
'-h', '--help',
help='Show this help message and exit.',
action='store_true'
)
return parser
def parse_config(self, config_file):
"""Load configuration. If files are not specified, try 'tipfy.cfg'
in the current dir.
"""
self.config_files = [
# Global configuration, saved in user dir.
path('~').expanduser().joinpath(GLOBAL_CONFIG_FILE).realpath(),
# Project configuration, saved in current or provided dir.
path(config_file).abspath().realpath(),
]
self.config = config.Config()
self.config_loaded = self.config.read(self.config_files)
def main():
manager = TipfyManager()
manager(sys.argv[1:])
if __name__ == '__main__':
main()
| adilhz/tipfy | manage/__init__.py | Python | bsd-3-clause | 20,992 |
from flask_testing import TestCase
from project import create_app, logger, db
import os
import logging
app = create_app()
class BaseTestCase(TestCase):
def create_app(self):
app.config.from_object('config.TestingConfig')
logger.setLevel(logging.ERROR)
return app
def setUp(self):
db.session.remove()
db.drop_all()
db.create_all()
def tearDown(self):
db.session.remove()
db.drop_all()
| Radu-Raicea/Stock-Analyzer | flask/tests/base_database_test.py | Python | bsd-3-clause | 467 |
# -*- coding: utf-8 -*-
#
# This file is part of CERN Document Server.
# Copyright (C) 2016 CERN.
#
# Invenio 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.
#
# Invenio 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 Invenio; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
# MA 02111-1307, USA.
#
# In applying this license, CERN does not
# waive the privileges and immunities granted to it by virtue of its status
# as an Intergovernmental Organization or submit itself to any jurisdiction.
"""CDS API to use Sorenson transcoding server."""
from __future__ import absolute_import, print_function
import os
from werkzeug.utils import cached_property
from . import config
class CDSSorenson(object):
"""CDS Sorenson extension."""
def __init__(self, app=None):
"""Extension initialization."""
if app:
self.app = app
self.init_app(app)
def init_app(self, app):
"""Flask application initialization."""
self.init_config(app)
app.extensions['cds-sorenson'] = self
def init_config(self, app):
"""Initialize configuration."""
for k in dir(config):
if k.startswith('CDS_SORENSON_'):
app.config.setdefault(k, getattr(config, k))
# Set the proxies
if (os.environ.get('APP_CDS_SORENSON_PROXIES_HTTP') and
os.environ.get('APP_CDS_SORENSON_PROXIES_HTTPS')):
app.config['CDS_SORENSON_PROXIES'] = {
'http': os.environ.get('APP_CDS_SORENSON_PROXIES_HTTP'),
'https': os.environ.get('APP_CDS_SORENSON_PROXIES_HTTPS')
}
@cached_property
def aspect_ratio_fractions(self):
"""Map aspect ratios with their computed fractions."""
fractions_with_ar = {}
for ar in self.app.config['CDS_SORENSON_PRESETS']:
sorenson_w, sorenson_h = ar.split(':')
sorenson_ar_fraction = float(sorenson_w) / float(sorenson_h)
fractions_with_ar.setdefault(sorenson_ar_fraction, ar)
return fractions_with_ar
| CERNDocumentServer/cds-sorenson | cds_sorenson/ext.py | Python | gpl-2.0 | 2,551 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*
# Supervisor process - reads config.yaml and checks services
# installation on Ubuntu
# sudo apt-get install python3-yaml
# sudo pip3 install paho-mqtt
#
# or (if running python 2.7):
# sudo apt-get install python-yaml
# sudo pip install paho-mqtt
# + backport of ipaddress to python 2.7:
# sudo apt-get install python-ipaddress
#
# If your user has trouble accessing paho-mqtt, execute the following commands:
# sudo find /usr/local/lib/python3.4/dist-packages/ -type d -exec chmod 755 {} ';'
# sudo find /usr/local/lib/python3.4/dist-packages/ -type f -exec chmod 644 {} ';'
import logging
import services
import sched
import time
import sys
import yaml
import paho.mqtt.client as paho
logging.basicConfig(level=logging.INFO)
# read yaml configuration
def read_configuration(file='config.yaml'):
logging.info("Opening config file " + file)
with open(file, 'r') as myfile:
data = myfile.read()
return yaml.load(data)
try:
config = read_configuration()
except Exception as e:
print("Could not read configuration: " + str(e))
sys.exit(1)
# open mqtt client
client = paho.Client()
# set user/password
if config['mqtt_broker']['use_username_password']:
client.username_pw_set(config['mqtt_broker']['username'], config['mqtt_broker']['password'])
# set tls
if config['mqtt_broker']['use_ca']:
client.tls_set(config['mqtt_broker']['ca_cert'])
client.tls_insecure_set(config['mqtt_broker']['ca_insecure'])
# connect
try:
client.connect(config['mqtt_broker']['hostname'], config['mqtt_broker']['port'], config['mqtt_broker']['keepalive'])
logging.info("Connected to broker " + config['mqtt_broker']['hostname'] + ":" + str(config['mqtt_broker']['port']))
except Exception as e:
print("Could not connect with mqtt broker: " + str(e))
sys.exit(1)
# add client to config
config['settings']['mqtt_client'] = client
# define check function to run on scheduler
def check_service(service, sc):
logging.info("Running " + service.name)
service.execute()
# re-enter service
sc.enter(service.check_frequency, 1, check_service, (service, sc,))
# initialize scheduler
s = sched.scheduler(time.time, time.sleep)
# get services and add them to scheduler
for key, service_config in config['services'].items():
service = services.service_factory(service_config['type'], key, service_config, config['settings'])
# add to scheduler
s.enter(0, 1, check_service, (service, s,))
# run scheduler
s.run()
| mkalus/mqtt-supervisor | mqtt_supervisor.py | Python | mit | 2,529 |
import traceback
class DbUtils(object):
#FIXME change to plugin style and read query from custom config files
db = None
db_conn = None
def __init__(self, db):
self.db = db
def __del__(self):
# dtor
if self.db_conn:
self.db_conn.close()
def connect(self):
db = self.db
protocol = db['protocol']
if protocol.find('mysql') == -1:
print('Do not support database other than mysql at the moment')
return False
dblib = None
try:
import MySQLdb as dblib
except:
pass
if not dblib:
print('No MySQL library installed for python')
return False
try:
self.db_conn = dblib.connect(host=db['host'], port=int(db['port']),
user=db['username'], passwd=db['password'],
db=db['dbname'])
except:
print('Failed to open connection to db {} using user {}'.format(db['host'], db['username']))
#print traceback.print_exc()
return False
return True
def query(self, sql):
if not self.db_conn:
print('Can\'t query until connection is established.')
return False
try:
cur = self.db_conn.cursor()
except:
print('Failed to create connection cursor.')
#print traceback.print_exc()
return False
try:
cur.execute(sql)
except:
cur.close()
print('Failed to execute SQL command.')
#print traceback.print_exc()
return False
cur.close()
return True | hsrky/pythoninfo | pythoninfo/lib/db_utils.py | Python | mit | 1,831 |
#!/usr/bin/python3
#coding=utf-8
'''
**************************
* File Name :base_line.py
* Author:Charlley88
* Mail:[email protected]
**************************
'''
import sys
sys.path.append('..')
import insummer
from insummer.query_expansion.entity_finder import NgramEntityFinder
from insummer.summarization.lexrank import LexRank
from insummer.summarization.textrank import TextRank
finder = NgramEntityFinder
import pickle
import data
import logging
from optparse import OptionParser
def exp(questions,qnum,method):
for i in range(qnum):
print('问题 : %s'%(i))
q = questions[i]
lexer = LexRank(q,250)
result = lexer.extract()
lexer.evaluation(result,'lex')
if __name__ == "__main__":
print(__doc__)
#parser = OptionParser()
#parser.add_option('-d','--data',dest='data',help='选择数据集')
#parser.add_option('-m','--method',dest='method',help='算法选择')
#(options,args) = parser.parse_args()
print('loading the data..')
duc_question = pickle.load(open('/home/lavi/project/insummer/question_data/duc_question.pkl','rb'))
#method = options.method
exp(duc_question,4,'lex')
| lavizhao/insummer | code/exp/base_line.py | Python | mit | 1,195 |
# -*- coding: utf-8 -*-
import pytest
import mock
from itertools import combinations
from biseqt.sequence import Alphabet
from biseqt.stochastics import rand_seq, MutationProcess, rand_read
from biseqt.stochastics import np # to mock
def test_rand_seq():
_bak = np.random.choice
np.random.choice = mock.Mock(return_value=[0, 0, 0])
A = Alphabet('ACGT')
assert rand_seq(A, 10) == A.parse('AAA')
np.random.choice = _bak
def test_expected_coverage():
A = Alphabet('ACGT')
S = rand_seq(A, 100)
cov = 10
reads = [r for r in rand_read(S, len_mean=len(S)/2, expected_coverage=cov)]
assert len(reads) == 2 * cov
def test_lossless_reads():
A = Alphabet('ACGT')
S = rand_seq(A, 100)
with pytest.raises(AssertionError):
next(rand_read(S, len_mean=200, num=1)) # len_mean must be < len(S)
with pytest.raises(AssertionError):
# at most one of num or expected_coverage given
next(rand_read(S, len_mean=50, num=1, expected_coverage=1))
assert sum(1 for _ in rand_read(S, len_mean=50, num=10)) == 10, \
'The number of sampled reads should be controllable'
assert sum(1 for _ in rand_read(S, len_mean=50)) == 1, \
'If neither num or expected coverage is given only one sample is read'
# there should be no noise added
read, pos = next(rand_read(S, len_mean=40, num=1))
assert S[pos:pos+len(read)] == read
S = A.parse('ACT' * 100)
reads = [x for x in rand_read(S, len_mean=100, len_sd=0.01, num=100)]
assert set(len(read) for read, _ in reads) > 1, \
'Read lengths should be randomly chosen'
len_mean = sum(len(read) for read, _ in reads) / 100.
assert len_mean > 50 and len_mean < 150, \
'Normal distribution of read lengths works'
# index edge cases
A = Alphabet(['00', '01'])
S = A.parse('01' * 10)
_bak = np.random.normal
np.random.normal = mock.Mock(return_value=[1])
assert next(rand_read(S, len_mean=1, num=1))[0] == A.parse('01'), \
'sequences in alphabets with > 1 long letters can be sampled too'
np.random.normal = _bak
def test_lossy_reads():
A = Alphabet('ACGT')
S = A.parse('ACT' * 100)
gap_kw = {'go_prob': 0.2, 'ge_prob': 0.3}
M = MutationProcess(A, subst_probs=0.3, **gap_kw)
read, pos, tx = next(M.noisy_read(S, len_mean=50, num=1))
assert tx.count('S') > 0 and tx.count('I') + tx.count('D') > 0, \
'Random mutations should be performed to get lossy reads'
def test_mutation_process():
A = Alphabet('ACGT')
S = A.parse('ACT' * 100)
gap_kw = {'go_prob': 0, 'ge_prob': 0}
T, tx = MutationProcess(A, subst_probs=0, **gap_kw).mutate(S)
assert T == S and tx == 'MMM' * 100, \
'all mutation probabilities can be set to zero'
T, tx = MutationProcess(A, subst_probs=0.1, **gap_kw).mutate(S)
assert all(op in 'MS' for op in tx) and 'S' in tx, \
'there can be mutation processes with only substitutions'
T, tx = MutationProcess(A, subst_probs=0.01, **gap_kw).mutate(S)
assert tx.count('S') < 0.1 * len(S), 'substitution probabilities work'
with pytest.raises(AssertionError):
MutationProcess(A, go_prob=0.2, ge_prob=0.1) # go_prob <= ge_prob
gap_kw = {'go_prob': 0.05, 'ge_prob': 0.1}
T, tx = MutationProcess(A, subst_probs=0, **gap_kw).mutate(S)
indels = sum(1 for op in tx if op in 'ID')
assert indels > 0 and indels < 0.5 * len(S), 'gap probabilities work'
def test_log_odds_scores():
A = Alphabet('ACGT')
# linear gap model
P = MutationProcess(A, subst_probs=.1, ge_prob=.1, go_prob=.1)
subst_scores, (go_score, ge_score) = P.log_odds_scores()
assert go_score == 0. and ge_score < 0
match_pos = [(i, i) for i in range(len(A))]
mismatch_pos = [(i, j) for i, j in combinations(range(len(A)), 2)]
assert all(subst_scores[i][j] < 0 for i, j in mismatch_pos)
assert all(subst_scores[i][j] > 0 for i, j in match_pos)
# affine gap model
P = MutationProcess(A, subst_probs=.1, ge_prob=.2, go_prob=.1)
subst_scores, (go_score, ge_score) = P.log_odds_scores()
assert ge_score < 0
# do mismatch scores go down if subst probs are decreased?
P = MutationProcess(A, subst_probs=.01, ge_prob=.2, go_prob=.1)
new_subst_scores, _ = P.log_odds_scores()
assert new_subst_scores[0][1] < subst_scores[0][1], \
'mismatch scores become more negative with lower mismatch probs'
| amirkdv/biseqt | tests/test_stochastics.py | Python | bsd-3-clause | 4,450 |
from httprpc.client import Client
a = Client("http://127.0.0.1:8000", username='a', password='a')
print a.hello(a=1, b=1)
print a.demo.hello(a=1, b=1)
| ya790206/httprpc-python | client.py | Python | apache-2.0 | 152 |
from mxl import MXLFile
import fileinput
SEP = ','
COLUMNS = (
'time.upper',
'time.lower',
'key.fifths',
'maj.min',
'melody.staff.1',
'melody.staff.2',
'num.dynamic.changes',
'A',
'B',
'C',
'D',
'E',
'F',
'G',
'16th',
'eighth',
'half',
'quarter',
'whole'
)
if __name__ == '__main__':
print SEP.join(COLUMNS)
for line in fileinput.input():
mxlf = MXLFile(line.rstrip('\n'))
num_measures = len(mxlf.get_part(0).get_measures())
note_type_counts = mxlf.get_part(0).get_note_type_counts(staff_num=1)
note_pitch_counts = mxlf.get_part(0).get_note_pitch_counts(staff_num=1)
num_staffs = mxlf.get_part(0).get_num_staffs()
time_signature = mxlf.time_signature()
key_signature = mxlf.key_signature()
melody_staff_0 = mxlf.get_part(0).get_melody_stat(staff_num=1)
if num_staffs > 1:
melody_staff_1 = mxlf.get_part(0).get_melody_stat(staff_num=2)
else:
melody_staff_1 = -1
columns = (
time_signature[0],
time_signature[1],
key_signature[0],
key_signature[1],
melody_staff_0,
melody_staff_1,
len(list(mxlf.get_part(0).get_dynamic_changes())) / float(num_measures),
note_pitch_counts['A'] / float(num_measures),
note_pitch_counts['B'] / float(num_measures),
note_pitch_counts['C'] / float(num_measures),
note_pitch_counts['D'] / float(num_measures),
note_pitch_counts['E'] / float(num_measures),
note_pitch_counts['F'] / float(num_measures),
note_pitch_counts['G'] / float(num_measures),
note_type_counts['16th'] / float(num_measures),
note_type_counts['eighth'] / float(num_measures),
note_type_counts['half'] / float(num_measures),
note_type_counts['quarter'] / float(num_measures),
note_type_counts['whole'] / float(num_measures)
)
print SEP.join(map(str, columns))
| themichaellai/musicxml-stats | output.py | Python | mit | 2,098 |
'''
Kivy standard library imports
'''
import kivy
from kivy.config import Config
#kivy.config.Config.set('graphics','resizable', False) #config needs to be set before kivy.app is imported
Config.set('graphics', 'fullscreen', 'auto')
from kivy.app import App
from time import time
from os.path import dirname, join
from kivy.lang import Builder
from kivy.properties import NumericProperty,StringProperty,BooleanProperty
from kivy.properties import ListProperty,ReferenceListProperty,ObjectProperty
from kivy.animation import Animation
from kivy.uix.screenmanager import Screen
from kivy.core.window import Window
from kivy.uix.widget import Widget
from kivy.uix.bubble import Bubble
from kivy.uix.gridlayout import GridLayout
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.label import Label
from kivy.uix.popup import Popup
from kivy.uix.button import Button
from kivy.uix.rst import RstDocument
from kivy.clock import Clock, mainthread
from kivy.uix.videoplayer import VideoPlayer
'''
Project imports
'''
from data.DatabaseThread import *
from data.StepperControl import *
from data.ServoControl import *
from data.libs.MyKnob import *
from data.libs.garden.mapview import *
| LBCC-SpaceClub/HAB2017 | AntennaTracker/data/libs/Dependencies.py | Python | mit | 1,235 |
import logging
import markdown
from flask import Markup
from flask import render_template
from sqlalchemy import text, column
from pajbot.managers.db import DBManager
from pajbot.models.user import User
from pajbot.models.webcontent import WebContent
from pajbot.modules import ChattersRefreshModule
log = logging.getLogger(__name__)
def init(app):
@app.route("/points")
def points():
with DBManager.create_session_scope() as db_session:
custom_web_content = db_session.query(WebContent).filter_by(page="points").first()
custom_content = ""
if custom_web_content and custom_web_content.content:
try:
custom_content = Markup(markdown.markdown(custom_web_content.content))
except:
log.exception("Unhandled exception in def index")
# rankings is a list of (User, int) tuples (user with their rank)
# note on the efficiency of this query: takes approx. 0.3-0.4 milliseconds on a 5 million user DB
#
# pajbot=# EXPLAIN ANALYZE SELECT * FROM (SELECT *, rank() OVER (ORDER BY points DESC) AS rank FROM "user") AS subquery LIMIT 30;
# QUERY PLAN
# ----------------------------------------------------------------------------------------------------------------------------------------------------------
# Limit (cost=0.43..2.03 rows=30 width=49) (actual time=0.020..0.069 rows=30 loops=1)
# -> WindowAgg (cost=0.43..181912.19 rows=4197554 width=49) (actual time=0.020..0.065 rows=30 loops=1)
# -> Index Scan Backward using user_points_idx on "user" (cost=0.43..118948.88 rows=4197554 width=41) (actual time=0.012..0.037 rows=31 loops=1)
# Planning Time: 0.080 ms
# Execution Time: 0.089 ms
#
# (see also the extensive comment on migration revision ID 2, 0002_create_index_on_user_points.py)
rankings = db_session.query(User, column("rank")).from_statement(
text(
'SELECT * FROM (SELECT *, rank() OVER (ORDER BY points DESC) AS rank FROM "user") AS subquery LIMIT 30'
)
)
chatters_refresh_enabled = ChattersRefreshModule.is_enabled()
chatters_refresh_settings = ChattersRefreshModule.module_settings()
chatters_refresh_interval = ChattersRefreshModule.UPDATE_INTERVAL
return render_template(
"points.html",
top_30_users=rankings,
custom_content=custom_content,
chatters_refresh_enabled=chatters_refresh_enabled,
chatters_refresh_settings=chatters_refresh_settings,
chatters_refresh_interval=chatters_refresh_interval,
)
| pajlada/pajbot | pajbot/web/routes/base/points.py | Python | mit | 2,923 |
#!/usr/bin/env python
a = [5, 3, 6, 4, 1, 2, 0, 8, 9]
class Node(object):
def __init__(self, value, left, right):
self.value, self.left, self.right = value, left, right
def __repr__(self):
return str(self.value)
class BTree(object):
def __init__(self, value):
self.root_node = Node(value, None, None)
def add_node(self, value):
cur_node = self.root_node
new_node = Node(value, None, None)
while True:
if cur_node.value > new_node.value: # Insert left side
if cur_node.left:
cur_node = cur_node.left
continue
else:
cur_node.left = new_node
return
elif cur_node.value < new_node.value: # Insert right side
if cur_node.right:
cur_node = cur_node.right
continue
else:
cur_node.right = new_node
return
break # Same us current node do nothing
def find_depth(self, cur_node=None, depth=0):
if cur_node is None:
cur_node = self.root_node
depth1 = depth2 = depth
if cur_node.left:
depth1 = self.find_depth(cur_node.left, depth + 1)
if cur_node.right:
depth2 = self.find_depth(cur_node.right, depth + 1)
depth = depth1
if depth1 < depth2:
depth = depth2
return depth
def print_nodes(self, cur_node=None, print_array=None, cur_depth=0):
is_root_node = False
if cur_depth == 0:
is_root_node = True
cur_node = cur_node if cur_node else self.root_node
total_depth = self.find_depth(cur_node)
print_array = [[] for i in range(total_depth + 2)]
print_array[cur_depth].append(str(cur_node.value))
if cur_node.left:
self.print_nodes(cur_node.left, print_array, cur_depth + 1)
else:
print_array[cur_depth + 1].append(' ')
if cur_node.right:
self.print_nodes(cur_node.right, print_array, cur_depth + 1)
else:
print_array[cur_depth + 1].append(' ')
if is_root_node:
for i in range(len(print_array)):
print '{}{}'.format(''.join(' ' * (total_depth - i + 1)),
' '.join(print_array[i]))
def find_node(self, value, cur_node=None):
if cur_node is None:
cur_node = self.root_node
if cur_node.value == value:
return cur_node
elif cur_node.value > value:
return self.find_node(value, cur_node.left)
else:
return self.find_node(value, cur_node.right)
def del_node(self, del_value, cur_node=None):
# Find node and parent node
if cur_node is None:
cur_node = self.root_node
parent_node = None
while True:
if cur_node.value == del_value:
break
elif cur_node.value > del_value and cur_node.left is not None:
parent_node = cur_node
cur_node = cur_node.left
continue
elif cur_node.value < del_value and cur_node.right is not None:
parent_node = cur_node
cur_node = cur_node.right
continue
return # Did not find node
if cur_node.left is None or cur_node.right is None:
replacement_node = cur_node.left if cur_node.left else \
cur_node.right
else:
replacement_node = cur_node.left
replacement_node_parent = cur_node
while replacement_node.right:
replacement_node_parent = replacement_node
replacement_node = replacement_node.right
replacement_node_parent.right = None
replacement_node.left = cur_node.left
replacement_node.right = cur_node.right
if parent_node:
if parent_node.left == cur_node:
parent_node.left = replacement_node
else:
parent_node.right = replacement_node
return
else:
self.root_node = replacement_node
if __name__ == '__main__':
btree = BTree(a[0])
for i in a[1:]:
btree.add_node(i)
print a
btree.print_nodes()
found_node = btree.find_node(3)
btree.print_nodes(cur_node=found_node)
btree.del_node(5)
btree.print_nodes()
| Ramyak/CodingPractice | algo_practice/sort/binary_search.py | Python | gpl-2.0 | 4,558 |
import unittest
import src.vector_gen.generateWeatherVectors as gwv
import pandas as pd
from test import test_path as path
class GenerateWeatherVectorsTest(unittest.TestCase):
trajectories_df = None
weather_df = None
def setUp(self):
self.trajectories_df = pd.read_csv(path.trajectories_training_file2)
self.weather_df = pd.read_csv(path.weather_training_file)
def test_get_simple_result(self):
X = gwv.generate_TimeInformationCurrentSituationWeatherVectors(self.trajectories_df, self.weather_df)
self.assertIsNotNone(X)
def test_length_of_timeIimeInformationCurrentSituationWeatherVector_X(self):
X = gwv.generate_TimeInformationCurrentSituationWeatherVectors(self.trajectories_df, self.weather_df)
# 91 days of training data, 12*2hours per day(
number = 7*12
self.assertEqual(len(X), number)
if __name__ == '__main__':
unittest.main()
| Superchicken1/SambaFlow | python/traffic-prediction/test/test_generateWeatherVectors.py | Python | apache-2.0 | 935 |
# =============================================================================
# COPYRIGHT 2013 Brain Corporation.
# License under MIT license (see LICENSE file)
# =============================================================================
import logging
import os
import platform
from utility import run_shell, cp, fix_rpath, safe_remove
from requirement import RequirementException
import shutil
import subprocess
def install(robustus, requirement_specifier, rob_file, ignore_index):
ni_install_dir = os.path.join(robustus.cache, 'OpenNI2')
if requirement_specifier.version is not None:
ni_install_dir += requirement_specifier.version
def in_cache():
return os.path.isfile(os.path.join(ni_install_dir, 'libOpenNI2.so'))
if not in_cache() and not ignore_index:
cwd = os.getcwd()
ni_clone_dir = os.path.join(cwd, 'OpenNI2')
try:
if os.path.isdir(ni_clone_dir):
logging.warn('Directory for cloning OpenNI found, cloning skipped')
else:
logging.info('Cloning OpenNI')
retcode = run_shell(['git', 'clone', 'https://github.com/occipital/OpenNI2.git'])
if retcode != 0:
raise RequirementException('OpenNI2 clone failed')
os.chdir(ni_clone_dir)
# checkout requested version
branch = requirement_specifier.version if requirement_specifier.version is not None else 'master'
if requirement_specifier.version is not None:
retcode = run_shell(['git', 'checkout', branch])
if retcode != 0:
raise RequirementException('OpenNI2 checkout failed')
logging.info('Building OpenNI')
if platform.machine().startswith('arm'):
ver = 'Arm'
# patch flags for arm
file_to_patch = os.path.join(ni_clone_dir, 'ThirdParty/PSCommon/BuildSystem/Platform.Arm')
with open(file_to_patch, "rt") as f:
content = f.read()
with open(file_to_patch, "wt") as f:
f.write(content.replace('-mfloat-abi=softfp', ''))
elif platform.architecture()[0].startswith('64'):
ver = 'x64'
else:
ver = 'x86'
retcode = run_shell(['make', 'PLATFORM=' + ver], verbose=robustus.settings['verbosity'] >= 1)
if retcode != 0:
raise RequirementException('OpenNI2 build failed')
# copy release dir and usb rules to wheelhouse
if os.path.isdir(ni_install_dir):
shutil.rmtree(ni_install_dir)
release_dir = os.path.join(ni_clone_dir, 'Bin', ver + '-Release')
shutil.copytree(release_dir, ni_install_dir)
cp(os.path.join(ni_clone_dir, 'Packaging/Linux/primesense-usb.rules'), ni_install_dir)
finally:
os.chdir(cwd)
safe_remove(ni_clone_dir)
# copy files to venv
if in_cache():
logging.info('Copying OpenNI2 to virtualenv')
cp(os.path.join(ni_install_dir, '*.so'), os.path.join(robustus.env, 'lib'))
cp(os.path.join(ni_install_dir, '*.jar'), os.path.join(robustus.env, 'lib'))
ni_drivers_dir = os.path.join(robustus.env, 'lib/OpenNI2')
if os.path.isdir(ni_drivers_dir):
shutil.rmtree(ni_drivers_dir)
shutil.copytree(os.path.join(ni_install_dir, 'OpenNI2'), ni_drivers_dir)
# copy demo for testing purposes
cp(os.path.join(ni_install_dir, 'SimpleRead'), os.path.join(robustus.env, 'bin'))
fix_rpath(robustus, robustus.env, os.path.join(robustus.env, 'bin/SimpleRead'), os.path.join(robustus.env, 'lib'))
# setup usb rules
logging.info('Configuring udev rules, you may need to reconnect sensor or restart computer')
retcode = run_shell(['sudo', 'cp', os.path.join(ni_install_dir, 'primesense-usb.rules'), '/etc/udev/rules.d/557-primesense-usb.rules'], verbose=robustus.settings['verbosity'] >= 1)
if retcode != 0:
raise RequirementException('Faied to copy udev rules')
# return nonzero code, but seems to work
subprocess.call(['sudo', 'udevadm', 'control', '--reload-rules'])
else:
raise RequirementException('can\'t find OpenNI2-%s in robustus cache' % requirement_specifier.version)
| braincorp/robustus | robustus/detail/install_openni.py | Python | mit | 4,406 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# This tool helps you to rebase package to the latest version
# Copyright (C) 2013-2014 Red Hat, Inc.
#
# 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
# he 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.
#
# Authors: Petr Hracek <[email protected]>
# Tomas Hozza <[email protected]>
from __future__ import print_function
import subprocess
import os
from rebasehelper.version import VERSION
try:
from setuptools import setup, Command
except:
from distutils.core import setup, Command
class PyTest(Command):
user_options = [('test-runner=',
't',
'test runner to use; by default, multiple py.test runners are tried')]
command_consumes_arguments = True
def initialize_options(self):
self.test_runner = None
self.args = []
def finalize_options(self):
pass
def runner_exists(self, runner):
syspaths = os.getenv('PATH').split(os.pathsep)
for p in syspaths:
if os.path.exists(os.path.join(p, runner)):
return True
return False
def run(self):
# only one test runner => just run the tests
supported = ['2.7', '3.3', '3.4']
potential_runners = ['py.test-' + s for s in supported]
if self.test_runner:
potential_runners = [self.test_runner]
runners = [pr for pr in potential_runners if self.runner_exists(pr)]
if not runners:
raise SystemExit('No test runners available!')
retcode = 0
for runner in runners:
if len(runners) > 1:
print('\n' * 2)
print('Running tests using "{0}":'.format(runner))
cmd = [runner]
for a in self.args:
cmd.append(a)
cmd.append('-v')
cmd.append('test')
t = subprocess.Popen(cmd)
rc = t.wait()
retcode = t.returncode or retcode
raise SystemExit(retcode)
setup(
name='rebasehelper',
version=VERSION,
description='RebaseHelper helps you to rebase your packages.',
keywords='packages,easy,quick',
author='Petr Hracek',
author_email='[email protected]',
url='https://github.com/phracek/rebase-helper',
license='GPLv2+',
packages=['rebasehelper'],
include_package_data=True,
entry_points={'console_scripts': ['rebase-helper=rebasehelper.cli:CliHelper.run']},
setup_requires=[],
classifiers=['Development Status :: 4 - Beta',
'Environment :: Console',
'Intended Audience :: Developers',
'License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)',
'Operating System :: POSIX :: Linux',
'Programming Language :: Python',
'Topic :: Software Development',
],
cmdclass={'test': PyTest}
)
| uhliarik/rebase-helper | setup.py | Python | gpl-2.0 | 3,564 |
# Python3
def allLongestStrings(inputArray):
maxLen = max(len(s) for s in inputArray)
return [ s for s in inputArray if len(s) == maxLen ]
| RevansChen/online-judge | Codefights/arcade/intro/level-3/9.All-Longest-Strings/Python/solution1.py | Python | mit | 148 |
# -*- coding: utf-8 -*-
"""
Copyright 2014 Telefonica Investigación y Desarrollo, S.A.U
This file is part of fiware-pep-steelskin
fiware-pep-steelskin 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.
fiware-pep-steelskin 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 fiware-pep-steelskin.
If not, see http://www.gnu.org/licenses/.
For those usages not covered by the GNU Affero General Public License
please contact with::[[email protected]]
"""
__author__ = 'Jon Calderin Goñi <[email protected]>'
from fabric.api import run, env, cd, put, sudo, local, output
import os
import platform
from lettuce import world
def set_variables_config(host_proxied_ip, host_proxied_port, port_listening,
ac_port, ac_ip,
pep_user, pep_password, pep_domain,
ks_ip, ks_port,
log_level,
plug_in, plug_in_extract_action,
bypass_activation='false', bypass_id='',
cache_users='1000', cache_projects='1000', cache_roles='60', administration_port='11211', ac_disable='false', ks_check_headers='true'):
"""
Modify the variables in the PEP config_template file and write the final values in a PEP config file.
:param host_proxied_ip:
:param host_proxied_port:
:param port_listening:
:param ac_port:
:param ac_ip:
:param pep_user:
:param pep_password:
:param pep_domain:
:param ks_ip:
:param ks_port:
:param log_level:
:param plug_in:
:param plug_in_extract_action:
:param bypass_activation:
:param bypass_id:
:param cache_users:
:param cache_projects:
:param cache_roles:
:param administration_port:
:return:
"""
world.log.info('Setting the pep config')
replaces = {
'host_proxied_ip': host_proxied_ip,
'host_proxied_port': host_proxied_port,
'port_listening': port_listening,
'ac_ip': ac_ip,
'ac_port': ac_port,
'ac_disable': ac_disable,
'pep_user': pep_user,
'pep_password': pep_password,
'pep_domain': pep_domain,
'ks_check_headers': ks_check_headers,
'ks_ip': ks_ip,
'ks_port': ks_port,
'log_level': log_level,
'plug_in': plug_in,
'plug_in_extract_action': plug_in_extract_action,
'bypass_activation': bypass_activation,
'bypass_id': bypass_id,
'cache_users': cache_users,
'cache_projects': cache_projects,
'cache_roles': cache_roles,
'administration_port': administration_port
}
path, fl = os.path.split(os.path.realpath(__file__))
if platform.system() == 'Windows':
path += '\\resources\\'
elif platform.system() == 'Linux':
path += '/resources/'
else:
raise NameError('The SO is not recognize, set the config manually')
full_path_template = path + 'config_template.js'
full_path_config = path + 'config.js'
template = open(full_path_template)
config = open(full_path_config, 'w+')
# Check in each line if there is a variable to modify
for line in template.readlines():
for replace in replaces:
string_to_replace = '{{%s}}' % replace
if line.find(string_to_replace) >= 0:
line = line.replace(string_to_replace, replaces[replace])
config.write(line)
template.close()
config.close()
def get_ssh_port(container_name):
"""
Given the name of a container, get the ssh port
:param container_name:
:return:
"""
world.log.info('Getting ssh port of the container')
ret = run('docker port {container_name} 22'.format(container_name=container_name))
return ret.split(':')[1]
def start_docker_pep(ip_host, user_host, password_host, container_user, container_pass, container_name,
pep_path='/fiware-pep-steelskin'):
"""
Given the docker host, get the PEP container and start it with the config defined
:param ip_host:
:param user_host:
:param password_host:
:param container_user:
:param container_pass:
:param container_name:
:param pep_path:
:return:
"""
world.log.info('Starting pep in docker')
env.host_string = ip_host
env.user = user_host
env.password = password_host
output['stdout'] = False
output['running'] = False
output['warnings'] = False
container_port = get_ssh_port(container_name)
start_pep(ip_host, container_user, container_pass, container_port, pep_path)
def stop_docker_pep(ip_host, user_host, password_host, container_user, container_pass, container_name):
"""
Given the docker host, get the PEP container and stop it
:param ip_host:
:param user_host:
:param password_host:
:param container_user:
:param container_pass:
:param container_name:
:return:
"""
world.log.info('Stoping pep in docker')
env.host_string = ip_host
env.user = user_host
env.password = password_host
output['stdout'] = False
output['running'] = False
output['warnings'] = False
container_port = get_ssh_port(container_name)
stop_pep(ip_host, container_user, container_pass, container_port)
def start_pep(ip, user, password, port='22', pep_path='/fiware-pep-steelskin'):
"""
Given a ssh connection data, stop PEP if its running, put the new configuration, and start is.
The machina have to has the "dtach" package
:param ip:
:param user:
:param password:
:param port:
:param pep_path:
:return:
"""
world.log.info('Starting pep in remote')
env.host_string = ip + ':' + port
env.user = user
env.password = password
env.sudo_password = password
output['stdout'] = False
output['running'] = False
output['warnings'] = False
path, fl = os.path.split(os.path.realpath(__file__))
if platform.system() == 'Windows':
config = path + '\\resources\\' + 'config.js'
elif platform.system() == 'Linux':
config = path + '/resources/' + 'config.js'
else:
raise NameError('The SO is not supported')
so = run('cat /etc/issue').split('\n')[0].split(' ')[0]
if so == 'CentOS':
pid = sudo('ps -ef | grep "node bin/pepProxy" | grep -v grep | awk \'{print $2}\'')
elif so == 'Ubuntu':
pid = sudo('ps -ef | grep "nodejs bin/pepProxy" | grep -v grep | awk \'{print $2}\'')
else:
raise NameError('Pep only can be started in Ubuntu and CentOS systems')
if pid != '':
for proc_pid in pid.split('\n'):
sudo('kill -9 {pid}'.format(pid=proc_pid.strip()))
with cd(pep_path):
put(config, '{path}/config.js'.format(path=pep_path))
sudo('mkdir -p {pep_tmp_dir}'.format(pep_tmp_dir=world.pep_tmp_dir))
if so == 'CentOS':
resp = sudo('dtach -n `mktemp -u {pep_tmp_dir}/dtach.XXXX` /bin/bash -c \' node bin/pepProxy >> {pep_tmp_dir}/pep.log\''.format(pep_tmp_dir=world.pep_tmp_dir))
elif so == 'Ubuntu':
resp =sudo('dtach -n `mktemp -u {pep_tmp_dir}/dtach.XXXX` /bin/bash -c \' nodejs bin/pepProxy >> {pep_tmp_dir}/pep.log\''.format(pep_tmp_dir=world.pep_tmp_dir))
else:
raise NameError('Pep only can be started in Ubuntu and CentOS systems')
world.log.debug('The response initializing pep in remote is: {resp}'.format(resp=resp))
def stop_pep(ip, user, password, port='22'):
"""
Stop pep process
:param ip:
:param user:
:param password:
:param port:
:return:
"""
world.log.info('Stoping pep in remote')
env.host_string = ip + ':' + port
env.user = user
env.password = password
env.sudo_password = password
output['stdout'] = False
output['running'] = False
output['warnings'] = False
so = run('cat /etc/issue').split('\n')[0].split(' ')[0]
if so == 'CentOS':
pid = sudo('ps -ef | grep "node bin/pepProxy" | grep -v grep | awk \'{print $2}\'')
elif so == 'Ubuntu':
pid = sudo('ps -ef | grep "nodejs bin/pepProxy" | grep -v grep | awk \'{print $2}\'')
else:
raise NameError('Pep only can be started in Ubuntu and CentOS systems')
if pid != '':
for proc_pid in pid.split('\n'):
sudo('kill -9 {pid}'.format(pid=proc_pid.strip()))
def start_pep_local(pep_path='/fiware-pep-steelskin'):
"""
Given a ssh connection data, stop PEP if its running, put the new configuration, and start is.
The machine has to have the "dtach" package
:param pep_path:
:return:
"""
world.log.info('Starting pep in local')
output['stdout'] = False
output['running'] = False
output['warnings'] = False
path, fl = os.path.split(os.path.realpath(__file__))
if platform.system() == 'Windows':
config = path + '\\resources\\' + 'config.js'
elif platform.system() == 'Linux':
config = path + '/resources/' + 'config.js'
else:
raise NameError('The SO is not supported')
so = local('cat /etc/issue', capture=True).split('\n')[0].split(' ')[0]
if so == 'CentOS':
pid = local('ps -ef | grep "node bin/pepProxy" | grep -v grep | awk \'{print $2}\'', capture=True)
elif so == 'Ubuntu':
pid = local('ps -ef | grep "nodejs bin/pepProxy" | grep -v grep | awk \'{print $2}\'', capture=True)
else:
raise NameError('Pep only can be started in Ubuntu and CentOS systems')
if pid != '':
for proc_pid in pid.split('\n'):
local('kill -9 {pid}'.format(pid=proc_pid.strip()), capture=True)
local('cp {config} {path}/config.js'.format(config=config, path=pep_path), capture=True)
local('mkdir -p {pep_tmp_dir}'.format(pep_tmp_dir=world.pep_tmp_dir))
if so == 'CentOS':
resp = local('dtach -n `mktemp -u {pep_tmp_dir}/dtach.XXXX` /bin/bash -c \' cd {path} && node bin/pepProxy >> {pep_tmp_dir}/pep.log\''.format(path=pep_path, pep_tmp_dir=world.pep_tmp_dir), capture=True)
elif so == 'Ubuntu':
resp = local('dtach -n `mktemp -u {pep_tmp_dir}/dtach.XXXX` /bin/bash -c \' cd {path} && nodejs bin/pepProxy >> {pep_tmp_dir}/pep.log\''.format(path=pep_path, pep_tmp_dir=world.pep_tmp_dir), capture=True)
else:
raise NameError('Pep only can be started in Ubuntu and CentOS systems')
world.log.debug('The response initializing pep in local is: {resp}'.format(resp=resp))
def stop_local_pep():
"""
Stop pep process
:return:
"""
world.log.info('Stoping pep in local')
output['stdout'] = False
output['running'] = False
output['warnings'] = False
so = local('cat /etc/issue', capture=True).split('\n')[0].split(' ')[0]
if so == 'CentOS':
pid = local('ps -ef | grep "node bin/pepProxy" | grep -v grep | awk \'{print $2}\'', capture=True)
elif so == 'Ubuntu':
pid = local('ps -ef | grep "nodejs bin/pepProxy" | grep -v grep | awk \'{print $2}\'', capture=True)
else:
raise NameError('Pep only can be started in Ubuntu and CentOS systems')
if pid != '':
for proc_pid in pid.split('\n'):
local('kill -9 {pid}'.format(pid=proc_pid.strip()), capture=True)
| agroknow/fiware-pep-steelskin | test/acceptance/tools/deploy_pep.py | Python | agpl-3.0 | 11,656 |
#!/usr/bin/env python
# -*- coding:utf8 -*-
from __future__ import print_function
import sys
from os.path import dirname, abspath
import nose
def run_all(argv=None):
sys.exitfunc = lambda: sys.stderr.write('Shutting down....\n')
# always insert coverage when running tests
if argv is None:
argv = [
'nosetests', '--with-xunit',
'--with-xcoverage', '--cover-package=nos',
'--cover-erase', '--cover-branches',
'--logging-filter=nos', '--logging-level=DEBUG',
'--verbose'
]
nose.run_exit(
argv=argv,
defaultTest=abspath(dirname(__file__))
)
if __name__ == '__main__':
run_all(sys.argv)
| NetEase-Object-Storage/nos-python-sdk | test_nos/run_tests.py | Python | mit | 707 |
#!/usr/bin/env python
#coding:utf-8
# Purpose: cell spanning controller
# Created: 13.02.2011
# Copyright (C) 2011, Manfred Moitzi
# License: MIT license
from __future__ import unicode_literals, print_function, division
__author__ = "mozman <[email protected]>"
from .xmlns import wrap
from .tableutils import iter_cell_range, iter_cell_range_without_start_pos
class CellSpanController(object):
# is not a public class
# public access only by Table or similar classes
# all cell references has to be 2-tuples!
def __init__(self, row_controller):
self._row_controller = row_controller
def _get_cell(self, pos):
return wrap(self._row_controller.get_cell(pos))
def is_cell_spanning(self, pos):
return self._get_cell(pos).span != (1, 1)
def set_span(self, pos, size):
self._check_pos_and_size(pos, size)
if self._has_cell_range_spanned_cells(pos, size):
raise ValueError("cell range contains already spanned cells")
for cell_index in iter_cell_range_without_start_pos(pos, size):
self._cover_cell(cell_index)
self._set_span_attributes(pos, size)
def _check_pos_and_size(self, pos, size):
start_row, start_column = pos
if start_row < 0 or start_column < 0:
raise IndexError("invalid start pos: %s" % tostr(pos))
nrows, ncols = size
if nrows < 1 or ncols < 1:
raise ValueError("invalid size parameter: %s" % tostr(size))
if start_row + nrows > self._row_controller.nrows() or \
start_column + ncols > self._row_controller.ncols():
raise ValueError("cell range exceeds table limits")
def _has_cell_range_spanned_cells(self, pos, size):
for cell_index in iter_cell_range(pos, size):
if self.is_cell_spanning(cell_index):
return True
return False
def _cover_cell(self, pos):
cell = self._get_cell(pos)
if not cell.covered:
cell._set_covered(True)
def _uncover_cell(self, pos):
cell = self._get_cell(pos)
if cell.covered:
cell._set_covered(False)
def _set_span_attributes(self, pos, size):
cell = self._get_cell(pos)
cell._set_span(size)
self._uncover_cell(pos)
def remove_span(self, pos):
if not self.is_cell_spanning(pos):
return # should it raise an error?
size = self._get_cell(pos).span
for cell_index in iter_cell_range(pos, size):
self._uncover_cell(cell_index)
self._remove_span_attributes(pos)
def _remove_span_attributes(self, pos):
cell = self._get_cell(pos)
cell._del_span_attributes()
self._uncover_cell(pos)
| chalbersma/btcaddrtocsv | ezodf/cellspancontroller.py | Python | lgpl-2.1 | 2,749 |
import logging
from xml.etree import ElementTree as etree
from xml.parsers import expat
try:
from oslo_serialization import jsonutils
except ImportError:
from oslo.serialization import jsonutils
from builtins import int
import six
from . import constants
from . import exceptions as exception
from ..i18n import _
LOG = logging.getLogger(__name__)
class ActionDispatcher(object):
def dispatch(self, *args, **kwargs):
action = kwargs.pop('action', 'default')
action_method = getattr(self, str(action), self.default)
return action_method(*args, **kwargs)
def default(self, data):
raise NotImplementedError()
class DictSerializer(ActionDispatcher):
def serialize(self, data, action='default'):
return self.dispatch(data, action=action)
def default(self, data):
return ""
class JSONDictSerializer(DictSerializer):
def default(self, data):
def sanitizer(obj):
return six.text_type(obj)
return jsonutils.dumps(data, default=sanitizer)
class XMLDictSerializer(DictSerializer):
def __init__(self, metadata=None, xmlns=None):
super(XMLDictSerializer, self).__init__()
self.metadata = metadata or {}
if not xmlns:
xmlns = self.metadata.get('xmlns')
if not xmlns:
xmlns = constants.XML_NS_V20
self.xmlns = xmlns
def default(self, data):
try:
links = None
has_atom = False
if data is None:
root_key = constants.VIRTUAL_ROOT_KEY
root_value = None
else:
link_keys = [k for k in six.iterkeys(data) or []
if k.endswith('_links')]
if link_keys:
links = data.pop(link_keys[0], None)
has_atom = True
root_key = (len(data) == 1 and
list(data.keys())[0] or constants.VIRTUAL_ROOT_KEY)
root_value = data.get(root_key, data)
doc = etree.Element("_temp_root")
used_prefixes = []
self._to_xml_node(doc, self.metadata, root_key,
root_value, used_prefixes)
if links:
self._create_link_nodes(list(doc)[0], links)
return self.to_xml_string(list(doc)[0], used_prefixes, has_atom)
except AttributeError as e:
LOG.exception(str(e))
return ''
def __call__(self, data):
return self.default(data)
def to_xml_string(self, node, used_prefixes, has_atom=False):
self._add_xmlns(node, used_prefixes, has_atom)
return etree.tostring(node, encoding='UTF-8')
def _add_xmlns(self, node, used_prefixes, has_atom=False):
node.set('xmlns', self.xmlns)
node.set(constants.TYPE_XMLNS, self.xmlns)
if has_atom:
node.set(constants.ATOM_XMLNS, constants.ATOM_NAMESPACE)
node.set(constants.XSI_NIL_ATTR, constants.XSI_NAMESPACE)
ext_ns = self.metadata.get(constants.EXT_NS, {})
for prefix in used_prefixes:
if prefix in ext_ns:
node.set('xmlns:' + prefix, ext_ns[prefix])
def _to_xml_node(self, parent, metadata, nodename, data, used_prefixes):
result = etree.SubElement(parent, nodename)
if ":" in nodename:
used_prefixes.append(nodename.split(":", 1)[0])
if isinstance(data, list):
if not data:
result.set(
constants.TYPE_ATTR,
constants.TYPE_LIST)
return result
singular = metadata.get('plurals', {}).get(nodename, None)
if singular is None:
if nodename.endswith('s'):
singular = nodename[:-1]
else:
singular = 'item'
for item in data:
self._to_xml_node(result, metadata, singular, item,
used_prefixes)
elif isinstance(data, dict):
if not data:
result.set(
constants.TYPE_ATTR,
constants.TYPE_DICT)
return result
attrs = metadata.get('attributes', {}).get(nodename, {})
for k, v in sorted(data.items()):
if k in attrs:
result.set(k, str(v))
else:
self._to_xml_node(result, metadata, k, v,
used_prefixes)
elif data is None:
result.set(constants.XSI_ATTR, 'true')
else:
if isinstance(data, bool):
result.set(
constants.TYPE_ATTR,
constants.TYPE_BOOL)
elif isinstance(data, int):
result.set(
constants.TYPE_ATTR,
constants.TYPE_INT)
elif isinstance(data, float):
result.set(
constants.TYPE_ATTR,
constants.TYPE_FLOAT)
LOG.debug("Data %(data)s type is %(type)s",
{'data': data,
'type': type(data)})
result.text = six.text_type(data)
return result
def _create_link_nodes(self, xml_doc, links):
for link in links:
link_node = etree.SubElement(xml_doc, 'atom:link')
link_node.set('rel', link['rel'])
link_node.set('href', link['href'])
class TextDeserializer(ActionDispatcher):
def deserialize(self, datastring, action='default'):
return self.dispatch(datastring, action=action)
def default(self, datastring):
return {}
class JSONDeserializer(TextDeserializer):
def _from_json(self, datastring):
try:
return jsonutils.loads(datastring)
except ValueError:
msg = _("Cannot understand JSON")
raise exception.MalformedResponseBody(reason=msg)
def default(self, datastring):
return {'body': self._from_json(datastring)}
class XMLDeserializer(TextDeserializer):
def __init__(self, metadata=None):
super(XMLDeserializer, self).__init__()
self.metadata = metadata or {}
xmlns = self.metadata.get('xmlns')
if not xmlns:
xmlns = constants.XML_NS_V20
self.xmlns = xmlns
def _get_key(self, tag):
tags = tag.split("}", 1)
if len(tags) == 2:
ns = tags[0][1:]
bare_tag = tags[1]
ext_ns = self.metadata.get(constants.EXT_NS, {})
if ns == self.xmlns:
return bare_tag
for prefix, _ns in ext_ns.items():
if ns == _ns:
return prefix + ":" + bare_tag
else:
return tag
def _get_links(self, root_tag, node):
link_nodes = node.findall(constants.ATOM_LINK_NOTATION)
root_tag = self._get_key(node.tag)
link_key = "%s_links" % root_tag
link_list = []
for link in link_nodes:
link_list.append({'rel': link.get('rel'),
'href': link.get('href')})
node.remove(link)
return link_list and {link_key: link_list} or {}
def _from_xml(self, datastring):
if datastring is None:
return None
plurals = set(self.metadata.get('plurals', {}))
try:
node = etree.fromstring(datastring)
root_tag = self._get_key(node.tag)
links = self._get_links(root_tag, node)
result = self._from_xml_node(node, plurals)
if root_tag == constants.VIRTUAL_ROOT_KEY:
return result
return dict({root_tag: result}, **links)
except Exception as e:
parseError = False
if (hasattr(etree, 'ParseError') and
isinstance(e, getattr(etree, 'ParseError'))):
parseError = True
elif isinstance(e, expat.ExpatError):
parseError = True
if parseError:
msg = _("Cannot understand XML")
raise exception.MalformedResponseBody(reason=msg)
else:
raise
def _from_xml_node(self, node, listnames):
attrNil = node.get(str(etree.QName(constants.XSI_NAMESPACE, "nil")))
attrType = node.get(str(etree.QName(
self.metadata.get('xmlns'), "type")))
if (attrNil and attrNil.lower() == 'true'):
return None
elif not len(node) and not node.text:
if (attrType and attrType == constants.TYPE_DICT):
return {}
elif (attrType and attrType == constants.TYPE_LIST):
return []
else:
return ''
elif (len(node) == 0 and node.text):
converters = {constants.TYPE_BOOL:
lambda x: x.lower() == 'true',
constants.TYPE_INT:
lambda x: int(x),
constants.TYPE_FLOAT:
lambda x: float(x)}
if attrType and attrType in converters:
return converters[attrType](node.text)
else:
return node.text
elif self._get_key(node.tag) in listnames:
return [self._from_xml_node(n, listnames) for n in node]
else:
result = dict()
for attr in node.keys():
if (attr == 'xmlns' or
attr.startswith('xmlns:') or
attr == constants.XSI_ATTR or
attr == constants.TYPE_ATTR):
continue
result[self._get_key(attr)] = node.get(attr)
children = list(node)
for child in children:
result[self._get_key(child.tag)] = self._from_xml_node(
child, listnames)
return result
def default(self, datastring):
return {'body': self._from_xml(datastring)}
def __call__(self, datastring):
return self.default(datastring)
class Serializer(object):
def __init__(self, metadata=None, default_xmlns=None):
self.metadata = metadata or {}
self.default_xmlns = default_xmlns
def _get_serialize_handler(self, content_type):
handlers = {
'application/json': JSONDictSerializer(),
'application/xml': XMLDictSerializer(self.metadata),
}
try:
return handlers[content_type]
except Exception:
raise exception.InvalidContentType(content_type=content_type)
def serialize(self, data, content_type):
return self._get_serialize_handler(content_type).serialize(data)
def deserialize(self, datastring, content_type):
return self.get_deserialize_handler(content_type).deserialize(
datastring)
def get_deserialize_handler(self, content_type):
handlers = {
'application/json': JSONDeserializer(),
'application/xml': XMLDeserializer(self.metadata),
}
try:
return handlers[content_type]
except Exception:
raise exception.InvalidContentType(content_type=content_type)
| nttcom/eclcli | eclcli/network/networkclient/common/serializer.py | Python | apache-2.0 | 11,379 |
"""Copyright (C) 2013 COLDWELL AG
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
import json
import gevent
from .models import Account, Profile, HosterAccount, PremiumAccount, Http, HttpAccount, HttpHosterAccount, HttpPremiumAccount, \
MultiAccount, HttpMultiAccount
from .manager import manager, log, config
from ..hoster.this import localctx
from ..scheme import transaction
from .. import db, interface, settings
from ..api import proto
from . import verify
def init():
# plugins are loaded by hoster.py
Account.localctx = localctx
with transaction, db.Cursor() as c:
aa = c.execute("SELECT * FROM account")
for a in aa.fetchall():
try:
name = json.loads(a['name'])
data = json.loads(a['data'])
data['id'] = int(a['id'])
a = manager.get_pool(name).add(**data)
except TypeError:
log.critical("broken row: {}".format(a))
c.execute("DELETE FROM account WHERE id={}".format(a["id"]))
except AttributeError:
log.critical("hoster account for {} not exists anymore".format(name))
@interface.register
class AccountInterface(interface.Interface):
name = "account"
def add(name=None, **kwargs):
"""adds a new account
generally the plugin name is needed: {name: 'plugin name'}
for default hoster plugins additional: {username: 'name', password: 'pass'}
for http profiles: {
host: 'hostname', port: port, username: 'user', password: 'pass',
auth_method: 'auth',
cookies: {key: value, key2: value2},
headers: {key: value, key2, value2}}
for ftp profiles: {
host: 'hostname', port: port, username: 'user', password: 'pass'}"""
account = manager.get_pool(name).add(**kwargs)
if account:
return account.id
def remove(id=None):
"""removes an account"""
with transaction:
try:
pool, account = manager.get_account_by_id(int(id))
except ValueError:
pass # account already deleted (not found)
else:
pool.remove(account)
def reset(id=None):
"""resets an account (logout and clear infos ...)"""
with transaction:
pool, account = manager.get_account_by_id(int(id))
account.reset()
def check(id=None):
"""rechecks an account (makes reset, than check)"""
with transaction:
pool, account = manager.get_account_by_id(int(id))
account.reset()
account.boot()
recheck = check
def modify(id=None, update=None):
"""modifies files. arguments are the same as on modify_package"""
pool, account = manager.get_account_by_id(int(id))
with transaction:
enabled = account.enabled
account.reset()
account.enabled = enabled
account.modify_table(update)
account.boot()
def sync(clients=None):
for name, pool in manager.iteritems():
for acc in pool:
if acc._private_account:
continue
data = acc.get_login_data()
if not data:
continue
data['name'] = name
data['enabled'] = acc.enabled
for client in clients:
if client == settings.app_uuid:
continue
proto.send('client', 'account.add', payload=data, channel=client)
def list_plugins():
"""lists all account plugins"""
return list(manager)
def set_secret(hoster=None, code=None, timeleft=None):
verify.set_secret(hoster, code, timeleft)
| MoroGasper/client | client/account/__init__.py | Python | gpl-3.0 | 4,393 |
# -*- coding: utf-8 -*-
"""Tools for visualizing ADCP data that is read and processed by the adcpy module
This module is imported under the main adcpy, and should be available as
adcpy.plot. Some methods can be used to visualize flat arrays, independent of
adcpy, and the plots may be created quickly using the IPanel and QPanel
classes.
This code is open source, and defined by the included MIT Copyright License
Designed for Python 2.7; NumPy 1.7; SciPy 0.11.0; Matplotlib 1.2.0
2014-09 - First Release; blsaenz, esatel
"""
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
import scipy.stats.stats as sp
from matplotlib.dates import num2date#,date2num,
import adcpy
from adcpy_recipes import calc_transect_flows_from_uniform_velocity_grid
U_str = 'u'
V_str = 'v'
W_str = 'w'
vel_strs = (U_str,V_str,W_str)
# Common formatting for datenums:
def fmt_dnum(dn):
return num2date(dn).strftime('%c')
class IPanel(object):
"""
This object stores and plots a 2D velocity map as an image. Any of the data
fields (kwarg_options) may be specificed as kwargs during initialization.
At minimum IPanel requires 'velocity' to be set.
"""
kwarg_options = ['use_pcolormesh',
'minv',
'maxv',
'velocity',
'title',
'units',
'xlabel',
'ylabel',
'x',
'y',
'chop_off_nans',
'x_is_mtime',
'arrow_color',
'xy_is_lonlat',
'interpolation',
'shading',
'my_axes']
def __init__(self,**kwargs):
# init everything to None
for kwarg in self.kwarg_options:
exec("self.%s = None"%kwarg)
# set defaults
self.minv = -0.25
self.maxv = 0.25
self.x_is_mtime = False
self.interpolation = 'nearest'
self.use_pcolormesh = False
self.shading = 'flat'
self.xy_is_lonlat = False
self.chop_off_nans = False
# read/save arguments
for kwarg in self.kwarg_options:
if kwarg in kwargs:
exec("self.%s = kwargs[kwarg]"%kwarg)
def plot(self,ax=None):
"""
Plots the data in IPanel onto the axis ax, or if ax is None,
onto self.my_axes.
Inputs:
ax = matplotlib axes object, or None
Returns:
Nothing
"""
# set desired axes
if ax is not None:
plt.sca(ax)
elif self.my_axes is not None:
ax = plt.sca(self.my_axes)
else:
ax = plt.gca()
if self.minv is not None:
mnv = ",vmin=self.minv"
else:
mnv = ""
if self.minv is not None:
mxv = ",vmax=self.maxv"
else:
mxv = ""
if self.use_pcolormesh:
vel_masked = np.ma.array(self.velocity,mask=np.isnan(self.velocity))
if self.x is not None and self.y is not None:
xy = "self.x,self.y,"
else:
xy = ""
plot_cmd = "pc=plt.pcolormesh(%svel_masked.T,shading=self.shading%s%s)"%(xy,mnv,mxv)
exec(plot_cmd)
else:
if self.x is not None and self.y is not None:
xy = ",extent=[self.x[0],self.x[-1],self.y[-1],self.y[0]]"
else:
xy = ""
plot_cmd = "pc=plt.imshow(self.velocity.T%s,interpolation=self.interpolation%s%s)"%(xy,mnv,mxv)
exec(plot_cmd)
if self.title is not None:
plt.title(self.title)
plt.axis('tight')
if self.chop_off_nans:
x_test = np.nansum(self.velocity,axis=1)
x_test = ~np.isnan(x_test)*np.arange(np.size(x_test))
if self.x is None:
plt.xlim([np.nanmin(x_test),np.nanmax(x_test)])
else:
plt.xlim([self.x[np.nanmin(x_test)],self.x[np.nanmax(x_test)]])
if self.x[-1] < self.x[0]:
plt.xlim(plt.xlim()[::-1])
y_test = np.nansum(self.velocity,axis=0)
y_test = ~np.isnan(y_test)*np.arange(np.size(y_test))
plt.ylim([np.nanmin(y_test),np.nanmax(y_test)])
if self.y is None:
plt.ylim([np.nanmin(y_test),np.nanmax(y_test)])
else:
plt.ylim([self.y[np.nanmin(y_test)],self.y[np.nanmax(y_test)]])
if self.y[-1] < self.y[0]:
plt.ylim(plt.ylim()[::-1])
if self.x_is_mtime:
ax.xaxis_date()
plt.gcf().autofmt_xdate()
elif self.xy_is_lonlat:
ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%7.4f'))
ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%7.4f'))
plt.ylabel('Latitude [degrees N]')
plt.xlabel('Longitude [degrees E]')
if self.xlabel is not None:
plt.xlabel(self.xlabel)
if self.ylabel is not None:
plt.ylabel(self.ylabel)
plt.colorbar(pc, use_gridspec=True)
class QPanel(object):
"""
This object stores and plots a 1D or 2D velocity map as a quiver plot. Any
of the data fields (kwarg_options) may be specificed as kwargs during
initialization. At minimum QPanel requires 'velocity' to be set.
"""
kwarg_options = ['u_vecs',
'v_vecs',
'velocity',
'title',
'units',
'xlabel',
'ylabel',
'x',
'y',
'v_scale', # make arrow bigger or smaller, relatively speaking, daults to 1
'xpand', # fractional buffer around xy extent, to capture arrow ends
'x_is_mtime',
'arrow_color',
'xy_is_lonlat',
'equal_axes',
'my_axes']
def __init__(self,**kwargs):
# init everything to None
for kwarg in self.kwarg_options:
exec("self.%s = None"%kwarg)
# set defaults
self.u_vecs = 50
self.v_vecs = 50
self.x_is_mtime = False
self.xy_is_lonlat = False
self.arrow_color = 'k'
self.v_scale = 1.0
self.xpand = 0.33
self.equal_axes = False
# read/save arguments
for kwarg in self.kwarg_options:
if kwarg in kwargs:
exec("self.%s = kwargs[kwarg]"%kwarg)
def plot(self,ax=None):
"""
Plots the data in QPanel onto the axis ax, or if ax is None,
onto self.my_axes.
Inputs:
ax = matplotlib axes object, or None
Returns:
Nothing
"""
# set desired axes
if ax is not None:
plt.sca(ax)
elif self.my_axes is not None:
ax = plt.sca(self.my_axes)
else:
ax = plt.gca()
dims = np.shape(self.velocity)
u_reduction = max(1,int(dims[0]/self.u_vecs))
u_indices = np.arange(0,dims[0],u_reduction)
v_mag = np.sqrt(self.velocity[...,0]**2 + self.velocity[...,1]**2)
if len(dims) == 2:
vScale = np.nanmax(v_mag[u_indices])
local_vel = self.velocity[u_indices,...]
local_u = local_vel[:,0]
local_v = local_vel[:,1]
local_x = self.x[u_indices]
local_y = self.y[u_indices]
elif len(dims) == 3:
v_reduction = max(1,int(dims[1]/self.v_vecs))
v_indices = np.arange(0,dims[1],v_reduction)
v_mag = v_mag[u_indices,:]
v_mag = v_mag[:,v_indices]
vScale = np.nanmax(np.nanmax(v_mag))
local_vel = self.velocity[u_indices,:,:]
local_vel = local_vel[:,v_indices,:]
local_u = local_vel[:,:,0].T
local_v = local_vel[:,:,1].T
local_x,local_y = np.meshgrid(self.x[u_indices],self.y[v_indices])
vScale = max(vScale,0.126)
qk_value = np.round(vScale*4)/4
Q = plt.quiver(local_x,local_y,
local_u,local_v,
width=0.0015*self.v_scale,
headlength=10.0,
headwidth=7.0,
scale = 10.0*vScale/self.v_scale, #scale = 0.005,
color = self.arrow_color,
scale_units = 'width')
if self.equal_axes:
ax.set_aspect('equal')
if self.xpand is not None:
xpand = self.xpand
xspan = np.max(self.x) - np.min(self.x)
yspan = np.max(self.y) - np.min(self.y)
xspan = max(xspan,yspan)
yspan = xspan
x1 = np.min(self.x) - xpand*xspan; x2 = np.max(self.x) + xpand*xspan
plt.xlim([x1, x2])
y1 = np.min(self.y) - xpand*yspan; y2 = np.max(self.y) + xpand*yspan
plt.ylim([y1, y2])
qk = plt.quiverkey(Q, 0.5, 0.08, qk_value,
r'%3.2f '%qk_value + r'$ \frac{m}{s}$', labelpos='W',)
if self.title is not None:
plt.title(self.title,y=1.06)
if self.x_is_mtime:
ax.xaxis_date()
plt.gcf().autofmt_xdate()
elif self.xy_is_lonlat:
ax.yaxis.set_major_formatter(plt.FormatStrFormatter('%7.4f'))
ax.xaxis.set_major_formatter(plt.FormatStrFormatter('%7.4f'))
plt.ylabel('Latitude [degrees N]')
plt.xlabel('Longitude [degrees E]')
if self.xlabel is not None:
plt.xlabel(self.xlabel)
if self.ylabel is not None:
plt.ylabel(self.ylabel)
#plt.autoscale(True)
def get_fig(fig):
"""
Returns a new figure if figure is None, otherwise passes returns fig.
Inputs:
fig = matplotlib figure object, or None
Returns:
fig = either passes, or new matplotlib figure object
"""
if fig is None:
return plt.figure()
else:
return fig
def plot_vertical_panels(vpanels,fig=None,title=None):
"""
Plots a list of panels in a vertical arangement in in figure window.
Inputs:
fig = matplotlib figure object in which to plot, or None for a new figure
Returns:
nothing
"""
fig_handle = get_fig(fig)
plt.clf()
n_panels = len(vpanels)
sp_base = 100*n_panels+10
for i in range(n_panels):
plt.subplot(sp_base+i+1)
vpanels[i].plot()
plt.tight_layout()
if title is not None:
plt.title(title)
return fig_handle
def show():
"""
Shortcut to matplotlib.pyplot.show()
"""
plt.show()
def find_array_value_bounds(nparray,resolution):
"""
Find the bounds of the array values, adding up + resolution to make the bounds
a round out of a multiple of resolution.
Inputs:
nparray = array of numbers for which bounds are needed
resoution = number of which the bounds will be rounded up toward
Returns:
minv = minimum bound value of nparray
maxv = maximum bound value of nparray
"""
inv = 1.0/resolution
mtest = np.floor(nparray*inv)
minv = np.nanmin(np.nanmin(mtest))*resolution
mtest = np.ceil(nparray*inv)
maxv = np.nanmax(np.nanmax(mtest))*resolution
return (minv,maxv)
def find_plot_min_max_from_velocity(velocity_2d,res=None,equal_res_about_zero=True):
"""
Finds bounds as in find_array_value_bounds(), then optinoally
equates then +/- from zero. If res is None, returns None
Inputs:
nparray = array of numbers for which bounds are needed [2D numpy array]
res = number of which the bounds will be rounded up toward [number]
equal_res_about_zero = toggle to switch [True/False]
Returns:
minv =- minimum bound value of nparray, or None
maxv = maximum bound value of nparray, or None
"""
if res is not None:
minv, maxv = find_array_value_bounds(velocity_2d,res)
if equal_res_about_zero:
maxv = np.max(np.abs(minv),np.abs(minv))
minv = -1.0*maxv
else:
minv = None
maxv = None
return (minv,maxv)
def get_basic_velocity_panel(velocity_2d,res=None,equal_res_about_zero=True):
"""
Returns an IPanel with from a 2D velocity array.
Inputs:
nparray = array of numbers for which bounds are needed
res = number of which the bounds will be rounded up toward
equal_res_about_zero = toggle to switch [True/False]
Returns:
IPanel onject
"""
minv, maxv = find_plot_min_max_from_velocity(velocity_2d,res,
equal_res_about_zero)
return IPanel(velocity = velocity_2d,
x = None,
y = None,
minv = minv,
maxv = maxv,
units = 'm/s')
def plot_uvw_velocity_array(velocity,fig=None,title=None,ures=None,vres=None,wres=None,
equal_res_about_zero=True):
"""
Generates a figure with three panels showing U,V,W velocity from a single 3D
velocity array
Inputs:
velocity = [x,y,3] shape numpy array of 2D velocities
fig = input figure number [integer or None]
ures,vres,wres = numbers by which the velocity bounds will be rounded up toward [number or None]
equal_res_about_zero = toggle to switch [True/False]
Returns:
fig = matplotlib figure object
"""
panels = []
res = [ures, vres, wres]
for i in range(3):
if i == 0 and title is not None:
title_str = title + " - "
else:
title_str = ""
panels.append(get_basic_velocity_panel(velocity[:,:,i],res=res[i],equal_res_about_zero=False))
panels[-1].title = "%s%s Velocity [m/s]"%(title_str,vel_strs[i])
panels[-1].use_pcolormesh = False
fig = plot_vertical_panels(panels)
plt.tight_layout()
return fig
def plot_secondary_circulation(adcp,u_vecs,v_vecs,fig=None,title=None):
"""
Generates a with a single panel, plotting U velocity as an IPanel, overlain by
VW vectors from a QPanel.
Inputs:
adcp = ADCPData object
u_vecs,v_vecs = desired number of horizontal/vertical vectors [integers]
fig = input figure number [integer or None]
title = figure title text [string or None]
Returns:
fig = matplotlib figure object
"""
if fig is None:
fig = plt.figure(fig,figsize=(10,4))
else:
plt.clf()
xd,yd,dd,xy_line = adcpy.util.find_projection_distances(adcp.xy)
stream_wise = get_basic_velocity_panel(adcp.velocity[:,:,1],res=0.01)
stream_wise.x = dd
stream_wise.y = adcp.bin_center_elevation
stream_wise.chop_off_nans = True
secondary = QPanel(velocity = adcp.velocity[:,:,1:],
x = dd,
y = adcp.bin_center_elevation,
xpand = None,
v_scale = 1.5,
u_vecs = u_vecs,
v_vecs = v_vecs,
arrow_color = 'k',
units = 'm/s')
stream_wise.plot()
secondary.plot()
if title is not None:
plt.title(title)
return fig
def plot_secondary_circulation_over_streamwise(adcp,u_vecs,v_vecs,fig=None,title=None):
"""
Generates a with a single panel, plotting U velocity as an IPanel, overlain by
VW vectors from a QPanel.
Inputs:
adcp = ADCPData object
u_vecs,v_vecs = desired number of horizontal/vertical vectors [integers]
fig = input figure number [integer or None]
title = figure title text [string or None]
Returns:
fig = matplotlib figure object
"""
if fig is None:
fig = plt.figure(fig,figsize=(10,4))
else:
plt.clf()
xd,yd,dd,xy_line = adcpy.util.find_projection_distances(adcp.xy)
stream_wise = get_basic_velocity_panel(adcp.velocity[:,:,0],res=0.01)
stream_wise.x = dd
stream_wise.y = adcp.bin_center_elevation
stream_wise.chop_off_nans = True
secondary = QPanel(velocity = adcp.velocity[:,:,1:],
x = dd,
y = adcp.bin_center_elevation,
xpand = None,
v_scale = 1.5,
u_vecs = u_vecs,
v_vecs = v_vecs,
arrow_color = 'k',
units = 'm/s')
stream_wise.plot()
secondary.plot()
if title is not None:
plt.title(title)
return fig
def plot_ensemble_mean_vectors(adcp,fig=None,title=None,n_vectors=50,return_panel=False):
"""
Generates a QPanel, plotting mean uv velocity vectors in the x-y plane.
Inputs:
adcp = ADCPData object
fig = input figure number [integer or None]
title = figure title text [string or None]
n_vectors = desired number of vectors [integer]
return_panel = optinally return the QPanel instead of the figure
Returns:
fig = matplotlib figure object, or
vectors = QPanel object
"""
dude = np.zeros((adcp.n_ensembles,2),np.float64)
velocity = adcp.get_unrotated_velocity()
# this doesn't factor in depth, may integrate bad values if the have not been filtered into NaNs somehow
dude[:,0] = sp.nanmean(velocity[:,:,0],axis=1)
dude[:,1] = sp.nanmean(velocity[:,:,1],axis=1)
vectors = QPanel(velocity = dude,
u_vecs = n_vectors,
arrow_color = 'k',
title = title,
units = 'm/s')
if adcp.xy is not None:
vectors.x = adcp.xy[:,0]
vectors.y = adcp.xy[:,1]
vectors.xlabel = 'm'
vectors.ylabel = 'm'
vectors.equal_axes = True
elif adcp.lonlat is not None:
vectors.x = adcp.lonlat[:,0]
vectors.y = adcp.lonlat[:,1]
vectors.xy_is_lonlat = True
else:
vectors.x = adcp.mtime
vectors.y = np.zeros(np.size(vectors.x))
vectors.x_is_mtime = True
if return_panel:
return vectors
else:
fig = get_fig(fig)
vectors.plot()
plt.tight_layout()
return fig
def plot_obs_group_xy_lines(adcp_obs,fig=None,title=None):
"""
Produces a quick plot of the adcp ensemble x-y locations, from
a list of ADCPData objects. x-y tracks lines are colored differently
for each ADCPData object.
Inputs:
adcp_obs = list ADCPData objects
fig = input figure number [integer or None]
title = figure title text [string or None]
Returns:
fig = matplotlib figure object
"""
fig = get_fig(fig)
plt.hold(True)
legends = []
for a in adcp_obs:
if a.mtime is not None:
label = a.source+"; "+fmt_dnum(a.mtime[0])
else:
label = a.source
plot_xy_line(a,fig,label=label,use_stars_at_xy_locations=False)
plt.legend(prop={'size':10})
if title is not None:
plt.title(title,y=1.06)
return fig
def plot_xy_line(adcp,fig=None,title=None,label=None,use_stars_at_xy_locations=True):
"""
Produces a quick plot of the adcp ensemble x-y locations, from an ADCPData
object.
Inputs:
adcp_obs = list ADCPData objects
fig = input figure number [integer or None]
title = figure title text [string or None]
use_stars_at_xy_locations = plots * at actual ensemble locations [True/False]
Returns:
fig = matplotlib figure object
"""
fig = get_fig(fig)
if adcp.xy is not None:
x = adcp.xy[:,0]
y = adcp.xy[:,1]
elif adcp.lonlat is not None:
x = adcp.lonlat[:,0]
y = adcp.lonlat[:,1]
else:
raise Exception,"plot_xy_line(): no position data in ADCPData object"
if use_stars_at_xy_locations:
plt.plot(x,y,marker='*',label=label)
else:
plt.plot(x,y,label=label)
if title is not None:
plt.title(title,y=1.06)
formatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
plt.gca().yaxis.set_major_formatter(formatter)
plt.gca().xaxis.set_major_formatter(formatter)
return fig
def plot_uvw_velocity(adcp,uvw='uvw',fig=None,title=None,ures=None,vres=None,wres=None,
equal_res_about_zero=True,return_panels=False):
"""
Produces a quick plot of the adcp ensemble x-y locations, from an ADCPData
object.
Inputs:
adcp_obs = list ADCPData objects
fig = input figure number [integer or None]
title = figure title text [string or None]
use_stars_at_xy_locations = plots * at actual ensemble locations [True/False]
Returns:
fig = matplotlib figure object
"""
panels = []
dx = None
dt = None
res = [ures, vres, wres]
if adcp.xy is not None:
if np.size(adcp.xy[:,0]) == adcp.n_ensembles:
xd,yd,dx,xy_line = adcpy.util.find_projection_distances(adcp.xy)
if adcp.mtime is not None:
if np.size(adcp.mtime) == adcp.n_ensembles:
dt = adcp.mtime
ax = adcpy.util.get_axis_num_from_str(uvw)
for i in ax:
if i == ax[0] and title is not None:
title_str = title + " - "
else:
title_str = ""
panels.append(get_basic_velocity_panel(adcp.velocity[:,:,i],res=res[i]))
panels[-1].title = "%s%s Velocity [m/s]"%(title_str,vel_strs[i])
if dx is not None:
# plotting velocity projected along a line
panels[-1].x = dx
panels[-1].xlabel = 'm'
panels[-1].ylabel = 'm'
panels[-1].y = adcp.bin_center_elevation
elif dt is not None:
# plotting velocity ensembles vs time
panels[-1].x = dt
panels[-1].x_is_mtime = True
panels[-1].y = adcp.bin_center_elevation
panels[-1].ylabel = 'm'
panels[-1].use_pcolormesh = False
else:
# super basic plot
panels[-1].use_pcolormesh = False
if return_panels:
return panels
else:
fig = plot_vertical_panels(panels)
return fig
def plot_flow_summmary(adcp,title=None,fig=None,ures=None,vres=None,use_grid_flows=False):
"""
Plots projected mean flow vectors, U and V velocity profiles, and
associated text data on a single plot.
Inputs:
adcp_obs = list ADCPData objects
fig = input figure number [integer or None]
title = figure title text [string or None]
ures,vres = numbers by which the velocity bounds will be rounded up toward [number or None]
use_grid_flows = calculates flows using crossproduct flow (if available)
[True] or by weighted summing of grid cells [False]
Returns:
fig = matplotlib figure object
"""
if adcp.xy is None:
ValueError('Cannot plot summary without projected data.')
raise
if fig is None:
fig = plt.figure(fig,figsize=(8,10.5))
else:
plt.clf()
vectors = plot_ensemble_mean_vectors(adcp,n_vectors=30,return_panel=True)
vectors.x = vectors.x - np.min(vectors.x)
vectors.y = vectors.y - np.min(vectors.y)
u_panel,v_panel = plot_uvw_velocity(adcp,uvw='uv',fig=fig,ures=ures,
vres=vres,return_panels=True)
u_panel.chop_off_nans = True
u_panel.xlabel = None
v_panel.chop_off_nans = True
xd,yd,dd,xy_line = adcpy.util.find_projection_distances(adcp.xy)
plt.subplot(221)
vectors.plot()
plt.subplot(413)
u_panel.plot()
plt.subplot(414)
v_panel.plot()
plt.tight_layout()
if title is not None:
plt.text(0.55,0.933,title,
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
if adcp.mtime is not None:
plt.text(0.55,0.9,'Start of Data: %s'%( num2date(adcp.mtime[0]).strftime('%c')),
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
if adcp.rotation_angle is not None:
if np.size(adcp.rotation_angle) > 1:
rot_str = 'Rozovski'
else:
rot_str = '%5.2f degrees'%(adcp.rotation_angle*180.0/np.pi)
else:
rot_str = 'None'
plt.text(0.55,0.866,'Streawise Rotation: %s'%rot_str,
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform=fig.transFigure)
x1 = min(adcp.xy[:,0][np.nonzero(~np.isnan(adcp.xy[:,0]))])
y1 = min(adcp.xy[:,1][np.nonzero(~np.isnan(adcp.xy[:,1]))])
loc_string = 'Plot origin (%s) = (%i,%i)'%(adcp.xy_srs,
int(x1),
int(y1))
plt.text(0.55,0.833,loc_string,
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
if not use_grid_flows and 'calc_crossproduct_flow' in dir(adcp):
wrums,wru,tsa,tcsa = adcp.calc_crossproduct_flow()
plt.text(0.55,0.8,'Mean cross-product velocity [m/s]: %3.2f'%wrums,
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
plt.text(0.55,0.766,'Mean cross-product flow [m^3/s]: %12.2f'%wru,
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
else:
(scalar_mean_vel, depth_averaged_vel, total_flow, total_survey_area) = \
calc_transect_flows_from_uniform_velocity_grid(adcp,use_grid_only=True)
plt.text(0.55,0.8,'Mean U velocity [m/s]: %3.2f'%scalar_mean_vel[0],
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
plt.text(0.55,0.766,'Mean V velocity [m/s]: %3.2f'%scalar_mean_vel[1],
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
plt.text(0.55,0.733,'Mean U flow [m^3/s]: %12.2f'%total_flow[0],
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
plt.text(0.55,0.7,'Mean V flow [m^3/s]: %12.2f'%total_flow[1],
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
if adcp.source is not None:
plt.text(0.55,0.633,'Sources:\n%s'%adcp.source,
horizontalalignment='left',
verticalalignment='center',
fontsize=10,
transform = fig.transFigure)
return fig
| esatel/ADCPy | adcpy/adcpy_plot.py | Python | mit | 27,568 |
# -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
# Copyright (C) 2010-2012 ChriCar Beteiligungs- und Beratungs- GmbH (<http://www.camptocamp.at>)
#
# 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/>.
#
##############################################################################
from openerp.osv import fields, osv
import openerp.netsvc
import logging
class account_invoice(osv.osv):
_inherit = "account.invoice"
def button_validate(self, cr , uid, ids, context=None):
"""FIXME
workaround because of limited multi company support
"""
_logger = logging.getLogger(__name__)
if not context:
context = {}
for invoice in self.browse(cr, uid, ids, context):
_logger.debug('FGF validate partner %s ' %(invoice.partner_id.id) )
if invoice.partner_id.company_id and invoice.partner_id.company_id.id != invoice.company_id.id:
_logger.debug('FGF update partner %s ' %(invoice.partner_id.id) )
self.pool.get('res.partner').write(cr, 1, [invoice.partner_id.id], {'company_id':''})
res= self.button_validate(cr , uid, ids, context)
return res
account_invoice()
| VitalPet/c2c-rd-addons | sale_order_2_purchase/invoice.py | Python | agpl-3.0 | 1,994 |
#!/usr/bin/python
"""Simple server that listens on port 6000 and echos back every input to the client.
Connect to it with:
telnet localhost 6000
Terminate the connection by terminating telnet (typically Ctrl-] and then 'quit').
"""
import gevent
from gevent.server import StreamServer
def discard(socket, address):
print ('New connection from %s:%s' % address)
fileobj = socket.makefile()
while True:
line = fileobj.readline()
if not line: return
print ("got %r" % line)
if __name__ == '__main__':
# to make the server use SSL, pass certfile and keyfile arguments to the constructor
s1 = StreamServer(('localhost', 59068), discard)
s1.start()
s2 = StreamServer(('localhost', 59067), lambda a,b:None)
s2.start()
gevent.sleep(30)
s1.stop()
s2.stop()
| smurfix/HomEvenT | test/scripts/wago_job.py | Python | gpl-3.0 | 772 |
from bin_heap import binHeap
import pytest
import random
def test_empty_heap():
blist = binHeap()
assert blist.heap == [0]
def test_push_pop():
blist = binHeap()
blist.push(123)
assert blist.pop() == 123
def all_list(heap):
value_input = []
while True:
try:
value_input.append(heap.pop())
except IndexError:
return value_input
return value_input
def test_input_random():
blist = binHeap()
for x in random.sample(range(123), 123):
blist.push(x)
assert all_list(blist) == range(0, 123) | alibulota/data-structures | test_bin_heap.py | Python | mit | 582 |
"""CLI tests for Repository setup.
:Requirement: Repository
:CaseAutomation: Automated
:CaseLevel: Component
:CaseComponent: Repositories
:TestType: Functional
:CaseImportance: High
:Upstream: No
"""
import pytest
from robottelo.cli.factory import (
make_lifecycle_environment,
make_org,
)
from robottelo.constants import (
CUSTOM_PUPPET_REPO,
DISTROS_SUPPORTED,
DOCKER_REGISTRY_HUB,
DOCKER_UPSTREAM_NAME,
FAKE_0_CUSTOM_PACKAGE,
FAKE_0_YUM_REPO,
)
from robottelo.datafactory import xdist_adapter
from robottelo.decorators import tier4
from robottelo.products import (
DockerRepository,
PuppetRepository,
YumRepository,
RepositoryCollection,
SatelliteToolsRepository,
)
from robottelo.vm import VirtualMachine
def _distro_cdn_variants():
distro_cdn = []
for cdn in [False, True]:
for distro in DISTROS_SUPPORTED:
distro_cdn.append((distro, cdn))
return distro_cdn
@pytest.fixture(scope='module')
def module_org():
return make_org()
@pytest.fixture(scope='module')
def module_lce(module_org):
return make_lifecycle_environment({'organization-id': module_org['id']})
@tier4
@pytest.mark.parametrize('value', **xdist_adapter(_distro_cdn_variants()))
def test_vm_install_package(value, module_org, module_lce):
"""Install a package with all supported distros and cdn not cdn variants
:id: b2a6065a-69f6-4805-a28b-eaaa812e0f4b
:expectedresults: Package is install is installed
"""
# the value is support distro DISTRO_RH6 or DISTRO_RH7
# this will create 4 tests:
# - one test with disto rhel6 cdn False
# - one test with distro rhel7 cdn False
# - one test with disto rhel6 cdn True
# - one test with distro rhel7 cdn True
distro, cdn = value
repos_collection = RepositoryCollection(
distro=distro,
repositories=[
SatelliteToolsRepository(cdn=cdn),
YumRepository(url=FAKE_0_YUM_REPO),
DockerRepository(url=DOCKER_REGISTRY_HUB, upstream_name=DOCKER_UPSTREAM_NAME),
PuppetRepository(url=CUSTOM_PUPPET_REPO,
modules=[dict(name='generic_1', author='robottelo')])
]
)
# this will create repositories , content view and activation key
repos_collection.setup_content(module_org['id'], module_lce['id'], upload_manifest=True)
with VirtualMachine(distro=distro) as vm:
# this will install katello ca, register vm host, enable rh repos,
# install katello-agent
repos_collection.setup_virtual_machine(vm, enable_custom_repos=True)
# install a package
result = vm.run('yum -y install {0}'.format(FAKE_0_CUSTOM_PACKAGE))
assert result.return_code == 0
| ldjebran/robottelo | tests/foreman/cli/test_vm_install_products_package.py | Python | gpl-3.0 | 2,762 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import codecs
from setuptools import setup
def read(fname):
file_path = os.path.join(os.path.dirname(__file__), fname)
return codecs.open(file_path, encoding='utf-8').read()
setup(
name='pytest-yapf',
version='0.1.1',
author='Roman Osipenko',
author_email='[email protected]',
maintainer='Roman Osipenko',
maintainer_email='[email protected]',
license='MIT',
url='https://github.com/django-stars/pytest-yapf',
description='Run yapf',
long_description=read('README.rst'),
py_modules=['pytest_yapf'],
install_requires=['pytest>=3.1.1', 'yapf>=0.16.2'],
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: Pytest',
'Intended Audience :: Developers',
'Topic :: Software Development :: Testing',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: Implementation :: CPython',
'Operating System :: OS Independent',
'License :: OSI Approved :: MIT License',
],
entry_points={
'pytest11': [
'yapf = pytest_yapf',
],
},
)
| django-stars/pytest-yapf | setup.py | Python | mit | 1,383 |
# Copyright 2014 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Continuous Integration Database Library."""
import glob
import logging
import os
import re
import sqlalchemy
from chromite.cbuildbot import constants
TEST_DB_CREDENTIALS_DIR = os.path.join(constants.SOURCE_ROOT,
'crostools', 'cidb',
'test_credentials')
CIDB_MIGRATIONS_DIR = os.path.join(constants.CHROMITE_DIR, 'cidb',
'migrations')
class DBException(Exception):
"""General exception class for this module."""
class UnsupportedMethodException(DBException):
"""Raised when a call is made that the database does not support."""
def minimum_schema(min_version):
"""Generate a decorator to specify a minimum schema version for a method.
This decorator should be applied only to instance methods of
SchemaVersionedMySQLConnection objects.
"""
def decorator(f):
def wrapper(self, *args):
if self.schema_version < min_version:
raise UnsupportedMethodException()
return f(self, *args)
return wrapper
return decorator
class SchemaVersionedMySQLConnection(object):
"""Connection to a database that is aware of its schema version."""
SCHEMA_VERSION_TABLE_NAME = 'schemaVersionTable'
SCHEMA_VERSION_COL = 'schemaVersion'
def __init__(self, db_name, db_migrations_dir, db_credentials_dir):
"""SchemaVersionedMySQLConnection constructor.
Args:
db_name: Name of the database to connect to.
db_migrations_dir: Absolute path to directory of migration scripts
for this database.
db_credentials_dir: Absolute path to directory containing connection
information to the database. Specifically, this
directory should contain files names user.txt,
password.txt, host.txt, client-cert.pem,
client-key.pem, and server-ca.pem
"""
self.db_migrations_dir = db_migrations_dir
self.db_credentials_dir = db_credentials_dir
self.db_name = db_name
with open(os.path.join(db_credentials_dir, 'password.txt')) as f:
password = f.read().strip()
with open(os.path.join(db_credentials_dir, 'host.txt')) as f:
host = f.read().strip()
with open(os.path.join(db_credentials_dir, 'user.txt')) as f:
user = f.read().strip()
cert = os.path.join(db_credentials_dir, 'client-cert.pem')
key = os.path.join(db_credentials_dir, 'client-key.pem')
ca = os.path.join(db_credentials_dir, 'server-ca.pem')
ssl_args = {'ssl': {'cert': cert, 'key': key, 'ca': ca}}
connect_string = 'mysql://%s:%s@%s' % (user, password, host)
# Create a temporary engine to connect to the mysql instance, and check if
# a database named |db_name| exists. If not, create one.
temp_engine = sqlalchemy.create_engine(connect_string,
connect_args=ssl_args)
databases = temp_engine.execute('SHOW DATABASES').fetchall()
if (db_name,) not in databases:
temp_engine.execute('CREATE DATABASE %s' % db_name)
logging.info('Created database %s', db_name)
temp_engine.dispose()
# Now create the persistent connection to the database named |db_name|.
# If there is a schema version table, read the current schema version
# from it. Otherwise, assume schema_version 0.
connect_string = '%s/%s' % (connect_string, db_name)
self.engine = sqlalchemy.create_engine(connect_string,
connect_args=ssl_args)
self.schema_version = self.QuerySchemaVersion()
def DropDatabase(self):
"""Delete all data and tables from database, and drop database.
Use with caution. All data in database will be deleted. Invalidates
this database connection instance.
"""
self.engine.execute('DROP DATABASE %s' % self.db_name)
self.engine.dispose()
def QuerySchemaVersion(self):
"""Query the database for its current schema version number.
Returns:
The current schema version from the database's schema version table,
as an integer, or 0 if the table is empty or nonexistent.
"""
tables = self.engine.execute('SHOW TABLES').fetchall()
if (self.SCHEMA_VERSION_TABLE_NAME,) in tables:
r = self.engine.execute('SELECT MAX(%s) from %s' %
(self.SCHEMA_VERSION_COL, self.SCHEMA_VERSION_TABLE_NAME))
return r.fetchone()[0] or 0
else:
return 0
def ApplySchemaMigrations(self, maxVersion=None):
"""Apply pending migration scripts to database, in order.
Args:
maxVersion: The highest version migration script to apply. If
unspecified, all migrations found will be applied.
"""
# Look for migration script files in the migration script directory,
# with names of the form [number]*.sql, and sort these by number.
migration_scripts = glob.glob(os.path.join(self.db_migrations_dir, '*.sql'))
migrations = []
for script in migration_scripts:
match = re.match(r'([0-9]*).*', os.path.basename(script))
if match:
migrations.append((int(match.group(1)), script))
migrations.sort()
# Execute the migration scripts in order, asserting that each one
# updates the schema version to the expected number. If maxVersion
# is specified stop early.
for (number, script) in migrations:
if maxVersion is not None and number > maxVersion:
break
if number > self.schema_version:
self.RunQueryScript(script)
self.schema_version = self.QuerySchemaVersion()
if self.schema_version != number:
raise DBException('Migration script %s did not update '
'schema version to %s as expected. ' % (number,
script))
def RunQueryScript(self, script_path):
"""Run a .sql script file located at |script_path| on the database."""
with open(script_path, 'r') as f:
script = f.read()
queries = [q.strip() for q in script.split(';') if q.strip()]
for q in queries:
self.engine.execute(q)
class CIDBConnection(SchemaVersionedMySQLConnection):
"""Connection to a Continuous Integration database."""
def __init__(self):
super(CIDBConnection, self).__init__('cidb', CIDB_MIGRATIONS_DIR,
TEST_DB_CREDENTIALS_DIR)
@minimum_schema(1)
def TestMethodSchemaTooLow(self):
"""This method is a temporary one to test the minimum_schema decorator."""
@minimum_schema(0)
def TestMethodSchemaOK(self):
"""This method is a temporary one to test the minimum_schema decorator."""
| chadversary/chromiumos.chromite | lib/cidb.py | Python | bsd-3-clause | 6,868 |
# Copyright 2018, 2020, 2021 Smithsonian Astrophysical Observatory
#
# 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.
#
# 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
# products derived from this software without specific prior written permission.
#
# 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 numpy as np
import pytest
from pytest import approx
from sherpa.astro.data import DataIMG, DataIMGInt
from sherpa.astro.ui.utils import Session
from sherpa.data import Data1DInt, Data1D
from sherpa.models.basic import Box1D
from sherpa.models import Const1D, RegriddableModel1D, Parameter, Const2D, \
RegriddableModel2D, ArithmeticModel, Gauss2D, basic, model
from sherpa.utils.err import ModelErr
from sherpa.utils import neville, linear_interp
from sherpa.utils import akima
@pytest.fixture
def setup():
const = Const1D("const")
const.c0 = 0
const.c0.freeze()
my_model = MyModel("my_model")
my_model.integrate = False
return Session(), my_model, const
@pytest.fixture
def setup2d():
const = Const2D("const")
const.c0 = 0
const.c0.freeze()
x = [2, 3, 2, 3]
y = [2, 2, 3, 3]
xhi = [2.1, 3.5, 2.1, 3.5]
yhi = [2.1, 2.1, 3, 3.5]
# This is the result when rebinning [100, ] * 4
z = [225, ] * 4
my_model = MyModel2D("my_model")
return Session(), my_model, const, (x, y, xhi, yhi, z)
def test_evaluate_model_on_arbitrary_grid_point_list(setup):
"""
The idea of the test is that the model will evaluate differently depending on the grid it is evaluated on.
This is really arbitrary, it just exercises the high level API for a common workflow while making sure the results
are the expected ones.
"""
ui, my_model, const = setup
# Load data
ui.load_arrays(1, [1, 2, 3], [100, 100, 100])
# Get a model that evaluates on a different grid
# This is the important part.
regrid_model = my_model.regrid([1, 2, 2.5, 4, 5])
# The model will usually be part of a complex model expression, so let's pretend we add another component,
# although that component is muted.
ui.set_source(regrid_model + const)
# Fit and check the result
assert_fit(ui, my_model, 1)
# Now fit with a different grid.
# This is also the important part.
regrid_model.grid = [1, 2, 3, 4, 5]
assert_fit(ui, my_model, 0)
def test_evaluate_model_on_arbitrary_grid_point_list_2d(setup2d):
"""
The idea of the test is that the model will evaluate differently depending on the grid it is evaluated on.
This is really arbitrary, it just exercises the high level API for a common workflow while making sure the results
are the expected ones.
"""
ui, my_model, const, data = setup2d
x, y, _, _, z = data
# Load data
ui.load_arrays(1, x, y, z, DataIMG)
# Get a model that evaluates on a different grid
# This is the important part.
regrid_model = my_model.regrid([2, 2.5, 3], [2, 2.5, 3])
# The model will usually be part of a complex model expression, so let's pretend we add another component,
# although that component is muted.
ui.set_source(regrid_model + const)
# Fit and check the result
assert_fit(ui, my_model, (1, 1))
# Now fit with a different grid.
# This is also the important part.
regrid_model.grid = [2, 3], [2, 3]
assert_fit(ui, my_model, (0, 0))
def test_evaluate_model_on_arbitrary_grid_integrated_list(setup):
"""
Same as above, but with integrated models.
"""
ui, my_model, const = setup
# Load data
ui.load_arrays(1, [1.5, 2.5, 3.5], [2.5, 3.5, 4.5], [100, 100, 100], Data1DInt)
# Get a model that evaluates on a different grid
# This is the important part.
regrid_model = my_model.regrid([0, 1, 2], [1, 2, 3])
# The model will be part of a complex model expression, so let's pretend we add another component
ui.set_source(regrid_model + const)
# Fit and check the result
assert_fit(ui, my_model, 1)
# Now fit with a different grid.
# This is also the important part.
regrid_model.grid = [1.5, 2.5, 3.5], [2.5, 3.5, 4.5]
assert_fit(ui, my_model, 0)
def test_evaluate_model_on_arbitrary_grid_integrated_list_2d(setup2d):
"""
Same as above, but with integrated models
"""
ui, my_model, const, data = setup2d
x, y, xhi, yhi, z = data
# Load data
ui.load_arrays(1, x, y, xhi, yhi, z, DataIMGInt)
regrid_lo = [2, 2.5, 3]
regrid_hi = np.array([2, 2.5, 3.5])
# Get a model that evaluates on a different grid
# This is the important part.
regrid_model = my_model.regrid(regrid_lo, regrid_lo, regrid_hi, regrid_hi)
# The model will usually be part of a complex model expression, so let's pretend we add another component,
# although that component is muted.
ui.set_source(regrid_model + const)
# Fit and check the result
assert_fit(ui, my_model, (1, 1))
# Now fit with a different grid.
# This is also the important part.
regrid_model.grid = x, y, xhi, yhi
assert_fit(ui, my_model, (0, 0))
def test_evaluate_model_on_arbitrary_grid_point_ndarray(setup):
"""
The idea of the test is that the model will evaluate differently depending on the grid it is evaluated on.
This is really arbitrary, it just exercises the high level API for a common workflow while making sure the results
are the expected ones.
"""
ui, my_model, const = setup
# Load data
ui.load_arrays(1, [1, 2, 3], [100, 100, 100])
# Get a model that evaluates on a different grid
# This is the important part.
regrid_model = my_model.regrid(np.array([1, 2, 2.5, 4, 5]))
# The model will be part of a complex model expression, so let's pretend we add another component
ui.set_source(regrid_model + const)
# Fit and check the result
assert_fit(ui, my_model, 1)
# Now fit with a different regrid.
# This is also the important part.
regrid_model.grid = np.array([1, 2, 3, 4, 5])
assert_fit(ui, my_model, 0)
def test_evaluate_model_on_arbitrary_grid_integrated_ndarray(setup):
"""
Same as above, but with integrated models.
"""
ui, my_model, const = setup
# Load data
ui.load_arrays(1, [1.5, 2.5, 3.5], [2.5, 3.5, 4.5], [100, 100, 100], Data1DInt)
# Get a model that evaluates on a different grid
# This is the important part.
regrid_model = my_model.regrid(np.array([0, 1, 2]), [1, 2, 3])
# The model will be part of a complex model expression, so let's pretend we add another component
ui.set_source(regrid_model + const)
# Fit and check the result
assert_fit(ui, my_model, 1)
# Now fit with a different grid.
# This is also the important part.
regrid_model.grid = [1.5, 2.5, 3.5], np.array([2.5, 3.5, 4.5])
assert_fit(ui, my_model, 0)
def test_evaluate_model_on_arbitrary_grid_no_overlap(setup):
"""
If grids do not overlap, issue a warning and return zeros
"""
ui, my_model, _ = setup
# Get a model that evaluates on a different grid
# This is the important part. Note that there is overlap, but
# the start and end p
with pytest.raises(ModelErr) as excinfo:
my_model.regrid([2, 2.5], [2, 2.5])
assert ModelErr.dict['needsint'] in str(excinfo.value)
def test_evaluate_model_on_arbitrary_grid_no_overlap_2d(setup2d):
"""
In the 2D case, the overlap is way more stringent than in the 1D case, due to the complexity of rebinning
"""
ui, my_model, _, data = setup2d
x, y, _, _, _ = data
my_model.x_has_25 = 1 # To force the model to evaluate to something other than 0.
# Get a model that evaluates on a different grid
# This is the important part. Note that there is overlap, but
# the start and end points are different.
regrid_model = my_model.regrid([2, 2.5], [2, 2.5])
with pytest.warns(UserWarning):
np.testing.assert_array_equal(regrid_model(x, y), [0, 0, 0, 0])
def test_runtime_interp():
def tst_runtime_interp(model, requested, interp):
regrid_model = mdl.regrid(requested, interp=interp)
yregrid = regrid_model(xgrid)
return yregrid
xgrid = np.arange(2, 6, 0.1)
requested = np.arange(2.5, 5.1, 0.075)
mdl = Box1D()
mdl.xlow = 3.1
mdl.xhi = 4.2
mdl.ampl = 0.4
yregrid = tst_runtime_interp(mdl, requested, akima.akima)
assert 4.4 == approx(yregrid.sum())
yregrid = tst_runtime_interp(mdl, requested, linear_interp)
assert 4.4 == approx(yregrid.sum())
yregrid = tst_runtime_interp(mdl, requested, neville)
assert - 5.0e6 > yregrid.sum()
d = Data1D('tst', xgrid, np.ones_like(xgrid))
yexpected = d.eval_model(mdl)
requested = np.arange(2.5, 7, 0.2)
rmdl = mdl.regrid(requested)
ygot = d.eval_model(rmdl)
assert ygot == approx(yexpected)
def test_regrid_binaryop_1d():
"""issue #762, Cannot regrid a composite model (BinaryOpModel)"""
from sherpa.stats import LeastSq
from sherpa.fit import Fit
from sherpa.optmethods import LevMar
class MyConst1D(RegriddableModel1D):
def __init__(self, name='myconst1d'):
self.c0 = Parameter(name, 'c0', 3.1)
self.counter = 0
ArithmeticModel.__init__(self, name, (self.c0,))
def calc(self, par, *args, **kwargs):
x = args[0]
self.counter += x.size
return par[0]
class MyGauss(RegriddableModel1D):
def __init__(self, name='mygauss'):
self.sigma = Parameter(name, 'sigma', 10, min=0, max=10)
self.pos = Parameter(name, 'pos', 0, min=-10, max=10)
self.ampl = Parameter(name, 'ampl', 5)
self.counter = 0
ArithmeticModel.__init__(self, name, (self.sigma, self.pos, self.ampl))
def calc(self, par, *args, **kwargs):
sigma, pos, ampl = par[0], par[1], par[2]
x = args[0]
self.counter += x.size
return ampl * np.exp(-0.5 * (args[0] - pos)**2 / sigma**2)
np.random.seed(0)
leastsq = LeastSq()
levmar = LevMar()
mygauss = MyGauss()
myconst = MyConst1D()
mymodel = mygauss + myconst
x = np.linspace(-5., 5., 5)
err = 0.25
y = mymodel(x) + np.random.normal(mygauss.pos.val, err, x.shape)
mygauss.counter = 0
myconst.counter = 0
data = Data1D('one', x, y)
fit = Fit(data, mymodel, leastsq, levmar)
result = fit.fit()
assert result.numpoints == x.size
assert result.statval < 1.0
assert mygauss.counter == myconst.counter
assert (result.nfev + 4) * x.size == mygauss.counter
mygauss.counter = 0
myconst.counter = 0
x_regrid = np.linspace(-5., 5., 25)
mymodel_regrid = mymodel.regrid(x_regrid)
fit = Fit(data, mymodel_regrid, leastsq, levmar)
result = fit.fit()
assert result.numpoints == x.size
assert result.statval < 1.0
assert mygauss.counter == myconst.counter
assert (result.nfev + 4) * x_regrid.size == mygauss.counter
def test_regrid_binaryop_2d():
y0, x0 = np.mgrid[20:29, 10:20]
y0 = y0.flatten()
x0 = x0.flatten()
gmdl = Gauss2D()
gmdl.fwhm = 14
gmdl.xpos = 15
gmdl.ypos = 24
gmdl.ampl = 10
cmdl = Const2D()
cmdl.c0 = 4
xr1 = np.arange(10, 20, 1)
yr1 = np.arange(20, 29, 1)
rmdlg = gmdl.regrid(xr1, yr1)
rmdlc = cmdl.regrid(xr1, yr1)
shape = y0.shape
truthg = gmdl(x0, y0).reshape(shape)
truthc = cmdl(x0, y0).reshape(shape)
truth = truthg + truthc
ans1 = rmdlg(x0, y0).reshape(shape)
ans2 = rmdlc(x0, y0).reshape(shape)
assert (ans1 == truthg).all()
assert (ans2 == truthc).all()
rmdl = (gmdl + cmdl).regrid(xr1, yr1)
ans3 = rmdl(x0, y0).reshape(shape)
assert (ans3 == truth).all()
def test_regrid_call_behavior():
class Wrappable1D(model.RegriddableModel1D):
def __init__(self, cls, name):
self.ncalled = [] # record the number of elements
self.baseclass = cls
self.baseclass.__init__(self, name)
def calc(self, pars, xlo, *args, **kwargs):
xlo = np.asarray(xlo)
self.ncalled.append((xlo[0], xlo[-1], xlo.size))
return self.baseclass.calc(self, pars, xlo, *args, **kwargs)
m1 = Wrappable1D(basic.Const1D, 'm1')
m2 = Wrappable1D(basic.Gauss1D, 'm2')
m2.pos = 5
xregrid = np.arange(0, 20, 0.2)
xdata = np.arange(1.5, 12.5, 0.5)
morig = m1 + m2
mwrap = morig.regrid(xregrid)
# evaluate the model, we do not check the return value
_ = mwrap(xdata)
# Check both components were called with the same grid
assert m1.ncalled == m2.ncalled
# Check that m1 was called with the expected grid (ie that
# it is larger than xdata).
got = m1.ncalled
assert len(got) == 1
minval, maxval, nbins = m1.ncalled[0]
assert minval == pytest.approx(0)
assert maxval == pytest.approx(19.8)
assert nbins > xdata.size
assert nbins == 111
class MyModel(RegriddableModel1D):
"""
A model that returns [100, ] * len(x) if 2.5 is in the input array x
"""
def __init__(self, name):
self.has_25 = Parameter(name, "has_25", 0, min=0, max=1)
ArithmeticModel.__init__(self, name, (self.has_25,))
def guess(self, dep, *args, **kwargs):
raise NotImplementedError()
def get_center(self):
raise NotImplementedError()
def set_center(self, *args, **kwargs):
raise NotImplementedError()
def calc(self, p, *args, **kwargs):
x = args[0]
if 2.5 not in x:
if p[0] == 0:
return [100, ] * len(x)
else:
return [100-p[0] * 100, ] * len(x)
if p[0] == 1:
return [100, ] * len(x)
else:
return [p[0]*100, ] * len(x)
class MyModel2D(RegriddableModel2D):
"""
A 2D model that returns [100, ] * len(x) * len(y) if 2.5 is in the input arrays x and y
"""
def __init__(self, name):
self.x_has_25 = Parameter(name, "x_has_25", 0, min=0, max=1)
self.y_has_25 = Parameter(name, "y_has_25", 0, min=0, max=1)
RegriddableModel2D.__init__(self, name, (self.x_has_25, self.y_has_25))
def guess(self, dep, *args, **kwargs):
raise NotImplementedError()
def get_center(self):
raise NotImplementedError()
def set_center(self, *args, **kwargs):
raise NotImplementedError()
def calc(self, p, *args, **kwargs):
x, y, x_has_25, y_has_25 = args[0], args[1], p[0], p[1]
x_eval = np.array(self._eval(x, x_has_25))
y_eval = np.array(self._eval(y, y_has_25))
return (x_eval + y_eval)/2
def _eval(self, array, has_25):
if 2.5 not in array:
if has_25 == 0:
return [100, ] * len(array)
else:
return [100 - has_25 * 100, ] * len(array)
if has_25 == 1:
return [100, ] * len(array)
else:
return [has_25 * 100, ] * len(array)
def assert_fit(ui, model, value):
ui.fit()
try: # 2D, two values
len(value)
assert model.x_has_25.val == approx(value[0])
assert model.y_has_25.val == approx(value[1])
except TypeError: # 1D, one value
assert model.has_25.val == approx(value)
| anetasie/sherpa | sherpa/models/tests/test_regrid.py | Python | gpl-3.0 | 16,594 |
"""WSGI Components
This module implements WSGI Components.
"""
try:
from urllib.parse import unquote
except ImportError:
from urllib import unquote # NOQA
from operator import itemgetter
from traceback import format_tb
from types import GeneratorType
from sys import exc_info as _exc_info
from circuits.tools import tryimport
from circuits.core import handler, BaseComponent
StringIO = tryimport(("cStringIO", "StringIO", "io"), "StringIO")
from .http import HTTP
from .events import request
from .headers import Headers
from .errors import httperror
from circuits.web import wrappers
from .dispatchers import Dispatcher
def create_environ(errors, path, req):
environ = {}
env = environ.__setitem__
env("REQUEST_METHOD", req.method)
env("SERVER_NAME", req.host.split(":", 1)[0])
env("SERVER_PORT", "%i" % (req.server.port or 0))
env("SERVER_PROTOCOL", "HTTP/%d.%d" % req.server.http.protocol)
env("QUERY_STRING", req.qs)
env("SCRIPT_NAME", req.script_name)
env("CONTENT_TYPE", req.headers.get("Content-Type", ""))
env("CONTENT_LENGTH", req.headers.get("Content-Length", ""))
env("REMOTE_ADDR", req.remote.ip)
env("REMOTE_PORT", "%i" % (req.remote.port or 0))
env("wsgi.version", (1, 0))
env("wsgi.input", req.body)
env("wsgi.errors", errors)
env("wsgi.multithread", False)
env("wsgi.multiprocess", False)
env("wsgi.run_once", False)
env("wsgi.url_scheme", req.scheme)
if req.path:
req.script_name = req.path[:len(path)]
req.path = req.path[len(path):]
env("SCRIPT_NAME", req.script_name)
env("PATH_INFO", req.path)
for k, v in list(req.headers.items()):
env("HTTP_%s" % k.upper().replace("-", "_"), v)
return environ
class Application(BaseComponent):
channel = "web"
headerNames = {
"HTTP_CGI_AUTHORIZATION": "Authorization",
"CONTENT_LENGTH": "Content-Length",
"CONTENT_TYPE": "Content-Type",
"REMOTE_HOST": "Remote-Host",
"REMOTE_ADDR": "Remote-Addr",
}
def init(self):
self._finished = False
HTTP(self).register(self)
Dispatcher().register(self)
def translateHeaders(self, environ):
for cgiName in environ:
# We assume all incoming header keys are uppercase already.
if cgiName in self.headerNames:
yield self.headerNames[cgiName], environ[cgiName]
elif cgiName[:5] == "HTTP_":
# Hackish attempt at recovering original header names.
translatedHeader = cgiName[5:].replace("_", "-")
yield translatedHeader, environ[cgiName]
def getRequestResponse(self, environ):
env = environ.get
headers = Headers(list(self.translateHeaders(environ)))
protocol = tuple(map(int, env("SERVER_PROTOCOL")[5:].split(".")))
req = wrappers.Request(
None,
env("REQUEST_METHOD"),
env("wsgi.url_scheme"),
env("PATH_INFO", ""),
protocol,
env("QUERY_STRING", ""),
headers=headers
)
req.remote = wrappers.Host(env("REMOTE_ADDR"), env("REMTOE_PORT"))
req.script_name = env("SCRIPT_NAME")
req.wsgi_environ = environ
try:
cl = int(headers.get("Content-Length", "0"))
except:
cl = 0
req.body.write(env("wsgi.input").read(cl))
req.body.seek(0)
res = wrappers.Response(req)
res.gzip = "gzip" in req.headers.get("Accept-Encoding", "")
return req, res
def __call__(self, environ, start_response, exc_info=None):
self.request, self.response = self.getRequestResponse(environ)
self.fire(request(self.request, self.response))
self._finished = False
while self or not self._finished:
self.tick()
self.response.prepare()
body = self.response.body
status = self.response.status
headers = list(self.response.headers.items())
start_response(str(status), headers, exc_info)
return body
@handler("response", channel="web")
def response(self, event, response):
self._finished = True
event.stop()
@property
def host(self):
return ""
@property
def port(self):
return 0
@property
def secure(self):
return False
class _Empty(str):
def __bool__(self):
return True
__nonzero__ = __bool__
empty = _Empty()
del _Empty
class Gateway(BaseComponent):
channel = "web"
def init(self, apps):
self.apps = apps
self.errors = dict((k, StringIO()) for k in self.apps.keys())
@handler("request", priority=0.2)
def _on_request(self, event, req, res):
if not self.apps:
return
parts = req.path.split("/")
candidates = []
for i in range(len(parts)):
k = "/".join(parts[:(i + 1)]) or "/"
if k in self.apps:
candidates.append((k, self.apps[k]))
candidates = sorted(candidates, key=itemgetter(0), reverse=True)
if not candidates:
return
path, app = candidates[0]
buffer = StringIO()
def start_response(status, headers, exc_info=None):
res.status = int(status.split(" ", 1)[0])
for header in headers:
res.headers.add_header(*header)
return buffer.write
errors = self.errors[path]
environ = create_environ(errors, path, req)
try:
body = app(environ, start_response)
if isinstance(body, list):
body = "".join(body)
elif isinstance(body, GeneratorType):
res.body = body
res.stream = True
return res
if not body:
if not buffer.tell():
return empty
else:
buffer.seek(0)
return buffer
else:
return body
except Exception as error:
etype, evalue, etraceback = _exc_info()
error = (etype, evalue, format_tb(etraceback))
return httperror(req, res, 500, error=error)
finally:
event.stop()
| treemo/circuits | circuits/web/wsgi.py | Python | mit | 6,348 |
# -*- coding: UTF-8 -*-
"""Module for defining report element classes.
"""
import numpy as np
import pandas as pd
from .base import *
__all__ = __features__ = ["Code", "Footer", "Header", "Table", "Section",
"Text", "Title"]
HEAD_CSS = "@%(pos)s-left{%(left)s};@%(pos)s-center{%(center)s};@%(pos)s-righ" \
"t{%(right)s};"
class Footer(Element):
""" This class represents the footer of a report. """
pos = "bottom"
def __init__(self, left="", center="", right=""):
self.pos = self.__class__.pos
if self.pos == "bottom" and center == "":
center = "\" counter(page) \"/\" counter(pages) \""
for elm in ["left", "center", "right"]:
val = locals()[elm]
if isinstance(val, string_types):
val = Text(val, size=9)
if isinstance(val, Text):
setattr(self, elm, val.css())
@output
def css(self, text=TEXT):
return HEAD_CSS % self.__dict__
class Header(Footer):
""" This class represents the header of a report. """
pos = "top"
class Table(Element):
""" This class represents a table. """
filename = "table"
def __init__(self, data, col_headers=None, row_headers=None):
array = np.array(data) if not isinstance(data, np.ndarray) else data
kw = {}
if col_headers is not None:
kw['columns'] = col_headers
if row_headers is not None:
kw['index'] = row_headers
self._data = pd.DataFrame(data, **kw)
@output
def csv(self, text=TEXT, sep=',', index=True, float_fmt="%.2g"):
""" Generate a CSV table from the table data. """
return self._data.to_csv(sep=sep, index=index, float_format=float_fmt)
@output
def html(self, text=TEXT):
""" Generate an HTML table from the table data. """
return self._data.to_html()
@output
def json(self, text=TEXT):
""" Generate a JSON object form the table data. """
return self._data.to_json(orient='index')
@output
def md(self, text=TEXT, float_format="%.2g"):
""" Generate Markdown from the table data. """
cols = self._data.columns
hl = pd.DataFrame([["---"] * len(cols)], index=["---"], columns=cols)
df = pd.concat([hl, self._data])
return df.to_csv(sep='|', index=True, float_format=float_format)
@output
def xml(self, text=TEXT):
""" Generate an XML output from the report data. """
def convert(line):
xml = " <item>\n"
for f in line.index:
xml += " <field name=\"%s\">%s</field>\n" % (f, line[f])
xml += " </item>\n"
return xml
return "<items>\n" + '\n'.join(self._data.apply(convert, axis=1)) + \
"</items>"
class Text(Element):
""" Text area report element. """
def __init__(self, content, size="12", style="normal", color="black",
tag="p"):
self.content = content
self.tag = tag
self.style = "font-size:%(size)spx;font-style:%(style)s;color:" \
"%(color)s;" % locals()
@output
def css(self, text=TEXT):
return 'content:"%(content)s";%(style)s' % self.__dict__
@output
def html(self, text=TEXT):
return ('<%(tag)s style="%(style)s">%(content)s</%(tag)s>' % \
self.__dict__).replace("\n", "<br>")
@output
def md(self, text=TEXT):
return self.content
class Code(Text):
""" Code block report element. """
def __init__(self, code, size="10", style="normal", color="grey",
language=None, hl_lines=None):
super(Code, self).__init__(code, size, style, color, "pre")
self.language = language
self.hl_lines = hl_lines
@output
def html(self, text=TEXT):
s = "<pre"
if self.language:
s += ' class="%s hljs"' % self.language
s += ' style="%s">' % self.style
return s + str(self.content).replace("\n", "<br>") + "</pre>"
@output
def md(self, text=TEXT):
s = "```"
if self.language:
s += self.language
if self.hl_lines:
s += " hl_lines=\"%s\"" % self.hl_lines
return s + "\n%s\n```" % self.content
class Title(Text):
""" Title report element. """
def __init__(self, title, style="normal", color="black", tag="h1"):
self.content = title
self.tag = tag
self.style = "font-style:%(style)s;color:%(color)s;" % locals()
@output
def md(self, text=TEXT):
i = self.tag[-1]
if not i.isdigit():
raise ValueError("Title tag should be \"h[1-6]\"")
return "%(prefix)s %(content)s" % {'prefix': "#" * int(i),
'content': self.content}
class Section(Title):
""" Section report element. """
def __init__(self, title, style="normal", color="black", tag="h2"):
super(Section, self).__init__(title, style, color, tag)
| dhondta/tinyscript | tinyscript/report/objects.py | Python | agpl-3.0 | 5,115 |
#!/usr/bin/env python
class DiscUsage(object):
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually."""
def __init__(self):
"""
Attributes:
swaggerTypes (dict): The key is attribute name and the value is attribute type.
attributeMap (dict): The key is attribute name and the value is json key in definition.
"""
self.swaggerTypes = {
'UsedSize': 'long',
'TotalSize': 'long'
}
self.attributeMap = {
'UsedSize': 'UsedSize','TotalSize': 'TotalSize'}
self.UsedSize = None # long
self.TotalSize = None # long
| imranwar/AsposeStoragePHP | SDKs/Aspose.Storage_Cloud_SDK_For_Python/asposestoragecloud/models/DiscUsage.py | Python | mit | 713 |
#!/usr/bin/python
#============================ adjust path =====================================
import sys
import os
if __name__ == '__main__':
here = sys.path[0]
sys.path.insert(0, os.path.join(here, '..'))
#============================ imports =========================================
import Tkinter
import dustGuiLib
import dustFrame
from dustStyle import dustStyle
from SmartMeshSDK import ApiException
#============================ defines =========================================
WELL_KNOWN_ADDR_MANAGER = 'ff020000000000000000000000000002'
DEFAULT_DEST_PORT = '61000'
DEFAULT_HOST_ADDR = '20010470006600170000000000000002'
#============================ body ============================================
class dustFrameSensorTx(dustFrame.dustFrame):
ERROR = 'error'
NOERROR = 'noerror'
def __init__(self,parentElem,guiLock,frameName="sensor",row=0,column=0):
# record params
# local variables
self.connector = None
self.payloadCounter = 0
# init parent
dustFrame.dustFrame.__init__(self,parentElem,guiLock,frameName,row,column)
#row 0: slide
self.slide = Tkinter.Scale(self.container,
from_=0,
to=0xffff,
orient=Tkinter.HORIZONTAL)
self._add(self.slide,0,0,columnspan=3)
#row 1: label
temp = dustGuiLib.Label(self.container,
text='destination IPv6 address')
self._add(temp,1,0)
temp.configure(font=dustStyle.FONT_HEADER)
temp = dustGuiLib.Label(self.container,
text='dest. UDP port')
self._add(temp,1,1)
temp.configure(font=dustStyle.FONT_HEADER)
#row 2: send to manager
temp = dustGuiLib.Label(self.container,
text=WELL_KNOWN_ADDR_MANAGER)
self._add(temp,2,0)
self.mgrPortText = dustGuiLib.Text(self.container,
width=6,
height=1)
self.mgrPortText.insert(1.0,DEFAULT_DEST_PORT)
self._add(self.mgrPortText,2,1)
self.mgrButton = dustGuiLib.Button(self.container,
text='send to manager',
state=Tkinter.DISABLED,
command=self._sendMgr)
self._add(self.mgrButton,2,2)
#row 3: send to host
self.hostAddrText = dustGuiLib.Text(self.container,
width=35,
height=1)
self.hostAddrText.insert(1.0,DEFAULT_HOST_ADDR)
self._add(self.hostAddrText,3,0)
self.hostPortText = dustGuiLib.Text(self.container,
width=6,
height=1)
self.hostPortText.insert(1.0,DEFAULT_DEST_PORT)
self._add(self.hostPortText,3,1)
self.hostButton = dustGuiLib.Button(self.container,
text='send to host',
state=Tkinter.DISABLED,
command=self._sendHost)
self._add(self.hostButton,3,2)
#row 4: status
self.statusLabel = dustGuiLib.Label(self.container)
self._add(self.statusLabel,4,0,columnspan=3)
#======================== public ==========================================
def activate(self,connector,socketId):
# store params
self.connector = connector
self.socketId = socketId
# enable send buttons
self.mgrButton.config(state=Tkinter.NORMAL)
self.hostButton.config(state=Tkinter.NORMAL)
def disactivate(self):
# forget about the connector
self.connector = None
# disable send buttons
self.mgrButton.config(state=Tkinter.DISABLED)
self.hostButton.config(state=Tkinter.DISABLED)
#======================== private =========================================
def _sendMgr(self):
destAddr = WELL_KNOWN_ADDR_MANAGER
destPort = int(self.mgrPortText.get(1.0,Tkinter.END).strip())
self._sendInternal(destAddr,destPort)
def _sendHost(self):
destAddr = self.hostAddrText.get(1.0,Tkinter.END).strip()
try:
destPort = int(self.hostPortText.get(1.0,Tkinter.END).strip())
except ValueError:
self._printStatus(self.ERROR,"invalid port number")
self._sendInternal(destAddr,destPort)
#======================== helpers =========================================
def _sendInternal(self,destAddrString,destPort):
# format destAddr
destAddr = []
destAddrString = ''.join( destAddrString.split(" ") )
if len(destAddrString)%2!=0:
self._printStatus(self.ERROR,"destination address is not a even number of characters")
return
try:
for i in range(0, len(destAddrString), 2):
destAddr.append( int(destAddrString[i:i+2],16) )
except ValueError:
self._printStatus(self.ERROR,"destination address not hexadecimal numbers")
return
# prepare sensor data
sensorValRaw = self.slide.get()
sensorVal = [(sensorValRaw>>8)%256,(sensorValRaw>>0)%256]
try:
res = self.connector.dn_sendTo(
self.socketId,
destAddr,
destPort,
0,
1,
self.payloadCounter,
sensorVal
)
self.payloadCounter += 1
except ApiException.APIError as err:
self._printStatus(self.ERROR,str(err))
else:
assert(res.RC==0)
self._printStatus(self.NOERROR,"Sent succesfully")
def _printStatus(self,errorLevel,statusText):
self.statusLabel.config(text=statusText)
if errorLevel in [self.NOERROR]:
self.statusLabel.config(bg=dustStyle.COLOR_NOERROR)
elif errorLevel in [self.ERROR]:
self.statusLabel.config(bg=dustStyle.COLOR_ERROR)
else:
raise ValueError("unknown errorLevel {0}".format(errorLevel))
#============================ sample app ======================================
# The following gets called only if you run this module as a standalone app, by
# double-clicking on this source file. This code is NOT executed when importing
# this module is a larger application
#
class exampleApp(object):
def __init__(self):
self.window = dustWindow("dustFrameSensorTx",
self._closeCb)
self.guiLock = threading.Lock()
self.frame = dustFrameSensorTx(
self.window,
self.guiLock,
row=0,column=0)
self.frame.show()
self.window.mainloop()
def _closeCb(self):
print " _closeCb called"
if __name__ == '__main__':
import threading
from dustWindow import dustWindow
exampleApp() | bubbalinear/smartmeshsdk | dustUI/dustFrameSensorTx.py | Python | bsd-3-clause | 7,785 |
import _plotly_utils.basevalidators
class FamilyValidator(_plotly_utils.basevalidators.StringValidator):
def __init__(
self,
plotly_name="family",
parent_name="scatter3d.legendgrouptitle.font",
**kwargs
):
super(FamilyValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "style"),
no_blank=kwargs.pop("no_blank", True),
strict=kwargs.pop("strict", True),
**kwargs
)
| plotly/plotly.py | packages/python/plotly/plotly/validators/scatter3d/legendgrouptitle/font/_family.py | Python | mit | 554 |
"""Computes active users over the last one year."""
import datetime
import logging
import isoweek
import luigi
from edx.analytics.tasks.common.mapreduce import MapReduceJobTask, MapReduceJobTaskMixin
from edx.analytics.tasks.common.pathutil import EventLogSelectionDownstreamMixin, EventLogSelectionMixin
from edx.analytics.tasks.common.vertica_load import IncrementalVerticaCopyTask, VerticaCopyTaskMixin
from edx.analytics.tasks.util import eventlog
from edx.analytics.tasks.util.hive import BareHiveTableTask, HivePartitionTask, WarehouseMixin
from edx.analytics.tasks.util.overwrite import OverwriteOutputMixin
from edx.analytics.tasks.util.url import get_target_from_url
from edx.analytics.tasks.util.weekly_interval import WeeklyIntervalMixin
log = logging.getLogger(__name__)
class ActiveUsersDownstreamMixin(
WarehouseMixin,
OverwriteOutputMixin,
MapReduceJobTaskMixin,
EventLogSelectionDownstreamMixin):
"""Common parameters needed for the workflow."""
pass
class ActiveUsersTask(ActiveUsersDownstreamMixin, EventLogSelectionMixin, MapReduceJobTask):
"""Task to compute active users."""
def mapper(self, line):
value = self.get_event_and_date_string(line)
if value is None:
return
event, date_string = value
username = eventlog.get_event_username(event)
if not username:
log.error("Encountered event with no username: %s", event)
self.incr_counter('Active Users last year', 'Discard Event Missing username', 1)
return
date = datetime.date(*[int(x) for x in date_string.split('-')])
iso_year, iso_weekofyear, _iso_weekday = date.isocalendar()
week = isoweek.Week(iso_year, iso_weekofyear)
start_date = week.monday().isoformat()
end_date = (week.sunday() + datetime.timedelta(1)).isoformat()
yield (start_date, end_date, username), 1
def reducer(self, key, _values):
yield key
def output(self):
output_url = self.hive_partition_path('active_users_per_week', self.interval.date_b)
return get_target_from_url(output_url)
def run(self):
self.remove_output_on_overwrite()
super(ActiveUsersTask, self).run()
def extra_modules(self):
import isoweek
return [isoweek]
class ActiveUsersTableTask(BareHiveTableTask):
"""Hive table that stores the active users over time."""
@property
def partition_by(self):
return 'dt'
@property
def table(self):
return 'active_users_per_week'
@property
def columns(self):
return [
('start_date', 'STRING'),
('end_date', 'STRING'),
('username', 'STRING'),
]
class ActiveUsersPartitionTask(ActiveUsersDownstreamMixin, HivePartitionTask):
"""Creates hive table partition to hold active users data."""
@property
def hive_table_task(self): # pragma: no cover
return ActiveUsersTableTask(
warehouse_path=self.warehouse_path,
)
@property
def partition_value(self):
""" Use a dynamic partition value based on the interval end date. """
return self.interval.date_b.isoformat()
@property
def data_task(self):
return ActiveUsersTask(
mapreduce_engine=self.mapreduce_engine,
n_reduce_tasks=self.n_reduce_tasks,
source=self.source,
pattern=self.pattern,
warehouse_path=self.warehouse_path,
interval=self.interval,
overwrite=self.overwrite,
)
class LoadInternalReportingActiveUsersToWarehouse(WeeklyIntervalMixin, ActiveUsersDownstreamMixin, IncrementalVerticaCopyTask):
"""Loads the active_users_this_year hive table into Vertica warehouse."""
HIVE_TABLE = 'active_users_per_week'
@property
def record_filter(self):
return "start_date='{start_date}' and end_date='{end_date}'".format(
start_date=self.interval.date_a.isoformat(),
end_date=self.interval.date_b.isoformat()
)
def update_id(self):
return '{task_name}(start_date={start_date},end_date={end_date})'.format(
task_name=self.task_family,
start_date=self.interval.date_a.isoformat(),
end_date=self.interval.date_b.isoformat()
)
@property
def insert_source_task(self):
return ActiveUsersPartitionTask(
interval=self.interval,
n_reduce_tasks=self.n_reduce_tasks,
warehouse_path=self.warehouse_path,
overwrite=self.overwrite,
).data_task
@property
def table(self):
return 'f_active_users_per_week'
@property
def auto_primary_key(self):
return None
@property
def default_columns(self):
"""List of tuples defining name and definition of automatically-filled columns."""
return None
@property
def columns(self):
return [
('start_date', 'DATE'),
('end_date', 'DATE'),
('username', 'VARCHAR(45) NOT NULL'),
]
class ActiveUsersWorkflow(ActiveUsersDownstreamMixin, VerticaCopyTaskMixin, luigi.WrapperTask):
date = luigi.DateParameter()
overwrite_n_weeks = luigi.IntParameter(default=1)
interval = None
def requires(self):
kwargs = {
'schema': self.schema,
'credentials': self.credentials,
'weeks': 1,
'warehouse_path': self.warehouse_path,
'n_reduce_tasks': self.n_reduce_tasks,
}
yield LoadInternalReportingActiveUsersToWarehouse(
end_date=self.date,
overwrite=self.overwrite,
**kwargs
)
weeks_to_overwrite = self.overwrite_n_weeks
end_date = self.date
while weeks_to_overwrite > 0:
end_date = end_date - datetime.timedelta(weeks=1)
yield LoadInternalReportingActiveUsersToWarehouse(
end_date=end_date,
overwrite=True,
**kwargs
)
weeks_to_overwrite -= 1
def complete(self):
# OverwriteOutputMixin changes the complete() method behavior, so we override it.
return all(r.complete() for r in luigi.task.flatten(self.requires()))
| Stanford-Online/edx-analytics-pipeline | edx/analytics/tasks/warehouse/load_internal_reporting_active_users.py | Python | agpl-3.0 | 6,350 |
# -*- 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.
#
import os
import mock
import grpc
from grpc.experimental import aio
from collections.abc import Iterable
import json
import math
import pytest
from proto.marshal.rules.dates import DurationRule, TimestampRule
from requests import Response
from requests import Request, PreparedRequest
from requests.sessions import Session
from google.api_core import client_options
from google.api_core import exceptions as core_exceptions
from google.api_core import gapic_v1
from google.api_core import grpc_helpers
from google.api_core import grpc_helpers_async
from google.api_core import path_template
from google.auth import credentials as ga_credentials
from google.auth.exceptions import MutualTLSChannelError
from google.cloud.compute_v1.services.region_backend_services import (
RegionBackendServicesClient,
)
from google.cloud.compute_v1.services.region_backend_services import pagers
from google.cloud.compute_v1.services.region_backend_services import transports
from google.cloud.compute_v1.types import compute
from google.oauth2 import service_account
import google.auth
def client_cert_source_callback():
return b"cert bytes", b"key bytes"
# If default endpoint is localhost, then default mtls endpoint will be the same.
# This method modifies the default endpoint so the client can produce a different
# mtls endpoint for endpoint testing purposes.
def modify_default_endpoint(client):
return (
"foo.googleapis.com"
if ("localhost" in client.DEFAULT_ENDPOINT)
else client.DEFAULT_ENDPOINT
)
def test__get_default_mtls_endpoint():
api_endpoint = "example.googleapis.com"
api_mtls_endpoint = "example.mtls.googleapis.com"
sandbox_endpoint = "example.sandbox.googleapis.com"
sandbox_mtls_endpoint = "example.mtls.sandbox.googleapis.com"
non_googleapi = "api.example.com"
assert RegionBackendServicesClient._get_default_mtls_endpoint(None) is None
assert (
RegionBackendServicesClient._get_default_mtls_endpoint(api_endpoint)
== api_mtls_endpoint
)
assert (
RegionBackendServicesClient._get_default_mtls_endpoint(api_mtls_endpoint)
== api_mtls_endpoint
)
assert (
RegionBackendServicesClient._get_default_mtls_endpoint(sandbox_endpoint)
== sandbox_mtls_endpoint
)
assert (
RegionBackendServicesClient._get_default_mtls_endpoint(sandbox_mtls_endpoint)
== sandbox_mtls_endpoint
)
assert (
RegionBackendServicesClient._get_default_mtls_endpoint(non_googleapi)
== non_googleapi
)
@pytest.mark.parametrize(
"client_class,transport_name", [(RegionBackendServicesClient, "rest"),]
)
def test_region_backend_services_client_from_service_account_info(
client_class, transport_name
):
creds = ga_credentials.AnonymousCredentials()
with mock.patch.object(
service_account.Credentials, "from_service_account_info"
) as factory:
factory.return_value = creds
info = {"valid": True}
client = client_class.from_service_account_info(info, transport=transport_name)
assert client.transport._credentials == creds
assert isinstance(client, client_class)
assert client.transport._host == (
"compute.googleapis.com{}".format(":443")
if transport_name in ["grpc", "grpc_asyncio"]
else "https://{}".format("compute.googleapis.com")
)
@pytest.mark.parametrize(
"transport_class,transport_name",
[(transports.RegionBackendServicesRestTransport, "rest"),],
)
def test_region_backend_services_client_service_account_always_use_jwt(
transport_class, transport_name
):
with mock.patch.object(
service_account.Credentials, "with_always_use_jwt_access", create=True
) as use_jwt:
creds = service_account.Credentials(None, None, None)
transport = transport_class(credentials=creds, always_use_jwt_access=True)
use_jwt.assert_called_once_with(True)
with mock.patch.object(
service_account.Credentials, "with_always_use_jwt_access", create=True
) as use_jwt:
creds = service_account.Credentials(None, None, None)
transport = transport_class(credentials=creds, always_use_jwt_access=False)
use_jwt.assert_not_called()
@pytest.mark.parametrize(
"client_class,transport_name", [(RegionBackendServicesClient, "rest"),]
)
def test_region_backend_services_client_from_service_account_file(
client_class, transport_name
):
creds = ga_credentials.AnonymousCredentials()
with mock.patch.object(
service_account.Credentials, "from_service_account_file"
) as factory:
factory.return_value = creds
client = client_class.from_service_account_file(
"dummy/file/path.json", transport=transport_name
)
assert client.transport._credentials == creds
assert isinstance(client, client_class)
client = client_class.from_service_account_json(
"dummy/file/path.json", transport=transport_name
)
assert client.transport._credentials == creds
assert isinstance(client, client_class)
assert client.transport._host == (
"compute.googleapis.com{}".format(":443")
if transport_name in ["grpc", "grpc_asyncio"]
else "https://{}".format("compute.googleapis.com")
)
def test_region_backend_services_client_get_transport_class():
transport = RegionBackendServicesClient.get_transport_class()
available_transports = [
transports.RegionBackendServicesRestTransport,
]
assert transport in available_transports
transport = RegionBackendServicesClient.get_transport_class("rest")
assert transport == transports.RegionBackendServicesRestTransport
@pytest.mark.parametrize(
"client_class,transport_class,transport_name",
[
(
RegionBackendServicesClient,
transports.RegionBackendServicesRestTransport,
"rest",
),
],
)
@mock.patch.object(
RegionBackendServicesClient,
"DEFAULT_ENDPOINT",
modify_default_endpoint(RegionBackendServicesClient),
)
def test_region_backend_services_client_client_options(
client_class, transport_class, transport_name
):
# Check that if channel is provided we won't create a new one.
with mock.patch.object(RegionBackendServicesClient, "get_transport_class") as gtc:
transport = transport_class(credentials=ga_credentials.AnonymousCredentials())
client = client_class(transport=transport)
gtc.assert_not_called()
# Check that if channel is provided via str we will create a new one.
with mock.patch.object(RegionBackendServicesClient, "get_transport_class") as gtc:
client = client_class(transport=transport_name)
gtc.assert_called()
# Check the case api_endpoint is provided.
options = client_options.ClientOptions(api_endpoint="squid.clam.whelk")
with mock.patch.object(transport_class, "__init__") as patched:
patched.return_value = None
client = client_class(transport=transport_name, client_options=options)
patched.assert_called_once_with(
credentials=None,
credentials_file=None,
host="squid.clam.whelk",
scopes=None,
client_cert_source_for_mtls=None,
quota_project_id=None,
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
# Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is
# "never".
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}):
with mock.patch.object(transport_class, "__init__") as patched:
patched.return_value = None
client = client_class(transport=transport_name)
patched.assert_called_once_with(
credentials=None,
credentials_file=None,
host=client.DEFAULT_ENDPOINT,
scopes=None,
client_cert_source_for_mtls=None,
quota_project_id=None,
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
# Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is
# "always".
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}):
with mock.patch.object(transport_class, "__init__") as patched:
patched.return_value = None
client = client_class(transport=transport_name)
patched.assert_called_once_with(
credentials=None,
credentials_file=None,
host=client.DEFAULT_MTLS_ENDPOINT,
scopes=None,
client_cert_source_for_mtls=None,
quota_project_id=None,
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
# Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT has
# unsupported value.
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "Unsupported"}):
with pytest.raises(MutualTLSChannelError):
client = client_class(transport=transport_name)
# Check the case GOOGLE_API_USE_CLIENT_CERTIFICATE has unsupported value.
with mock.patch.dict(
os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "Unsupported"}
):
with pytest.raises(ValueError):
client = client_class(transport=transport_name)
# Check the case quota_project_id is provided
options = client_options.ClientOptions(quota_project_id="octopus")
with mock.patch.object(transport_class, "__init__") as patched:
patched.return_value = None
client = client_class(client_options=options, transport=transport_name)
patched.assert_called_once_with(
credentials=None,
credentials_file=None,
host=client.DEFAULT_ENDPOINT,
scopes=None,
client_cert_source_for_mtls=None,
quota_project_id="octopus",
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
@pytest.mark.parametrize(
"client_class,transport_class,transport_name,use_client_cert_env",
[
(
RegionBackendServicesClient,
transports.RegionBackendServicesRestTransport,
"rest",
"true",
),
(
RegionBackendServicesClient,
transports.RegionBackendServicesRestTransport,
"rest",
"false",
),
],
)
@mock.patch.object(
RegionBackendServicesClient,
"DEFAULT_ENDPOINT",
modify_default_endpoint(RegionBackendServicesClient),
)
@mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "auto"})
def test_region_backend_services_client_mtls_env_auto(
client_class, transport_class, transport_name, use_client_cert_env
):
# This tests the endpoint autoswitch behavior. Endpoint is autoswitched to the default
# mtls endpoint, if GOOGLE_API_USE_CLIENT_CERTIFICATE is "true" and client cert exists.
# Check the case client_cert_source is provided. Whether client cert is used depends on
# GOOGLE_API_USE_CLIENT_CERTIFICATE value.
with mock.patch.dict(
os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env}
):
options = client_options.ClientOptions(
client_cert_source=client_cert_source_callback
)
with mock.patch.object(transport_class, "__init__") as patched:
patched.return_value = None
client = client_class(client_options=options, transport=transport_name)
if use_client_cert_env == "false":
expected_client_cert_source = None
expected_host = client.DEFAULT_ENDPOINT
else:
expected_client_cert_source = client_cert_source_callback
expected_host = client.DEFAULT_MTLS_ENDPOINT
patched.assert_called_once_with(
credentials=None,
credentials_file=None,
host=expected_host,
scopes=None,
client_cert_source_for_mtls=expected_client_cert_source,
quota_project_id=None,
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
# Check the case ADC client cert is provided. Whether client cert is used depends on
# GOOGLE_API_USE_CLIENT_CERTIFICATE value.
with mock.patch.dict(
os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env}
):
with mock.patch.object(transport_class, "__init__") as patched:
with mock.patch(
"google.auth.transport.mtls.has_default_client_cert_source",
return_value=True,
):
with mock.patch(
"google.auth.transport.mtls.default_client_cert_source",
return_value=client_cert_source_callback,
):
if use_client_cert_env == "false":
expected_host = client.DEFAULT_ENDPOINT
expected_client_cert_source = None
else:
expected_host = client.DEFAULT_MTLS_ENDPOINT
expected_client_cert_source = client_cert_source_callback
patched.return_value = None
client = client_class(transport=transport_name)
patched.assert_called_once_with(
credentials=None,
credentials_file=None,
host=expected_host,
scopes=None,
client_cert_source_for_mtls=expected_client_cert_source,
quota_project_id=None,
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
# Check the case client_cert_source and ADC client cert are not provided.
with mock.patch.dict(
os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env}
):
with mock.patch.object(transport_class, "__init__") as patched:
with mock.patch(
"google.auth.transport.mtls.has_default_client_cert_source",
return_value=False,
):
patched.return_value = None
client = client_class(transport=transport_name)
patched.assert_called_once_with(
credentials=None,
credentials_file=None,
host=client.DEFAULT_ENDPOINT,
scopes=None,
client_cert_source_for_mtls=None,
quota_project_id=None,
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
@pytest.mark.parametrize("client_class", [RegionBackendServicesClient])
@mock.patch.object(
RegionBackendServicesClient,
"DEFAULT_ENDPOINT",
modify_default_endpoint(RegionBackendServicesClient),
)
def test_region_backend_services_client_get_mtls_endpoint_and_cert_source(client_class):
mock_client_cert_source = mock.Mock()
# Test the case GOOGLE_API_USE_CLIENT_CERTIFICATE is "true".
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}):
mock_api_endpoint = "foo"
options = client_options.ClientOptions(
client_cert_source=mock_client_cert_source, api_endpoint=mock_api_endpoint
)
api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source(
options
)
assert api_endpoint == mock_api_endpoint
assert cert_source == mock_client_cert_source
# Test the case GOOGLE_API_USE_CLIENT_CERTIFICATE is "false".
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "false"}):
mock_client_cert_source = mock.Mock()
mock_api_endpoint = "foo"
options = client_options.ClientOptions(
client_cert_source=mock_client_cert_source, api_endpoint=mock_api_endpoint
)
api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source(
options
)
assert api_endpoint == mock_api_endpoint
assert cert_source is None
# Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "never".
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}):
api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source()
assert api_endpoint == client_class.DEFAULT_ENDPOINT
assert cert_source is None
# Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "always".
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}):
api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source()
assert api_endpoint == client_class.DEFAULT_MTLS_ENDPOINT
assert cert_source is None
# Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "auto" and default cert doesn't exist.
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}):
with mock.patch(
"google.auth.transport.mtls.has_default_client_cert_source",
return_value=False,
):
api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source()
assert api_endpoint == client_class.DEFAULT_ENDPOINT
assert cert_source is None
# Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "auto" and default cert exists.
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}):
with mock.patch(
"google.auth.transport.mtls.has_default_client_cert_source",
return_value=True,
):
with mock.patch(
"google.auth.transport.mtls.default_client_cert_source",
return_value=mock_client_cert_source,
):
(
api_endpoint,
cert_source,
) = client_class.get_mtls_endpoint_and_cert_source()
assert api_endpoint == client_class.DEFAULT_MTLS_ENDPOINT
assert cert_source == mock_client_cert_source
@pytest.mark.parametrize(
"client_class,transport_class,transport_name",
[
(
RegionBackendServicesClient,
transports.RegionBackendServicesRestTransport,
"rest",
),
],
)
def test_region_backend_services_client_client_options_scopes(
client_class, transport_class, transport_name
):
# Check the case scopes are provided.
options = client_options.ClientOptions(scopes=["1", "2"],)
with mock.patch.object(transport_class, "__init__") as patched:
patched.return_value = None
client = client_class(client_options=options, transport=transport_name)
patched.assert_called_once_with(
credentials=None,
credentials_file=None,
host=client.DEFAULT_ENDPOINT,
scopes=["1", "2"],
client_cert_source_for_mtls=None,
quota_project_id=None,
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
@pytest.mark.parametrize(
"client_class,transport_class,transport_name,grpc_helpers",
[
(
RegionBackendServicesClient,
transports.RegionBackendServicesRestTransport,
"rest",
None,
),
],
)
def test_region_backend_services_client_client_options_credentials_file(
client_class, transport_class, transport_name, grpc_helpers
):
# Check the case credentials file is provided.
options = client_options.ClientOptions(credentials_file="credentials.json")
with mock.patch.object(transport_class, "__init__") as patched:
patched.return_value = None
client = client_class(client_options=options, transport=transport_name)
patched.assert_called_once_with(
credentials=None,
credentials_file="credentials.json",
host=client.DEFAULT_ENDPOINT,
scopes=None,
client_cert_source_for_mtls=None,
quota_project_id=None,
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
@pytest.mark.parametrize(
"request_type", [compute.DeleteRegionBackendServiceRequest, dict,]
)
def test_delete_unary_rest(request_type):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request = request_type(request_init)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.Operation(
client_operation_id="client_operation_id_value",
creation_timestamp="creation_timestamp_value",
description="description_value",
end_time="end_time_value",
http_error_message="http_error_message_value",
http_error_status_code=2374,
id=205,
insert_time="insert_time_value",
kind="kind_value",
name="name_value",
operation_group_id="operation_group_id_value",
operation_type="operation_type_value",
progress=885,
region="region_value",
self_link="self_link_value",
start_time="start_time_value",
status=compute.Operation.Status.DONE,
status_message="status_message_value",
target_id=947,
target_link="target_link_value",
user="user_value",
zone="zone_value",
)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.delete_unary(request)
# Establish that the response is the type that we expect.
assert isinstance(response, compute.Operation)
assert response.client_operation_id == "client_operation_id_value"
assert response.creation_timestamp == "creation_timestamp_value"
assert response.description == "description_value"
assert response.end_time == "end_time_value"
assert response.http_error_message == "http_error_message_value"
assert response.http_error_status_code == 2374
assert response.id == 205
assert response.insert_time == "insert_time_value"
assert response.kind == "kind_value"
assert response.name == "name_value"
assert response.operation_group_id == "operation_group_id_value"
assert response.operation_type == "operation_type_value"
assert response.progress == 885
assert response.region == "region_value"
assert response.self_link == "self_link_value"
assert response.start_time == "start_time_value"
assert response.status == compute.Operation.Status.DONE
assert response.status_message == "status_message_value"
assert response.target_id == 947
assert response.target_link == "target_link_value"
assert response.user == "user_value"
assert response.zone == "zone_value"
def test_delete_unary_rest_required_fields(
request_type=compute.DeleteRegionBackendServiceRequest,
):
transport_class = transports.RegionBackendServicesRestTransport
request_init = {}
request_init["backend_service"] = ""
request_init["project"] = ""
request_init["region"] = ""
request = request_type(request_init)
jsonified_request = json.loads(
request_type.to_json(
request, including_default_value_fields=False, use_integers_for_enums=False
)
)
# verify fields with default values are dropped
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).delete._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["backendService"] = "backend_service_value"
jsonified_request["project"] = "project_value"
jsonified_request["region"] = "region_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).delete._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
assert not set(unset_fields) - set(("request_id",))
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "backendService" in jsonified_request
assert jsonified_request["backendService"] == "backend_service_value"
assert "project" in jsonified_request
assert jsonified_request["project"] == "project_value"
assert "region" in jsonified_request
assert jsonified_request["region"] == "region_value"
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
request = request_type(request_init)
# Designate an appropriate value for the returned response.
return_value = compute.Operation()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
# for required fields will fail the real version if the http_options
# expect actual values for those fields.
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
transcode_result = {
"uri": "v1/sample_method",
"method": "delete",
"query_params": request_init,
}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.delete_unary(request)
expected_params = []
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
def test_delete_unary_rest_unset_required_fields():
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
unset_fields = transport.delete._get_unset_required_fields({})
assert set(unset_fields) == (
set(("requestId",)) & set(("backendService", "project", "region",))
)
@pytest.mark.parametrize("null_interceptor", [True, False])
def test_delete_unary_rest_interceptors(null_interceptor):
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
interceptor=None
if null_interceptor
else transports.RegionBackendServicesRestInterceptor(),
)
client = RegionBackendServicesClient(transport=transport)
with mock.patch.object(
type(client.transport._session), "request"
) as req, mock.patch.object(
path_template, "transcode"
) as transcode, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "post_delete"
) as post, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "pre_delete"
) as pre:
pre.assert_not_called()
post.assert_not_called()
transcode.return_value = {
"method": "post",
"uri": "my_uri",
"body": None,
"query_params": {},
}
req.return_value = Response()
req.return_value.status_code = 200
req.return_value.request = PreparedRequest()
req.return_value._content = compute.Operation.to_json(compute.Operation())
request = compute.DeleteRegionBackendServiceRequest()
metadata = [
("key", "val"),
("cephalopod", "squid"),
]
pre.return_value = request, metadata
post.return_value = compute.Operation
client.delete_unary(
request, metadata=[("key", "val"), ("cephalopod", "squid"),]
)
pre.assert_called_once()
post.assert_called_once()
def test_delete_unary_rest_bad_request(
transport: str = "rest", request_type=compute.DeleteRegionBackendServiceRequest
):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request = request_type(request_init)
# Mock the http request call within the method and fake a BadRequest error.
with mock.patch.object(Session, "request") as req, pytest.raises(
core_exceptions.BadRequest
):
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 400
response_value.request = Request()
req.return_value = response_value
client.delete_unary(request)
def test_delete_unary_rest_flattened():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.Operation()
# get arguments that satisfy an http rule for this method
sample_request = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
# get truthy value for each flattened field
mock_args = dict(
project="project_value",
region="region_value",
backend_service="backend_service_value",
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
client.delete_unary(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
"%s/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}"
% client.transport._host,
args[1],
)
def test_delete_unary_rest_flattened_error(transport: str = "rest"):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
client.delete_unary(
compute.DeleteRegionBackendServiceRequest(),
project="project_value",
region="region_value",
backend_service="backend_service_value",
)
def test_delete_unary_rest_error():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
@pytest.mark.parametrize(
"request_type", [compute.GetRegionBackendServiceRequest, dict,]
)
def test_get_rest(request_type):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request = request_type(request_init)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.BackendService(
affinity_cookie_ttl_sec=2432,
creation_timestamp="creation_timestamp_value",
custom_request_headers=["custom_request_headers_value"],
custom_response_headers=["custom_response_headers_value"],
description="description_value",
edge_security_policy="edge_security_policy_value",
enable_c_d_n=True,
fingerprint="fingerprint_value",
health_checks=["health_checks_value"],
id=205,
kind="kind_value",
load_balancing_scheme="load_balancing_scheme_value",
locality_lb_policy="locality_lb_policy_value",
name="name_value",
network="network_value",
port=453,
port_name="port_name_value",
protocol="protocol_value",
region="region_value",
security_policy="security_policy_value",
self_link="self_link_value",
session_affinity="session_affinity_value",
timeout_sec=1185,
)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.BackendService.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.get(request)
# Establish that the response is the type that we expect.
assert isinstance(response, compute.BackendService)
assert response.affinity_cookie_ttl_sec == 2432
assert response.creation_timestamp == "creation_timestamp_value"
assert response.custom_request_headers == ["custom_request_headers_value"]
assert response.custom_response_headers == ["custom_response_headers_value"]
assert response.description == "description_value"
assert response.edge_security_policy == "edge_security_policy_value"
assert response.enable_c_d_n is True
assert response.fingerprint == "fingerprint_value"
assert response.health_checks == ["health_checks_value"]
assert response.id == 205
assert response.kind == "kind_value"
assert response.load_balancing_scheme == "load_balancing_scheme_value"
assert response.locality_lb_policy == "locality_lb_policy_value"
assert response.name == "name_value"
assert response.network == "network_value"
assert response.port == 453
assert response.port_name == "port_name_value"
assert response.protocol == "protocol_value"
assert response.region == "region_value"
assert response.security_policy == "security_policy_value"
assert response.self_link == "self_link_value"
assert response.session_affinity == "session_affinity_value"
assert response.timeout_sec == 1185
def test_get_rest_required_fields(request_type=compute.GetRegionBackendServiceRequest):
transport_class = transports.RegionBackendServicesRestTransport
request_init = {}
request_init["backend_service"] = ""
request_init["project"] = ""
request_init["region"] = ""
request = request_type(request_init)
jsonified_request = json.loads(
request_type.to_json(
request, including_default_value_fields=False, use_integers_for_enums=False
)
)
# verify fields with default values are dropped
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).get._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["backendService"] = "backend_service_value"
jsonified_request["project"] = "project_value"
jsonified_request["region"] = "region_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).get._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "backendService" in jsonified_request
assert jsonified_request["backendService"] == "backend_service_value"
assert "project" in jsonified_request
assert jsonified_request["project"] == "project_value"
assert "region" in jsonified_request
assert jsonified_request["region"] == "region_value"
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
request = request_type(request_init)
# Designate an appropriate value for the returned response.
return_value = compute.BackendService()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
# for required fields will fail the real version if the http_options
# expect actual values for those fields.
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
transcode_result = {
"uri": "v1/sample_method",
"method": "get",
"query_params": request_init,
}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
json_return_value = compute.BackendService.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.get(request)
expected_params = []
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
def test_get_rest_unset_required_fields():
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
unset_fields = transport.get._get_unset_required_fields({})
assert set(unset_fields) == (
set(()) & set(("backendService", "project", "region",))
)
@pytest.mark.parametrize("null_interceptor", [True, False])
def test_get_rest_interceptors(null_interceptor):
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
interceptor=None
if null_interceptor
else transports.RegionBackendServicesRestInterceptor(),
)
client = RegionBackendServicesClient(transport=transport)
with mock.patch.object(
type(client.transport._session), "request"
) as req, mock.patch.object(
path_template, "transcode"
) as transcode, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "post_get"
) as post, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "pre_get"
) as pre:
pre.assert_not_called()
post.assert_not_called()
transcode.return_value = {
"method": "post",
"uri": "my_uri",
"body": None,
"query_params": {},
}
req.return_value = Response()
req.return_value.status_code = 200
req.return_value.request = PreparedRequest()
req.return_value._content = compute.BackendService.to_json(
compute.BackendService()
)
request = compute.GetRegionBackendServiceRequest()
metadata = [
("key", "val"),
("cephalopod", "squid"),
]
pre.return_value = request, metadata
post.return_value = compute.BackendService
client.get(request, metadata=[("key", "val"), ("cephalopod", "squid"),])
pre.assert_called_once()
post.assert_called_once()
def test_get_rest_bad_request(
transport: str = "rest", request_type=compute.GetRegionBackendServiceRequest
):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request = request_type(request_init)
# Mock the http request call within the method and fake a BadRequest error.
with mock.patch.object(Session, "request") as req, pytest.raises(
core_exceptions.BadRequest
):
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 400
response_value.request = Request()
req.return_value = response_value
client.get(request)
def test_get_rest_flattened():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.BackendService()
# get arguments that satisfy an http rule for this method
sample_request = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
# get truthy value for each flattened field
mock_args = dict(
project="project_value",
region="region_value",
backend_service="backend_service_value",
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.BackendService.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
client.get(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
"%s/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}"
% client.transport._host,
args[1],
)
def test_get_rest_flattened_error(transport: str = "rest"):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
client.get(
compute.GetRegionBackendServiceRequest(),
project="project_value",
region="region_value",
backend_service="backend_service_value",
)
def test_get_rest_error():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
@pytest.mark.parametrize(
"request_type", [compute.GetHealthRegionBackendServiceRequest, dict,]
)
def test_get_health_rest(request_type):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request_init["resource_group_reference_resource"] = {"group": "group_value"}
request = request_type(request_init)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.BackendServiceGroupHealth(kind="kind_value",)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.BackendServiceGroupHealth.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.get_health(request)
# Establish that the response is the type that we expect.
assert isinstance(response, compute.BackendServiceGroupHealth)
assert response.kind == "kind_value"
def test_get_health_rest_required_fields(
request_type=compute.GetHealthRegionBackendServiceRequest,
):
transport_class = transports.RegionBackendServicesRestTransport
request_init = {}
request_init["backend_service"] = ""
request_init["project"] = ""
request_init["region"] = ""
request = request_type(request_init)
jsonified_request = json.loads(
request_type.to_json(
request, including_default_value_fields=False, use_integers_for_enums=False
)
)
# verify fields with default values are dropped
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).get_health._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["backendService"] = "backend_service_value"
jsonified_request["project"] = "project_value"
jsonified_request["region"] = "region_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).get_health._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "backendService" in jsonified_request
assert jsonified_request["backendService"] == "backend_service_value"
assert "project" in jsonified_request
assert jsonified_request["project"] == "project_value"
assert "region" in jsonified_request
assert jsonified_request["region"] == "region_value"
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
request = request_type(request_init)
# Designate an appropriate value for the returned response.
return_value = compute.BackendServiceGroupHealth()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
# for required fields will fail the real version if the http_options
# expect actual values for those fields.
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
transcode_result = {
"uri": "v1/sample_method",
"method": "post",
"query_params": request_init,
}
transcode_result["body"] = {}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
json_return_value = compute.BackendServiceGroupHealth.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.get_health(request)
expected_params = []
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
def test_get_health_rest_unset_required_fields():
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
unset_fields = transport.get_health._get_unset_required_fields({})
assert set(unset_fields) == (
set(())
& set(
("backendService", "project", "region", "resourceGroupReferenceResource",)
)
)
@pytest.mark.parametrize("null_interceptor", [True, False])
def test_get_health_rest_interceptors(null_interceptor):
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
interceptor=None
if null_interceptor
else transports.RegionBackendServicesRestInterceptor(),
)
client = RegionBackendServicesClient(transport=transport)
with mock.patch.object(
type(client.transport._session), "request"
) as req, mock.patch.object(
path_template, "transcode"
) as transcode, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "post_get_health"
) as post, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "pre_get_health"
) as pre:
pre.assert_not_called()
post.assert_not_called()
transcode.return_value = {
"method": "post",
"uri": "my_uri",
"body": None,
"query_params": {},
}
req.return_value = Response()
req.return_value.status_code = 200
req.return_value.request = PreparedRequest()
req.return_value._content = compute.BackendServiceGroupHealth.to_json(
compute.BackendServiceGroupHealth()
)
request = compute.GetHealthRegionBackendServiceRequest()
metadata = [
("key", "val"),
("cephalopod", "squid"),
]
pre.return_value = request, metadata
post.return_value = compute.BackendServiceGroupHealth
client.get_health(request, metadata=[("key", "val"), ("cephalopod", "squid"),])
pre.assert_called_once()
post.assert_called_once()
def test_get_health_rest_bad_request(
transport: str = "rest", request_type=compute.GetHealthRegionBackendServiceRequest
):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request_init["resource_group_reference_resource"] = {"group": "group_value"}
request = request_type(request_init)
# Mock the http request call within the method and fake a BadRequest error.
with mock.patch.object(Session, "request") as req, pytest.raises(
core_exceptions.BadRequest
):
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 400
response_value.request = Request()
req.return_value = response_value
client.get_health(request)
def test_get_health_rest_flattened():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.BackendServiceGroupHealth()
# get arguments that satisfy an http rule for this method
sample_request = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
# get truthy value for each flattened field
mock_args = dict(
project="project_value",
region="region_value",
backend_service="backend_service_value",
resource_group_reference_resource=compute.ResourceGroupReference(
group="group_value"
),
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.BackendServiceGroupHealth.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
client.get_health(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
"%s/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}/getHealth"
% client.transport._host,
args[1],
)
def test_get_health_rest_flattened_error(transport: str = "rest"):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
client.get_health(
compute.GetHealthRegionBackendServiceRequest(),
project="project_value",
region="region_value",
backend_service="backend_service_value",
resource_group_reference_resource=compute.ResourceGroupReference(
group="group_value"
),
)
def test_get_health_rest_error():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
@pytest.mark.parametrize(
"request_type", [compute.InsertRegionBackendServiceRequest, dict,]
)
def test_insert_unary_rest(request_type):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# send a request that will satisfy transcoding
request_init = {"project": "sample1", "region": "sample2"}
request_init["backend_service_resource"] = {
"affinity_cookie_ttl_sec": 2432,
"backends": [
{
"balancing_mode": "balancing_mode_value",
"capacity_scaler": 0.1575,
"description": "description_value",
"failover": True,
"group": "group_value",
"max_connections": 1608,
"max_connections_per_endpoint": 2990,
"max_connections_per_instance": 2978,
"max_rate": 849,
"max_rate_per_endpoint": 0.22310000000000002,
"max_rate_per_instance": 0.22190000000000001,
"max_utilization": 0.1633,
}
],
"cdn_policy": {
"bypass_cache_on_request_headers": [{"header_name": "header_name_value"}],
"cache_key_policy": {
"include_host": True,
"include_http_headers": [
"include_http_headers_value_1",
"include_http_headers_value_2",
],
"include_named_cookies": [
"include_named_cookies_value_1",
"include_named_cookies_value_2",
],
"include_protocol": True,
"include_query_string": True,
"query_string_blacklist": [
"query_string_blacklist_value_1",
"query_string_blacklist_value_2",
],
"query_string_whitelist": [
"query_string_whitelist_value_1",
"query_string_whitelist_value_2",
],
},
"cache_mode": "cache_mode_value",
"client_ttl": 1074,
"default_ttl": 1176,
"max_ttl": 761,
"negative_caching": True,
"negative_caching_policy": [{"code": 411, "ttl": 340}],
"request_coalescing": True,
"serve_while_stale": 1813,
"signed_url_cache_max_age_sec": 2890,
"signed_url_key_names": [
"signed_url_key_names_value_1",
"signed_url_key_names_value_2",
],
},
"circuit_breakers": {
"max_connections": 1608,
"max_pending_requests": 2149,
"max_requests": 1313,
"max_requests_per_connection": 2902,
"max_retries": 1187,
},
"connection_draining": {"draining_timeout_sec": 2124},
"connection_tracking_policy": {
"connection_persistence_on_unhealthy_backends": "connection_persistence_on_unhealthy_backends_value",
"idle_timeout_sec": 1694,
"tracking_mode": "tracking_mode_value",
},
"consistent_hash": {
"http_cookie": {
"name": "name_value",
"path": "path_value",
"ttl": {"nanos": 543, "seconds": 751},
},
"http_header_name": "http_header_name_value",
"minimum_ring_size": 1829,
},
"creation_timestamp": "creation_timestamp_value",
"custom_request_headers": [
"custom_request_headers_value_1",
"custom_request_headers_value_2",
],
"custom_response_headers": [
"custom_response_headers_value_1",
"custom_response_headers_value_2",
],
"description": "description_value",
"edge_security_policy": "edge_security_policy_value",
"enable_c_d_n": True,
"failover_policy": {
"disable_connection_drain_on_failover": True,
"drop_traffic_if_unhealthy": True,
"failover_ratio": 0.1494,
},
"fingerprint": "fingerprint_value",
"health_checks": ["health_checks_value_1", "health_checks_value_2"],
"iap": {
"enabled": True,
"oauth2_client_id": "oauth2_client_id_value",
"oauth2_client_secret": "oauth2_client_secret_value",
"oauth2_client_secret_sha256": "oauth2_client_secret_sha256_value",
},
"id": 205,
"kind": "kind_value",
"load_balancing_scheme": "load_balancing_scheme_value",
"locality_lb_policy": "locality_lb_policy_value",
"log_config": {"enable": True, "sample_rate": 0.1165},
"max_stream_duration": {},
"name": "name_value",
"network": "network_value",
"outlier_detection": {
"base_ejection_time": {},
"consecutive_errors": 1956,
"consecutive_gateway_failure": 2880,
"enforcing_consecutive_errors": 3006,
"enforcing_consecutive_gateway_failure": 3930,
"enforcing_success_rate": 2334,
"interval": {},
"max_ejection_percent": 2118,
"success_rate_minimum_hosts": 2799,
"success_rate_request_volume": 2915,
"success_rate_stdev_factor": 2663,
},
"port": 453,
"port_name": "port_name_value",
"protocol": "protocol_value",
"region": "region_value",
"security_policy": "security_policy_value",
"security_settings": {
"client_tls_policy": "client_tls_policy_value",
"subject_alt_names": [
"subject_alt_names_value_1",
"subject_alt_names_value_2",
],
},
"self_link": "self_link_value",
"session_affinity": "session_affinity_value",
"subsetting": {"policy": "policy_value"},
"timeout_sec": 1185,
}
request = request_type(request_init)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.Operation(
client_operation_id="client_operation_id_value",
creation_timestamp="creation_timestamp_value",
description="description_value",
end_time="end_time_value",
http_error_message="http_error_message_value",
http_error_status_code=2374,
id=205,
insert_time="insert_time_value",
kind="kind_value",
name="name_value",
operation_group_id="operation_group_id_value",
operation_type="operation_type_value",
progress=885,
region="region_value",
self_link="self_link_value",
start_time="start_time_value",
status=compute.Operation.Status.DONE,
status_message="status_message_value",
target_id=947,
target_link="target_link_value",
user="user_value",
zone="zone_value",
)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.insert_unary(request)
# Establish that the response is the type that we expect.
assert isinstance(response, compute.Operation)
assert response.client_operation_id == "client_operation_id_value"
assert response.creation_timestamp == "creation_timestamp_value"
assert response.description == "description_value"
assert response.end_time == "end_time_value"
assert response.http_error_message == "http_error_message_value"
assert response.http_error_status_code == 2374
assert response.id == 205
assert response.insert_time == "insert_time_value"
assert response.kind == "kind_value"
assert response.name == "name_value"
assert response.operation_group_id == "operation_group_id_value"
assert response.operation_type == "operation_type_value"
assert response.progress == 885
assert response.region == "region_value"
assert response.self_link == "self_link_value"
assert response.start_time == "start_time_value"
assert response.status == compute.Operation.Status.DONE
assert response.status_message == "status_message_value"
assert response.target_id == 947
assert response.target_link == "target_link_value"
assert response.user == "user_value"
assert response.zone == "zone_value"
def test_insert_unary_rest_required_fields(
request_type=compute.InsertRegionBackendServiceRequest,
):
transport_class = transports.RegionBackendServicesRestTransport
request_init = {}
request_init["project"] = ""
request_init["region"] = ""
request = request_type(request_init)
jsonified_request = json.loads(
request_type.to_json(
request, including_default_value_fields=False, use_integers_for_enums=False
)
)
# verify fields with default values are dropped
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).insert._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["project"] = "project_value"
jsonified_request["region"] = "region_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).insert._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
assert not set(unset_fields) - set(("request_id",))
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "project" in jsonified_request
assert jsonified_request["project"] == "project_value"
assert "region" in jsonified_request
assert jsonified_request["region"] == "region_value"
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
request = request_type(request_init)
# Designate an appropriate value for the returned response.
return_value = compute.Operation()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
# for required fields will fail the real version if the http_options
# expect actual values for those fields.
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
transcode_result = {
"uri": "v1/sample_method",
"method": "post",
"query_params": request_init,
}
transcode_result["body"] = {}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.insert_unary(request)
expected_params = []
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
def test_insert_unary_rest_unset_required_fields():
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
unset_fields = transport.insert._get_unset_required_fields({})
assert set(unset_fields) == (
set(("requestId",)) & set(("backendServiceResource", "project", "region",))
)
@pytest.mark.parametrize("null_interceptor", [True, False])
def test_insert_unary_rest_interceptors(null_interceptor):
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
interceptor=None
if null_interceptor
else transports.RegionBackendServicesRestInterceptor(),
)
client = RegionBackendServicesClient(transport=transport)
with mock.patch.object(
type(client.transport._session), "request"
) as req, mock.patch.object(
path_template, "transcode"
) as transcode, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "post_insert"
) as post, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "pre_insert"
) as pre:
pre.assert_not_called()
post.assert_not_called()
transcode.return_value = {
"method": "post",
"uri": "my_uri",
"body": None,
"query_params": {},
}
req.return_value = Response()
req.return_value.status_code = 200
req.return_value.request = PreparedRequest()
req.return_value._content = compute.Operation.to_json(compute.Operation())
request = compute.InsertRegionBackendServiceRequest()
metadata = [
("key", "val"),
("cephalopod", "squid"),
]
pre.return_value = request, metadata
post.return_value = compute.Operation
client.insert_unary(
request, metadata=[("key", "val"), ("cephalopod", "squid"),]
)
pre.assert_called_once()
post.assert_called_once()
def test_insert_unary_rest_bad_request(
transport: str = "rest", request_type=compute.InsertRegionBackendServiceRequest
):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# send a request that will satisfy transcoding
request_init = {"project": "sample1", "region": "sample2"}
request_init["backend_service_resource"] = {
"affinity_cookie_ttl_sec": 2432,
"backends": [
{
"balancing_mode": "balancing_mode_value",
"capacity_scaler": 0.1575,
"description": "description_value",
"failover": True,
"group": "group_value",
"max_connections": 1608,
"max_connections_per_endpoint": 2990,
"max_connections_per_instance": 2978,
"max_rate": 849,
"max_rate_per_endpoint": 0.22310000000000002,
"max_rate_per_instance": 0.22190000000000001,
"max_utilization": 0.1633,
}
],
"cdn_policy": {
"bypass_cache_on_request_headers": [{"header_name": "header_name_value"}],
"cache_key_policy": {
"include_host": True,
"include_http_headers": [
"include_http_headers_value_1",
"include_http_headers_value_2",
],
"include_named_cookies": [
"include_named_cookies_value_1",
"include_named_cookies_value_2",
],
"include_protocol": True,
"include_query_string": True,
"query_string_blacklist": [
"query_string_blacklist_value_1",
"query_string_blacklist_value_2",
],
"query_string_whitelist": [
"query_string_whitelist_value_1",
"query_string_whitelist_value_2",
],
},
"cache_mode": "cache_mode_value",
"client_ttl": 1074,
"default_ttl": 1176,
"max_ttl": 761,
"negative_caching": True,
"negative_caching_policy": [{"code": 411, "ttl": 340}],
"request_coalescing": True,
"serve_while_stale": 1813,
"signed_url_cache_max_age_sec": 2890,
"signed_url_key_names": [
"signed_url_key_names_value_1",
"signed_url_key_names_value_2",
],
},
"circuit_breakers": {
"max_connections": 1608,
"max_pending_requests": 2149,
"max_requests": 1313,
"max_requests_per_connection": 2902,
"max_retries": 1187,
},
"connection_draining": {"draining_timeout_sec": 2124},
"connection_tracking_policy": {
"connection_persistence_on_unhealthy_backends": "connection_persistence_on_unhealthy_backends_value",
"idle_timeout_sec": 1694,
"tracking_mode": "tracking_mode_value",
},
"consistent_hash": {
"http_cookie": {
"name": "name_value",
"path": "path_value",
"ttl": {"nanos": 543, "seconds": 751},
},
"http_header_name": "http_header_name_value",
"minimum_ring_size": 1829,
},
"creation_timestamp": "creation_timestamp_value",
"custom_request_headers": [
"custom_request_headers_value_1",
"custom_request_headers_value_2",
],
"custom_response_headers": [
"custom_response_headers_value_1",
"custom_response_headers_value_2",
],
"description": "description_value",
"edge_security_policy": "edge_security_policy_value",
"enable_c_d_n": True,
"failover_policy": {
"disable_connection_drain_on_failover": True,
"drop_traffic_if_unhealthy": True,
"failover_ratio": 0.1494,
},
"fingerprint": "fingerprint_value",
"health_checks": ["health_checks_value_1", "health_checks_value_2"],
"iap": {
"enabled": True,
"oauth2_client_id": "oauth2_client_id_value",
"oauth2_client_secret": "oauth2_client_secret_value",
"oauth2_client_secret_sha256": "oauth2_client_secret_sha256_value",
},
"id": 205,
"kind": "kind_value",
"load_balancing_scheme": "load_balancing_scheme_value",
"locality_lb_policy": "locality_lb_policy_value",
"log_config": {"enable": True, "sample_rate": 0.1165},
"max_stream_duration": {},
"name": "name_value",
"network": "network_value",
"outlier_detection": {
"base_ejection_time": {},
"consecutive_errors": 1956,
"consecutive_gateway_failure": 2880,
"enforcing_consecutive_errors": 3006,
"enforcing_consecutive_gateway_failure": 3930,
"enforcing_success_rate": 2334,
"interval": {},
"max_ejection_percent": 2118,
"success_rate_minimum_hosts": 2799,
"success_rate_request_volume": 2915,
"success_rate_stdev_factor": 2663,
},
"port": 453,
"port_name": "port_name_value",
"protocol": "protocol_value",
"region": "region_value",
"security_policy": "security_policy_value",
"security_settings": {
"client_tls_policy": "client_tls_policy_value",
"subject_alt_names": [
"subject_alt_names_value_1",
"subject_alt_names_value_2",
],
},
"self_link": "self_link_value",
"session_affinity": "session_affinity_value",
"subsetting": {"policy": "policy_value"},
"timeout_sec": 1185,
}
request = request_type(request_init)
# Mock the http request call within the method and fake a BadRequest error.
with mock.patch.object(Session, "request") as req, pytest.raises(
core_exceptions.BadRequest
):
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 400
response_value.request = Request()
req.return_value = response_value
client.insert_unary(request)
def test_insert_unary_rest_flattened():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.Operation()
# get arguments that satisfy an http rule for this method
sample_request = {"project": "sample1", "region": "sample2"}
# get truthy value for each flattened field
mock_args = dict(
project="project_value",
region="region_value",
backend_service_resource=compute.BackendService(
affinity_cookie_ttl_sec=2432
),
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
client.insert_unary(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
"%s/compute/v1/projects/{project}/regions/{region}/backendServices"
% client.transport._host,
args[1],
)
def test_insert_unary_rest_flattened_error(transport: str = "rest"):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
client.insert_unary(
compute.InsertRegionBackendServiceRequest(),
project="project_value",
region="region_value",
backend_service_resource=compute.BackendService(
affinity_cookie_ttl_sec=2432
),
)
def test_insert_unary_rest_error():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
@pytest.mark.parametrize(
"request_type", [compute.ListRegionBackendServicesRequest, dict,]
)
def test_list_rest(request_type):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# send a request that will satisfy transcoding
request_init = {"project": "sample1", "region": "sample2"}
request = request_type(request_init)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.BackendServiceList(
id="id_value",
kind="kind_value",
next_page_token="next_page_token_value",
self_link="self_link_value",
)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.BackendServiceList.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.list(request)
# Establish that the response is the type that we expect.
assert isinstance(response, pagers.ListPager)
assert response.id == "id_value"
assert response.kind == "kind_value"
assert response.next_page_token == "next_page_token_value"
assert response.self_link == "self_link_value"
def test_list_rest_required_fields(
request_type=compute.ListRegionBackendServicesRequest,
):
transport_class = transports.RegionBackendServicesRestTransport
request_init = {}
request_init["project"] = ""
request_init["region"] = ""
request = request_type(request_init)
jsonified_request = json.loads(
request_type.to_json(
request, including_default_value_fields=False, use_integers_for_enums=False
)
)
# verify fields with default values are dropped
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).list._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["project"] = "project_value"
jsonified_request["region"] = "region_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).list._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
assert not set(unset_fields) - set(
("filter", "max_results", "order_by", "page_token", "return_partial_success",)
)
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "project" in jsonified_request
assert jsonified_request["project"] == "project_value"
assert "region" in jsonified_request
assert jsonified_request["region"] == "region_value"
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
request = request_type(request_init)
# Designate an appropriate value for the returned response.
return_value = compute.BackendServiceList()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
# for required fields will fail the real version if the http_options
# expect actual values for those fields.
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
transcode_result = {
"uri": "v1/sample_method",
"method": "get",
"query_params": request_init,
}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
json_return_value = compute.BackendServiceList.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.list(request)
expected_params = []
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
def test_list_rest_unset_required_fields():
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
unset_fields = transport.list._get_unset_required_fields({})
assert set(unset_fields) == (
set(("filter", "maxResults", "orderBy", "pageToken", "returnPartialSuccess",))
& set(("project", "region",))
)
@pytest.mark.parametrize("null_interceptor", [True, False])
def test_list_rest_interceptors(null_interceptor):
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
interceptor=None
if null_interceptor
else transports.RegionBackendServicesRestInterceptor(),
)
client = RegionBackendServicesClient(transport=transport)
with mock.patch.object(
type(client.transport._session), "request"
) as req, mock.patch.object(
path_template, "transcode"
) as transcode, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "post_list"
) as post, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "pre_list"
) as pre:
pre.assert_not_called()
post.assert_not_called()
transcode.return_value = {
"method": "post",
"uri": "my_uri",
"body": None,
"query_params": {},
}
req.return_value = Response()
req.return_value.status_code = 200
req.return_value.request = PreparedRequest()
req.return_value._content = compute.BackendServiceList.to_json(
compute.BackendServiceList()
)
request = compute.ListRegionBackendServicesRequest()
metadata = [
("key", "val"),
("cephalopod", "squid"),
]
pre.return_value = request, metadata
post.return_value = compute.BackendServiceList
client.list(request, metadata=[("key", "val"), ("cephalopod", "squid"),])
pre.assert_called_once()
post.assert_called_once()
def test_list_rest_bad_request(
transport: str = "rest", request_type=compute.ListRegionBackendServicesRequest
):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# send a request that will satisfy transcoding
request_init = {"project": "sample1", "region": "sample2"}
request = request_type(request_init)
# Mock the http request call within the method and fake a BadRequest error.
with mock.patch.object(Session, "request") as req, pytest.raises(
core_exceptions.BadRequest
):
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 400
response_value.request = Request()
req.return_value = response_value
client.list(request)
def test_list_rest_flattened():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.BackendServiceList()
# get arguments that satisfy an http rule for this method
sample_request = {"project": "sample1", "region": "sample2"}
# get truthy value for each flattened field
mock_args = dict(project="project_value", region="region_value",)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.BackendServiceList.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
client.list(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
"%s/compute/v1/projects/{project}/regions/{region}/backendServices"
% client.transport._host,
args[1],
)
def test_list_rest_flattened_error(transport: str = "rest"):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
client.list(
compute.ListRegionBackendServicesRequest(),
project="project_value",
region="region_value",
)
def test_list_rest_pager(transport: str = "rest"):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# TODO(kbandes): remove this mock unless there's a good reason for it.
# with mock.patch.object(path_template, 'transcode') as transcode:
# Set the response as a series of pages
response = (
compute.BackendServiceList(
items=[
compute.BackendService(),
compute.BackendService(),
compute.BackendService(),
],
next_page_token="abc",
),
compute.BackendServiceList(items=[], next_page_token="def",),
compute.BackendServiceList(
items=[compute.BackendService(),], next_page_token="ghi",
),
compute.BackendServiceList(
items=[compute.BackendService(), compute.BackendService(),],
),
)
# Two responses for two calls
response = response + response
# Wrap the values into proper Response objs
response = tuple(compute.BackendServiceList.to_json(x) for x in response)
return_values = tuple(Response() for i in response)
for return_val, response_val in zip(return_values, response):
return_val._content = response_val.encode("UTF-8")
return_val.status_code = 200
req.side_effect = return_values
sample_request = {"project": "sample1", "region": "sample2"}
pager = client.list(request=sample_request)
results = list(pager)
assert len(results) == 6
assert all(isinstance(i, compute.BackendService) for i in results)
pages = list(client.list(request=sample_request).pages)
for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
assert page_.raw_page.next_page_token == token
@pytest.mark.parametrize(
"request_type", [compute.PatchRegionBackendServiceRequest, dict,]
)
def test_patch_unary_rest(request_type):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request_init["backend_service_resource"] = {
"affinity_cookie_ttl_sec": 2432,
"backends": [
{
"balancing_mode": "balancing_mode_value",
"capacity_scaler": 0.1575,
"description": "description_value",
"failover": True,
"group": "group_value",
"max_connections": 1608,
"max_connections_per_endpoint": 2990,
"max_connections_per_instance": 2978,
"max_rate": 849,
"max_rate_per_endpoint": 0.22310000000000002,
"max_rate_per_instance": 0.22190000000000001,
"max_utilization": 0.1633,
}
],
"cdn_policy": {
"bypass_cache_on_request_headers": [{"header_name": "header_name_value"}],
"cache_key_policy": {
"include_host": True,
"include_http_headers": [
"include_http_headers_value_1",
"include_http_headers_value_2",
],
"include_named_cookies": [
"include_named_cookies_value_1",
"include_named_cookies_value_2",
],
"include_protocol": True,
"include_query_string": True,
"query_string_blacklist": [
"query_string_blacklist_value_1",
"query_string_blacklist_value_2",
],
"query_string_whitelist": [
"query_string_whitelist_value_1",
"query_string_whitelist_value_2",
],
},
"cache_mode": "cache_mode_value",
"client_ttl": 1074,
"default_ttl": 1176,
"max_ttl": 761,
"negative_caching": True,
"negative_caching_policy": [{"code": 411, "ttl": 340}],
"request_coalescing": True,
"serve_while_stale": 1813,
"signed_url_cache_max_age_sec": 2890,
"signed_url_key_names": [
"signed_url_key_names_value_1",
"signed_url_key_names_value_2",
],
},
"circuit_breakers": {
"max_connections": 1608,
"max_pending_requests": 2149,
"max_requests": 1313,
"max_requests_per_connection": 2902,
"max_retries": 1187,
},
"connection_draining": {"draining_timeout_sec": 2124},
"connection_tracking_policy": {
"connection_persistence_on_unhealthy_backends": "connection_persistence_on_unhealthy_backends_value",
"idle_timeout_sec": 1694,
"tracking_mode": "tracking_mode_value",
},
"consistent_hash": {
"http_cookie": {
"name": "name_value",
"path": "path_value",
"ttl": {"nanos": 543, "seconds": 751},
},
"http_header_name": "http_header_name_value",
"minimum_ring_size": 1829,
},
"creation_timestamp": "creation_timestamp_value",
"custom_request_headers": [
"custom_request_headers_value_1",
"custom_request_headers_value_2",
],
"custom_response_headers": [
"custom_response_headers_value_1",
"custom_response_headers_value_2",
],
"description": "description_value",
"edge_security_policy": "edge_security_policy_value",
"enable_c_d_n": True,
"failover_policy": {
"disable_connection_drain_on_failover": True,
"drop_traffic_if_unhealthy": True,
"failover_ratio": 0.1494,
},
"fingerprint": "fingerprint_value",
"health_checks": ["health_checks_value_1", "health_checks_value_2"],
"iap": {
"enabled": True,
"oauth2_client_id": "oauth2_client_id_value",
"oauth2_client_secret": "oauth2_client_secret_value",
"oauth2_client_secret_sha256": "oauth2_client_secret_sha256_value",
},
"id": 205,
"kind": "kind_value",
"load_balancing_scheme": "load_balancing_scheme_value",
"locality_lb_policy": "locality_lb_policy_value",
"log_config": {"enable": True, "sample_rate": 0.1165},
"max_stream_duration": {},
"name": "name_value",
"network": "network_value",
"outlier_detection": {
"base_ejection_time": {},
"consecutive_errors": 1956,
"consecutive_gateway_failure": 2880,
"enforcing_consecutive_errors": 3006,
"enforcing_consecutive_gateway_failure": 3930,
"enforcing_success_rate": 2334,
"interval": {},
"max_ejection_percent": 2118,
"success_rate_minimum_hosts": 2799,
"success_rate_request_volume": 2915,
"success_rate_stdev_factor": 2663,
},
"port": 453,
"port_name": "port_name_value",
"protocol": "protocol_value",
"region": "region_value",
"security_policy": "security_policy_value",
"security_settings": {
"client_tls_policy": "client_tls_policy_value",
"subject_alt_names": [
"subject_alt_names_value_1",
"subject_alt_names_value_2",
],
},
"self_link": "self_link_value",
"session_affinity": "session_affinity_value",
"subsetting": {"policy": "policy_value"},
"timeout_sec": 1185,
}
request = request_type(request_init)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.Operation(
client_operation_id="client_operation_id_value",
creation_timestamp="creation_timestamp_value",
description="description_value",
end_time="end_time_value",
http_error_message="http_error_message_value",
http_error_status_code=2374,
id=205,
insert_time="insert_time_value",
kind="kind_value",
name="name_value",
operation_group_id="operation_group_id_value",
operation_type="operation_type_value",
progress=885,
region="region_value",
self_link="self_link_value",
start_time="start_time_value",
status=compute.Operation.Status.DONE,
status_message="status_message_value",
target_id=947,
target_link="target_link_value",
user="user_value",
zone="zone_value",
)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.patch_unary(request)
# Establish that the response is the type that we expect.
assert isinstance(response, compute.Operation)
assert response.client_operation_id == "client_operation_id_value"
assert response.creation_timestamp == "creation_timestamp_value"
assert response.description == "description_value"
assert response.end_time == "end_time_value"
assert response.http_error_message == "http_error_message_value"
assert response.http_error_status_code == 2374
assert response.id == 205
assert response.insert_time == "insert_time_value"
assert response.kind == "kind_value"
assert response.name == "name_value"
assert response.operation_group_id == "operation_group_id_value"
assert response.operation_type == "operation_type_value"
assert response.progress == 885
assert response.region == "region_value"
assert response.self_link == "self_link_value"
assert response.start_time == "start_time_value"
assert response.status == compute.Operation.Status.DONE
assert response.status_message == "status_message_value"
assert response.target_id == 947
assert response.target_link == "target_link_value"
assert response.user == "user_value"
assert response.zone == "zone_value"
def test_patch_unary_rest_required_fields(
request_type=compute.PatchRegionBackendServiceRequest,
):
transport_class = transports.RegionBackendServicesRestTransport
request_init = {}
request_init["backend_service"] = ""
request_init["project"] = ""
request_init["region"] = ""
request = request_type(request_init)
jsonified_request = json.loads(
request_type.to_json(
request, including_default_value_fields=False, use_integers_for_enums=False
)
)
# verify fields with default values are dropped
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).patch._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["backendService"] = "backend_service_value"
jsonified_request["project"] = "project_value"
jsonified_request["region"] = "region_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).patch._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
assert not set(unset_fields) - set(("request_id",))
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "backendService" in jsonified_request
assert jsonified_request["backendService"] == "backend_service_value"
assert "project" in jsonified_request
assert jsonified_request["project"] == "project_value"
assert "region" in jsonified_request
assert jsonified_request["region"] == "region_value"
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
request = request_type(request_init)
# Designate an appropriate value for the returned response.
return_value = compute.Operation()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
# for required fields will fail the real version if the http_options
# expect actual values for those fields.
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
transcode_result = {
"uri": "v1/sample_method",
"method": "patch",
"query_params": request_init,
}
transcode_result["body"] = {}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.patch_unary(request)
expected_params = []
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
def test_patch_unary_rest_unset_required_fields():
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
unset_fields = transport.patch._get_unset_required_fields({})
assert set(unset_fields) == (
set(("requestId",))
& set(("backendService", "backendServiceResource", "project", "region",))
)
@pytest.mark.parametrize("null_interceptor", [True, False])
def test_patch_unary_rest_interceptors(null_interceptor):
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
interceptor=None
if null_interceptor
else transports.RegionBackendServicesRestInterceptor(),
)
client = RegionBackendServicesClient(transport=transport)
with mock.patch.object(
type(client.transport._session), "request"
) as req, mock.patch.object(
path_template, "transcode"
) as transcode, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "post_patch"
) as post, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "pre_patch"
) as pre:
pre.assert_not_called()
post.assert_not_called()
transcode.return_value = {
"method": "post",
"uri": "my_uri",
"body": None,
"query_params": {},
}
req.return_value = Response()
req.return_value.status_code = 200
req.return_value.request = PreparedRequest()
req.return_value._content = compute.Operation.to_json(compute.Operation())
request = compute.PatchRegionBackendServiceRequest()
metadata = [
("key", "val"),
("cephalopod", "squid"),
]
pre.return_value = request, metadata
post.return_value = compute.Operation
client.patch_unary(request, metadata=[("key", "val"), ("cephalopod", "squid"),])
pre.assert_called_once()
post.assert_called_once()
def test_patch_unary_rest_bad_request(
transport: str = "rest", request_type=compute.PatchRegionBackendServiceRequest
):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request_init["backend_service_resource"] = {
"affinity_cookie_ttl_sec": 2432,
"backends": [
{
"balancing_mode": "balancing_mode_value",
"capacity_scaler": 0.1575,
"description": "description_value",
"failover": True,
"group": "group_value",
"max_connections": 1608,
"max_connections_per_endpoint": 2990,
"max_connections_per_instance": 2978,
"max_rate": 849,
"max_rate_per_endpoint": 0.22310000000000002,
"max_rate_per_instance": 0.22190000000000001,
"max_utilization": 0.1633,
}
],
"cdn_policy": {
"bypass_cache_on_request_headers": [{"header_name": "header_name_value"}],
"cache_key_policy": {
"include_host": True,
"include_http_headers": [
"include_http_headers_value_1",
"include_http_headers_value_2",
],
"include_named_cookies": [
"include_named_cookies_value_1",
"include_named_cookies_value_2",
],
"include_protocol": True,
"include_query_string": True,
"query_string_blacklist": [
"query_string_blacklist_value_1",
"query_string_blacklist_value_2",
],
"query_string_whitelist": [
"query_string_whitelist_value_1",
"query_string_whitelist_value_2",
],
},
"cache_mode": "cache_mode_value",
"client_ttl": 1074,
"default_ttl": 1176,
"max_ttl": 761,
"negative_caching": True,
"negative_caching_policy": [{"code": 411, "ttl": 340}],
"request_coalescing": True,
"serve_while_stale": 1813,
"signed_url_cache_max_age_sec": 2890,
"signed_url_key_names": [
"signed_url_key_names_value_1",
"signed_url_key_names_value_2",
],
},
"circuit_breakers": {
"max_connections": 1608,
"max_pending_requests": 2149,
"max_requests": 1313,
"max_requests_per_connection": 2902,
"max_retries": 1187,
},
"connection_draining": {"draining_timeout_sec": 2124},
"connection_tracking_policy": {
"connection_persistence_on_unhealthy_backends": "connection_persistence_on_unhealthy_backends_value",
"idle_timeout_sec": 1694,
"tracking_mode": "tracking_mode_value",
},
"consistent_hash": {
"http_cookie": {
"name": "name_value",
"path": "path_value",
"ttl": {"nanos": 543, "seconds": 751},
},
"http_header_name": "http_header_name_value",
"minimum_ring_size": 1829,
},
"creation_timestamp": "creation_timestamp_value",
"custom_request_headers": [
"custom_request_headers_value_1",
"custom_request_headers_value_2",
],
"custom_response_headers": [
"custom_response_headers_value_1",
"custom_response_headers_value_2",
],
"description": "description_value",
"edge_security_policy": "edge_security_policy_value",
"enable_c_d_n": True,
"failover_policy": {
"disable_connection_drain_on_failover": True,
"drop_traffic_if_unhealthy": True,
"failover_ratio": 0.1494,
},
"fingerprint": "fingerprint_value",
"health_checks": ["health_checks_value_1", "health_checks_value_2"],
"iap": {
"enabled": True,
"oauth2_client_id": "oauth2_client_id_value",
"oauth2_client_secret": "oauth2_client_secret_value",
"oauth2_client_secret_sha256": "oauth2_client_secret_sha256_value",
},
"id": 205,
"kind": "kind_value",
"load_balancing_scheme": "load_balancing_scheme_value",
"locality_lb_policy": "locality_lb_policy_value",
"log_config": {"enable": True, "sample_rate": 0.1165},
"max_stream_duration": {},
"name": "name_value",
"network": "network_value",
"outlier_detection": {
"base_ejection_time": {},
"consecutive_errors": 1956,
"consecutive_gateway_failure": 2880,
"enforcing_consecutive_errors": 3006,
"enforcing_consecutive_gateway_failure": 3930,
"enforcing_success_rate": 2334,
"interval": {},
"max_ejection_percent": 2118,
"success_rate_minimum_hosts": 2799,
"success_rate_request_volume": 2915,
"success_rate_stdev_factor": 2663,
},
"port": 453,
"port_name": "port_name_value",
"protocol": "protocol_value",
"region": "region_value",
"security_policy": "security_policy_value",
"security_settings": {
"client_tls_policy": "client_tls_policy_value",
"subject_alt_names": [
"subject_alt_names_value_1",
"subject_alt_names_value_2",
],
},
"self_link": "self_link_value",
"session_affinity": "session_affinity_value",
"subsetting": {"policy": "policy_value"},
"timeout_sec": 1185,
}
request = request_type(request_init)
# Mock the http request call within the method and fake a BadRequest error.
with mock.patch.object(Session, "request") as req, pytest.raises(
core_exceptions.BadRequest
):
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 400
response_value.request = Request()
req.return_value = response_value
client.patch_unary(request)
def test_patch_unary_rest_flattened():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.Operation()
# get arguments that satisfy an http rule for this method
sample_request = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
# get truthy value for each flattened field
mock_args = dict(
project="project_value",
region="region_value",
backend_service="backend_service_value",
backend_service_resource=compute.BackendService(
affinity_cookie_ttl_sec=2432
),
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
client.patch_unary(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
"%s/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}"
% client.transport._host,
args[1],
)
def test_patch_unary_rest_flattened_error(transport: str = "rest"):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
client.patch_unary(
compute.PatchRegionBackendServiceRequest(),
project="project_value",
region="region_value",
backend_service="backend_service_value",
backend_service_resource=compute.BackendService(
affinity_cookie_ttl_sec=2432
),
)
def test_patch_unary_rest_error():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
@pytest.mark.parametrize(
"request_type", [compute.UpdateRegionBackendServiceRequest, dict,]
)
def test_update_unary_rest(request_type):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request_init["backend_service_resource"] = {
"affinity_cookie_ttl_sec": 2432,
"backends": [
{
"balancing_mode": "balancing_mode_value",
"capacity_scaler": 0.1575,
"description": "description_value",
"failover": True,
"group": "group_value",
"max_connections": 1608,
"max_connections_per_endpoint": 2990,
"max_connections_per_instance": 2978,
"max_rate": 849,
"max_rate_per_endpoint": 0.22310000000000002,
"max_rate_per_instance": 0.22190000000000001,
"max_utilization": 0.1633,
}
],
"cdn_policy": {
"bypass_cache_on_request_headers": [{"header_name": "header_name_value"}],
"cache_key_policy": {
"include_host": True,
"include_http_headers": [
"include_http_headers_value_1",
"include_http_headers_value_2",
],
"include_named_cookies": [
"include_named_cookies_value_1",
"include_named_cookies_value_2",
],
"include_protocol": True,
"include_query_string": True,
"query_string_blacklist": [
"query_string_blacklist_value_1",
"query_string_blacklist_value_2",
],
"query_string_whitelist": [
"query_string_whitelist_value_1",
"query_string_whitelist_value_2",
],
},
"cache_mode": "cache_mode_value",
"client_ttl": 1074,
"default_ttl": 1176,
"max_ttl": 761,
"negative_caching": True,
"negative_caching_policy": [{"code": 411, "ttl": 340}],
"request_coalescing": True,
"serve_while_stale": 1813,
"signed_url_cache_max_age_sec": 2890,
"signed_url_key_names": [
"signed_url_key_names_value_1",
"signed_url_key_names_value_2",
],
},
"circuit_breakers": {
"max_connections": 1608,
"max_pending_requests": 2149,
"max_requests": 1313,
"max_requests_per_connection": 2902,
"max_retries": 1187,
},
"connection_draining": {"draining_timeout_sec": 2124},
"connection_tracking_policy": {
"connection_persistence_on_unhealthy_backends": "connection_persistence_on_unhealthy_backends_value",
"idle_timeout_sec": 1694,
"tracking_mode": "tracking_mode_value",
},
"consistent_hash": {
"http_cookie": {
"name": "name_value",
"path": "path_value",
"ttl": {"nanos": 543, "seconds": 751},
},
"http_header_name": "http_header_name_value",
"minimum_ring_size": 1829,
},
"creation_timestamp": "creation_timestamp_value",
"custom_request_headers": [
"custom_request_headers_value_1",
"custom_request_headers_value_2",
],
"custom_response_headers": [
"custom_response_headers_value_1",
"custom_response_headers_value_2",
],
"description": "description_value",
"edge_security_policy": "edge_security_policy_value",
"enable_c_d_n": True,
"failover_policy": {
"disable_connection_drain_on_failover": True,
"drop_traffic_if_unhealthy": True,
"failover_ratio": 0.1494,
},
"fingerprint": "fingerprint_value",
"health_checks": ["health_checks_value_1", "health_checks_value_2"],
"iap": {
"enabled": True,
"oauth2_client_id": "oauth2_client_id_value",
"oauth2_client_secret": "oauth2_client_secret_value",
"oauth2_client_secret_sha256": "oauth2_client_secret_sha256_value",
},
"id": 205,
"kind": "kind_value",
"load_balancing_scheme": "load_balancing_scheme_value",
"locality_lb_policy": "locality_lb_policy_value",
"log_config": {"enable": True, "sample_rate": 0.1165},
"max_stream_duration": {},
"name": "name_value",
"network": "network_value",
"outlier_detection": {
"base_ejection_time": {},
"consecutive_errors": 1956,
"consecutive_gateway_failure": 2880,
"enforcing_consecutive_errors": 3006,
"enforcing_consecutive_gateway_failure": 3930,
"enforcing_success_rate": 2334,
"interval": {},
"max_ejection_percent": 2118,
"success_rate_minimum_hosts": 2799,
"success_rate_request_volume": 2915,
"success_rate_stdev_factor": 2663,
},
"port": 453,
"port_name": "port_name_value",
"protocol": "protocol_value",
"region": "region_value",
"security_policy": "security_policy_value",
"security_settings": {
"client_tls_policy": "client_tls_policy_value",
"subject_alt_names": [
"subject_alt_names_value_1",
"subject_alt_names_value_2",
],
},
"self_link": "self_link_value",
"session_affinity": "session_affinity_value",
"subsetting": {"policy": "policy_value"},
"timeout_sec": 1185,
}
request = request_type(request_init)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.Operation(
client_operation_id="client_operation_id_value",
creation_timestamp="creation_timestamp_value",
description="description_value",
end_time="end_time_value",
http_error_message="http_error_message_value",
http_error_status_code=2374,
id=205,
insert_time="insert_time_value",
kind="kind_value",
name="name_value",
operation_group_id="operation_group_id_value",
operation_type="operation_type_value",
progress=885,
region="region_value",
self_link="self_link_value",
start_time="start_time_value",
status=compute.Operation.Status.DONE,
status_message="status_message_value",
target_id=947,
target_link="target_link_value",
user="user_value",
zone="zone_value",
)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.update_unary(request)
# Establish that the response is the type that we expect.
assert isinstance(response, compute.Operation)
assert response.client_operation_id == "client_operation_id_value"
assert response.creation_timestamp == "creation_timestamp_value"
assert response.description == "description_value"
assert response.end_time == "end_time_value"
assert response.http_error_message == "http_error_message_value"
assert response.http_error_status_code == 2374
assert response.id == 205
assert response.insert_time == "insert_time_value"
assert response.kind == "kind_value"
assert response.name == "name_value"
assert response.operation_group_id == "operation_group_id_value"
assert response.operation_type == "operation_type_value"
assert response.progress == 885
assert response.region == "region_value"
assert response.self_link == "self_link_value"
assert response.start_time == "start_time_value"
assert response.status == compute.Operation.Status.DONE
assert response.status_message == "status_message_value"
assert response.target_id == 947
assert response.target_link == "target_link_value"
assert response.user == "user_value"
assert response.zone == "zone_value"
def test_update_unary_rest_required_fields(
request_type=compute.UpdateRegionBackendServiceRequest,
):
transport_class = transports.RegionBackendServicesRestTransport
request_init = {}
request_init["backend_service"] = ""
request_init["project"] = ""
request_init["region"] = ""
request = request_type(request_init)
jsonified_request = json.loads(
request_type.to_json(
request, including_default_value_fields=False, use_integers_for_enums=False
)
)
# verify fields with default values are dropped
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).update._get_unset_required_fields(jsonified_request)
jsonified_request.update(unset_fields)
# verify required fields with default values are now present
jsonified_request["backendService"] = "backend_service_value"
jsonified_request["project"] = "project_value"
jsonified_request["region"] = "region_value"
unset_fields = transport_class(
credentials=ga_credentials.AnonymousCredentials()
).update._get_unset_required_fields(jsonified_request)
# Check that path parameters and body parameters are not mixing in.
assert not set(unset_fields) - set(("request_id",))
jsonified_request.update(unset_fields)
# verify required fields with non-default values are left alone
assert "backendService" in jsonified_request
assert jsonified_request["backendService"] == "backend_service_value"
assert "project" in jsonified_request
assert jsonified_request["project"] == "project_value"
assert "region" in jsonified_request
assert jsonified_request["region"] == "region_value"
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
request = request_type(request_init)
# Designate an appropriate value for the returned response.
return_value = compute.Operation()
# Mock the http request call within the method and fake a response.
with mock.patch.object(Session, "request") as req:
# We need to mock transcode() because providing default values
# for required fields will fail the real version if the http_options
# expect actual values for those fields.
with mock.patch.object(path_template, "transcode") as transcode:
# A uri without fields and an empty body will force all the
# request fields to show up in the query_params.
transcode_result = {
"uri": "v1/sample_method",
"method": "put",
"query_params": request_init,
}
transcode_result["body"] = {}
transcode.return_value = transcode_result
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
response = client.update_unary(request)
expected_params = []
actual_params = req.call_args.kwargs["params"]
assert expected_params == actual_params
def test_update_unary_rest_unset_required_fields():
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials
)
unset_fields = transport.update._get_unset_required_fields({})
assert set(unset_fields) == (
set(("requestId",))
& set(("backendService", "backendServiceResource", "project", "region",))
)
@pytest.mark.parametrize("null_interceptor", [True, False])
def test_update_unary_rest_interceptors(null_interceptor):
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
interceptor=None
if null_interceptor
else transports.RegionBackendServicesRestInterceptor(),
)
client = RegionBackendServicesClient(transport=transport)
with mock.patch.object(
type(client.transport._session), "request"
) as req, mock.patch.object(
path_template, "transcode"
) as transcode, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "post_update"
) as post, mock.patch.object(
transports.RegionBackendServicesRestInterceptor, "pre_update"
) as pre:
pre.assert_not_called()
post.assert_not_called()
transcode.return_value = {
"method": "post",
"uri": "my_uri",
"body": None,
"query_params": {},
}
req.return_value = Response()
req.return_value.status_code = 200
req.return_value.request = PreparedRequest()
req.return_value._content = compute.Operation.to_json(compute.Operation())
request = compute.UpdateRegionBackendServiceRequest()
metadata = [
("key", "val"),
("cephalopod", "squid"),
]
pre.return_value = request, metadata
post.return_value = compute.Operation
client.update_unary(
request, metadata=[("key", "val"), ("cephalopod", "squid"),]
)
pre.assert_called_once()
post.assert_called_once()
def test_update_unary_rest_bad_request(
transport: str = "rest", request_type=compute.UpdateRegionBackendServiceRequest
):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# send a request that will satisfy transcoding
request_init = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
request_init["backend_service_resource"] = {
"affinity_cookie_ttl_sec": 2432,
"backends": [
{
"balancing_mode": "balancing_mode_value",
"capacity_scaler": 0.1575,
"description": "description_value",
"failover": True,
"group": "group_value",
"max_connections": 1608,
"max_connections_per_endpoint": 2990,
"max_connections_per_instance": 2978,
"max_rate": 849,
"max_rate_per_endpoint": 0.22310000000000002,
"max_rate_per_instance": 0.22190000000000001,
"max_utilization": 0.1633,
}
],
"cdn_policy": {
"bypass_cache_on_request_headers": [{"header_name": "header_name_value"}],
"cache_key_policy": {
"include_host": True,
"include_http_headers": [
"include_http_headers_value_1",
"include_http_headers_value_2",
],
"include_named_cookies": [
"include_named_cookies_value_1",
"include_named_cookies_value_2",
],
"include_protocol": True,
"include_query_string": True,
"query_string_blacklist": [
"query_string_blacklist_value_1",
"query_string_blacklist_value_2",
],
"query_string_whitelist": [
"query_string_whitelist_value_1",
"query_string_whitelist_value_2",
],
},
"cache_mode": "cache_mode_value",
"client_ttl": 1074,
"default_ttl": 1176,
"max_ttl": 761,
"negative_caching": True,
"negative_caching_policy": [{"code": 411, "ttl": 340}],
"request_coalescing": True,
"serve_while_stale": 1813,
"signed_url_cache_max_age_sec": 2890,
"signed_url_key_names": [
"signed_url_key_names_value_1",
"signed_url_key_names_value_2",
],
},
"circuit_breakers": {
"max_connections": 1608,
"max_pending_requests": 2149,
"max_requests": 1313,
"max_requests_per_connection": 2902,
"max_retries": 1187,
},
"connection_draining": {"draining_timeout_sec": 2124},
"connection_tracking_policy": {
"connection_persistence_on_unhealthy_backends": "connection_persistence_on_unhealthy_backends_value",
"idle_timeout_sec": 1694,
"tracking_mode": "tracking_mode_value",
},
"consistent_hash": {
"http_cookie": {
"name": "name_value",
"path": "path_value",
"ttl": {"nanos": 543, "seconds": 751},
},
"http_header_name": "http_header_name_value",
"minimum_ring_size": 1829,
},
"creation_timestamp": "creation_timestamp_value",
"custom_request_headers": [
"custom_request_headers_value_1",
"custom_request_headers_value_2",
],
"custom_response_headers": [
"custom_response_headers_value_1",
"custom_response_headers_value_2",
],
"description": "description_value",
"edge_security_policy": "edge_security_policy_value",
"enable_c_d_n": True,
"failover_policy": {
"disable_connection_drain_on_failover": True,
"drop_traffic_if_unhealthy": True,
"failover_ratio": 0.1494,
},
"fingerprint": "fingerprint_value",
"health_checks": ["health_checks_value_1", "health_checks_value_2"],
"iap": {
"enabled": True,
"oauth2_client_id": "oauth2_client_id_value",
"oauth2_client_secret": "oauth2_client_secret_value",
"oauth2_client_secret_sha256": "oauth2_client_secret_sha256_value",
},
"id": 205,
"kind": "kind_value",
"load_balancing_scheme": "load_balancing_scheme_value",
"locality_lb_policy": "locality_lb_policy_value",
"log_config": {"enable": True, "sample_rate": 0.1165},
"max_stream_duration": {},
"name": "name_value",
"network": "network_value",
"outlier_detection": {
"base_ejection_time": {},
"consecutive_errors": 1956,
"consecutive_gateway_failure": 2880,
"enforcing_consecutive_errors": 3006,
"enforcing_consecutive_gateway_failure": 3930,
"enforcing_success_rate": 2334,
"interval": {},
"max_ejection_percent": 2118,
"success_rate_minimum_hosts": 2799,
"success_rate_request_volume": 2915,
"success_rate_stdev_factor": 2663,
},
"port": 453,
"port_name": "port_name_value",
"protocol": "protocol_value",
"region": "region_value",
"security_policy": "security_policy_value",
"security_settings": {
"client_tls_policy": "client_tls_policy_value",
"subject_alt_names": [
"subject_alt_names_value_1",
"subject_alt_names_value_2",
],
},
"self_link": "self_link_value",
"session_affinity": "session_affinity_value",
"subsetting": {"policy": "policy_value"},
"timeout_sec": 1185,
}
request = request_type(request_init)
# Mock the http request call within the method and fake a BadRequest error.
with mock.patch.object(Session, "request") as req, pytest.raises(
core_exceptions.BadRequest
):
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 400
response_value.request = Request()
req.return_value = response_value
client.update_unary(request)
def test_update_unary_rest_flattened():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest",
)
# Mock the http request call within the method and fake a response.
with mock.patch.object(type(client.transport._session), "request") as req:
# Designate an appropriate value for the returned response.
return_value = compute.Operation()
# get arguments that satisfy an http rule for this method
sample_request = {
"project": "sample1",
"region": "sample2",
"backend_service": "sample3",
}
# get truthy value for each flattened field
mock_args = dict(
project="project_value",
region="region_value",
backend_service="backend_service_value",
backend_service_resource=compute.BackendService(
affinity_cookie_ttl_sec=2432
),
)
mock_args.update(sample_request)
# Wrap the value into a proper Response obj
response_value = Response()
response_value.status_code = 200
json_return_value = compute.Operation.to_json(return_value)
response_value._content = json_return_value.encode("UTF-8")
req.return_value = response_value
client.update_unary(**mock_args)
# Establish that the underlying call was made with the expected
# request object values.
assert len(req.mock_calls) == 1
_, args, _ = req.mock_calls[0]
assert path_template.validate(
"%s/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}"
% client.transport._host,
args[1],
)
def test_update_unary_rest_flattened_error(transport: str = "rest"):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# Attempting to call a method with both a request object and flattened
# fields is an error.
with pytest.raises(ValueError):
client.update_unary(
compute.UpdateRegionBackendServiceRequest(),
project="project_value",
region="region_value",
backend_service="backend_service_value",
backend_service_resource=compute.BackendService(
affinity_cookie_ttl_sec=2432
),
)
def test_update_unary_rest_error():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport="rest"
)
def test_credentials_transport_error():
# It is an error to provide credentials and a transport instance.
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
)
with pytest.raises(ValueError):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport,
)
# It is an error to provide a credentials file and a transport instance.
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
)
with pytest.raises(ValueError):
client = RegionBackendServicesClient(
client_options={"credentials_file": "credentials.json"},
transport=transport,
)
# It is an error to provide an api_key and a transport instance.
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
)
options = client_options.ClientOptions()
options.api_key = "api_key"
with pytest.raises(ValueError):
client = RegionBackendServicesClient(
client_options=options, transport=transport,
)
# It is an error to provide an api_key and a credential.
options = mock.Mock()
options.api_key = "api_key"
with pytest.raises(ValueError):
client = RegionBackendServicesClient(
client_options=options, credentials=ga_credentials.AnonymousCredentials()
)
# It is an error to provide scopes and a transport instance.
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
)
with pytest.raises(ValueError):
client = RegionBackendServicesClient(
client_options={"scopes": ["1", "2"]}, transport=transport,
)
def test_transport_instance():
# A client may be instantiated with a custom transport instance.
transport = transports.RegionBackendServicesRestTransport(
credentials=ga_credentials.AnonymousCredentials(),
)
client = RegionBackendServicesClient(transport=transport)
assert client.transport is transport
@pytest.mark.parametrize(
"transport_class", [transports.RegionBackendServicesRestTransport,]
)
def test_transport_adc(transport_class):
# Test default credentials are used if not provided.
with mock.patch.object(google.auth, "default") as adc:
adc.return_value = (ga_credentials.AnonymousCredentials(), None)
transport_class()
adc.assert_called_once()
def test_region_backend_services_base_transport_error():
# Passing both a credentials object and credentials_file should raise an error
with pytest.raises(core_exceptions.DuplicateCredentialArgs):
transport = transports.RegionBackendServicesTransport(
credentials=ga_credentials.AnonymousCredentials(),
credentials_file="credentials.json",
)
def test_region_backend_services_base_transport():
# Instantiate the base transport.
with mock.patch(
"google.cloud.compute_v1.services.region_backend_services.transports.RegionBackendServicesTransport.__init__"
) as Transport:
Transport.return_value = None
transport = transports.RegionBackendServicesTransport(
credentials=ga_credentials.AnonymousCredentials(),
)
# Every method on the transport should just blindly
# raise NotImplementedError.
methods = (
"delete",
"get",
"get_health",
"insert",
"list",
"patch",
"update",
)
for method in methods:
with pytest.raises(NotImplementedError):
getattr(transport, method)(request=object())
with pytest.raises(NotImplementedError):
transport.close()
def test_region_backend_services_base_transport_with_credentials_file():
# Instantiate the base transport with a credentials file
with mock.patch.object(
google.auth, "load_credentials_from_file", autospec=True
) as load_creds, mock.patch(
"google.cloud.compute_v1.services.region_backend_services.transports.RegionBackendServicesTransport._prep_wrapped_messages"
) as Transport:
Transport.return_value = None
load_creds.return_value = (ga_credentials.AnonymousCredentials(), None)
transport = transports.RegionBackendServicesTransport(
credentials_file="credentials.json", quota_project_id="octopus",
)
load_creds.assert_called_once_with(
"credentials.json",
scopes=None,
default_scopes=(
"https://www.googleapis.com/auth/compute",
"https://www.googleapis.com/auth/cloud-platform",
),
quota_project_id="octopus",
)
def test_region_backend_services_base_transport_with_adc():
# Test the default credentials are used if credentials and credentials_file are None.
with mock.patch.object(google.auth, "default", autospec=True) as adc, mock.patch(
"google.cloud.compute_v1.services.region_backend_services.transports.RegionBackendServicesTransport._prep_wrapped_messages"
) as Transport:
Transport.return_value = None
adc.return_value = (ga_credentials.AnonymousCredentials(), None)
transport = transports.RegionBackendServicesTransport()
adc.assert_called_once()
def test_region_backend_services_auth_adc():
# If no credentials are provided, we should use ADC credentials.
with mock.patch.object(google.auth, "default", autospec=True) as adc:
adc.return_value = (ga_credentials.AnonymousCredentials(), None)
RegionBackendServicesClient()
adc.assert_called_once_with(
scopes=None,
default_scopes=(
"https://www.googleapis.com/auth/compute",
"https://www.googleapis.com/auth/cloud-platform",
),
quota_project_id=None,
)
def test_region_backend_services_http_transport_client_cert_source_for_mtls():
cred = ga_credentials.AnonymousCredentials()
with mock.patch(
"google.auth.transport.requests.AuthorizedSession.configure_mtls_channel"
) as mock_configure_mtls_channel:
transports.RegionBackendServicesRestTransport(
credentials=cred, client_cert_source_for_mtls=client_cert_source_callback
)
mock_configure_mtls_channel.assert_called_once_with(client_cert_source_callback)
@pytest.mark.parametrize("transport_name", ["rest",])
def test_region_backend_services_host_no_port(transport_name):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(),
client_options=client_options.ClientOptions(
api_endpoint="compute.googleapis.com"
),
transport=transport_name,
)
assert client.transport._host == (
"compute.googleapis.com:443"
if transport_name in ["grpc", "grpc_asyncio"]
else "https://compute.googleapis.com"
)
@pytest.mark.parametrize("transport_name", ["rest",])
def test_region_backend_services_host_with_port(transport_name):
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(),
client_options=client_options.ClientOptions(
api_endpoint="compute.googleapis.com:8000"
),
transport=transport_name,
)
assert client.transport._host == (
"compute.googleapis.com:8000"
if transport_name in ["grpc", "grpc_asyncio"]
else "https://compute.googleapis.com:8000"
)
def test_common_billing_account_path():
billing_account = "squid"
expected = "billingAccounts/{billing_account}".format(
billing_account=billing_account,
)
actual = RegionBackendServicesClient.common_billing_account_path(billing_account)
assert expected == actual
def test_parse_common_billing_account_path():
expected = {
"billing_account": "clam",
}
path = RegionBackendServicesClient.common_billing_account_path(**expected)
# Check that the path construction is reversible.
actual = RegionBackendServicesClient.parse_common_billing_account_path(path)
assert expected == actual
def test_common_folder_path():
folder = "whelk"
expected = "folders/{folder}".format(folder=folder,)
actual = RegionBackendServicesClient.common_folder_path(folder)
assert expected == actual
def test_parse_common_folder_path():
expected = {
"folder": "octopus",
}
path = RegionBackendServicesClient.common_folder_path(**expected)
# Check that the path construction is reversible.
actual = RegionBackendServicesClient.parse_common_folder_path(path)
assert expected == actual
def test_common_organization_path():
organization = "oyster"
expected = "organizations/{organization}".format(organization=organization,)
actual = RegionBackendServicesClient.common_organization_path(organization)
assert expected == actual
def test_parse_common_organization_path():
expected = {
"organization": "nudibranch",
}
path = RegionBackendServicesClient.common_organization_path(**expected)
# Check that the path construction is reversible.
actual = RegionBackendServicesClient.parse_common_organization_path(path)
assert expected == actual
def test_common_project_path():
project = "cuttlefish"
expected = "projects/{project}".format(project=project,)
actual = RegionBackendServicesClient.common_project_path(project)
assert expected == actual
def test_parse_common_project_path():
expected = {
"project": "mussel",
}
path = RegionBackendServicesClient.common_project_path(**expected)
# Check that the path construction is reversible.
actual = RegionBackendServicesClient.parse_common_project_path(path)
assert expected == actual
def test_common_location_path():
project = "winkle"
location = "nautilus"
expected = "projects/{project}/locations/{location}".format(
project=project, location=location,
)
actual = RegionBackendServicesClient.common_location_path(project, location)
assert expected == actual
def test_parse_common_location_path():
expected = {
"project": "scallop",
"location": "abalone",
}
path = RegionBackendServicesClient.common_location_path(**expected)
# Check that the path construction is reversible.
actual = RegionBackendServicesClient.parse_common_location_path(path)
assert expected == actual
def test_client_with_default_client_info():
client_info = gapic_v1.client_info.ClientInfo()
with mock.patch.object(
transports.RegionBackendServicesTransport, "_prep_wrapped_messages"
) as prep:
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), client_info=client_info,
)
prep.assert_called_once_with(client_info)
with mock.patch.object(
transports.RegionBackendServicesTransport, "_prep_wrapped_messages"
) as prep:
transport_class = RegionBackendServicesClient.get_transport_class()
transport = transport_class(
credentials=ga_credentials.AnonymousCredentials(), client_info=client_info,
)
prep.assert_called_once_with(client_info)
def test_transport_close():
transports = {
"rest": "_session",
}
for transport, close_name in transports.items():
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport
)
with mock.patch.object(
type(getattr(client.transport, close_name)), "close"
) as close:
with client:
close.assert_not_called()
close.assert_called_once()
def test_client_ctx():
transports = [
"rest",
]
for transport in transports:
client = RegionBackendServicesClient(
credentials=ga_credentials.AnonymousCredentials(), transport=transport
)
# Test client calls underlying transport.
with mock.patch.object(type(client.transport), "close") as close:
close.assert_not_called()
with client:
pass
close.assert_called()
@pytest.mark.parametrize(
"client_class,transport_class",
[(RegionBackendServicesClient, transports.RegionBackendServicesRestTransport),],
)
def test_api_key_credentials(client_class, transport_class):
with mock.patch.object(
google.auth._default, "get_api_key_credentials", create=True
) as get_api_key_credentials:
mock_cred = mock.Mock()
get_api_key_credentials.return_value = mock_cred
options = client_options.ClientOptions()
options.api_key = "api_key"
with mock.patch.object(transport_class, "__init__") as patched:
patched.return_value = None
client = client_class(client_options=options)
patched.assert_called_once_with(
credentials=mock_cred,
credentials_file=None,
host=client.DEFAULT_ENDPOINT,
scopes=None,
client_cert_source_for_mtls=None,
quota_project_id=None,
client_info=transports.base.DEFAULT_CLIENT_INFO,
always_use_jwt_access=True,
)
| googleapis/python-compute | tests/unit/gapic/compute_v1/test_region_backend_services.py | Python | apache-2.0 | 149,814 |
# Copyright 2010 OpenStack Foundation
# Copyright 2013 Hewlett-Packard Development Company, L.P.
# 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.
import abc
import datetime
from http import client as http_client
import os
import shutil
from urllib import parse as urlparse
from oslo_log import log
from oslo_utils import strutils
from oslo_utils import uuidutils
import requests
from ironic.common import exception
from ironic.common.glance_service.image_service import GlanceImageService
from ironic.common.i18n import _
from ironic.common import utils
from ironic.conf import CONF
IMAGE_CHUNK_SIZE = 1024 * 1024 # 1mb
# NOTE(kaifeng) Image will be truncated to 2GiB by sendfile,
# we use a large chunk size here for a better performance
# while keep the chunk size less than the size limit.
SENDFILE_CHUNK_SIZE = 1024 * 1024 * 1024 # 1Gb
LOG = log.getLogger(__name__)
class BaseImageService(object, metaclass=abc.ABCMeta):
"""Provides retrieval of disk images."""
@abc.abstractmethod
def validate_href(self, image_href):
"""Validate image reference.
:param image_href: Image reference.
:raises: exception.ImageRefValidationFailed.
:returns: Information needed to further operate with an image.
"""
@abc.abstractmethod
def download(self, image_href, image_file):
"""Downloads image to specified location.
:param image_href: Image reference.
:param image_file: File object to write data to.
:raises: exception.ImageRefValidationFailed.
:raises: exception.ImageDownloadFailed.
"""
@abc.abstractmethod
def show(self, image_href):
"""Get dictionary of image properties.
:param image_href: Image reference.
:raises: exception.ImageRefValidationFailed.
:returns: dictionary of image properties. It has three of them: 'size',
'updated_at' and 'properties'. 'updated_at' attribute is a naive
UTC datetime object.
"""
class HttpImageService(BaseImageService):
"""Provides retrieval of disk images using HTTP."""
def validate_href(self, image_href, secret=False):
"""Validate HTTP image reference.
:param image_href: Image reference.
:param secret: Specify if image_href being validated should not be
shown in exception message.
:raises: exception.ImageRefValidationFailed if HEAD request failed or
returned response code not equal to 200.
:returns: Response to HEAD request.
"""
output_url = 'secreturl' if secret else image_href
try:
verify = strutils.bool_from_string(CONF.webserver_verify_ca,
strict=True)
except ValueError:
verify = CONF.webserver_verify_ca
try:
response = requests.head(image_href, verify=verify,
timeout=CONF.webserver_connection_timeout)
if response.status_code != http_client.OK:
raise exception.ImageRefValidationFailed(
image_href=output_url,
reason=_("Got HTTP code %s instead of 200 in response "
"to HEAD request.") % response.status_code)
except (OSError, requests.ConnectionError,
requests.RequestException) as e:
raise exception.ImageRefValidationFailed(image_href=output_url,
reason=str(e))
return response
def download(self, image_href, image_file):
"""Downloads image to specified location.
:param image_href: Image reference.
:param image_file: File object to write data to.
:raises: exception.ImageRefValidationFailed if GET request returned
response code not equal to 200.
:raises: exception.ImageDownloadFailed if:
* IOError happened during file write;
* GET request failed.
"""
try:
verify = strutils.bool_from_string(CONF.webserver_verify_ca,
strict=True)
except ValueError:
verify = CONF.webserver_verify_ca
try:
response = requests.get(image_href, stream=True, verify=verify,
timeout=CONF.webserver_connection_timeout)
if response.status_code != http_client.OK:
raise exception.ImageRefValidationFailed(
image_href=image_href,
reason=_("Got HTTP code %s instead of 200 in response "
"to GET request.") % response.status_code)
with response.raw as input_img:
shutil.copyfileobj(input_img, image_file, IMAGE_CHUNK_SIZE)
except (OSError, requests.ConnectionError, requests.RequestException,
IOError) as e:
raise exception.ImageDownloadFailed(image_href=image_href,
reason=str(e))
def show(self, image_href):
"""Get dictionary of image properties.
:param image_href: Image reference.
:raises: exception.ImageRefValidationFailed if:
* HEAD request failed;
* HEAD request returned response code not equal to 200;
* Content-Length header not found in response to HEAD request.
:returns: dictionary of image properties. It has three of them: 'size',
'updated_at' and 'properties'. 'updated_at' attribute is a naive
UTC datetime object.
"""
response = self.validate_href(image_href)
image_size = response.headers.get('Content-Length')
if image_size is None:
raise exception.ImageRefValidationFailed(
image_href=image_href,
reason=_("Cannot determine image size as there is no "
"Content-Length header specified in response "
"to HEAD request."))
# Parse last-modified header to return naive datetime object
str_date = response.headers.get('Last-Modified')
date = None
if str_date:
http_date_format_strings = [
'%a, %d %b %Y %H:%M:%S GMT', # RFC 822
'%A, %d-%b-%y %H:%M:%S GMT', # RFC 850
'%a %b %d %H:%M:%S %Y' # ANSI C
]
for fmt in http_date_format_strings:
try:
date = datetime.datetime.strptime(str_date, fmt)
break
except ValueError:
continue
no_cache = 'no-store' in response.headers.get('Cache-Control', '')
return {
'size': int(image_size),
'updated_at': date,
'properties': {},
'no_cache': no_cache,
}
class FileImageService(BaseImageService):
"""Provides retrieval of disk images available locally on the conductor."""
def validate_href(self, image_href):
"""Validate local image reference.
:param image_href: Image reference.
:raises: exception.ImageRefValidationFailed if source image file
doesn't exist.
:returns: Path to image file if it exists.
"""
image_path = urlparse.urlparse(image_href).path
if not os.path.isfile(image_path):
raise exception.ImageRefValidationFailed(
image_href=image_href,
reason=_("Specified image file not found."))
return image_path
def download(self, image_href, image_file):
"""Downloads image to specified location.
:param image_href: Image reference.
:param image_file: File object to write data to.
:raises: exception.ImageRefValidationFailed if source image file
doesn't exist.
:raises: exception.ImageDownloadFailed if exceptions were raised while
writing to file or creating hard link.
"""
source_image_path = self.validate_href(image_href)
dest_image_path = image_file.name
local_device = os.stat(dest_image_path).st_dev
try:
# We should have read and write access to source file to create
# hard link to it.
if (local_device == os.stat(source_image_path).st_dev
and os.access(source_image_path, os.R_OK | os.W_OK)):
image_file.close()
os.remove(dest_image_path)
os.link(source_image_path, dest_image_path)
else:
filesize = os.path.getsize(source_image_path)
offset = 0
with open(source_image_path, 'rb') as input_img:
while offset < filesize:
count = min(SENDFILE_CHUNK_SIZE, filesize - offset)
nbytes_out = os.sendfile(image_file.fileno(),
input_img.fileno(),
offset,
count)
offset += nbytes_out
except Exception as e:
raise exception.ImageDownloadFailed(image_href=image_href,
reason=str(e))
def show(self, image_href):
"""Get dictionary of image properties.
:param image_href: Image reference.
:raises: exception.ImageRefValidationFailed if image file specified
doesn't exist.
:returns: dictionary of image properties. It has three of them: 'size',
'updated_at' and 'properties'. 'updated_at' attribute is a naive
UTC datetime object.
"""
source_image_path = self.validate_href(image_href)
return {
'size': os.path.getsize(source_image_path),
'updated_at': utils.unix_file_modification_datetime(
source_image_path),
'properties': {},
# No point in caching local file images
'no_cache': True,
}
protocol_mapping = {
'http': HttpImageService,
'https': HttpImageService,
'file': FileImageService,
'glance': GlanceImageService,
}
def get_image_service(image_href, client=None, context=None):
"""Get image service instance to download the image.
:param image_href: String containing href to get image service for.
:param client: Glance client to be used for download, used only if
image_href is Glance href.
:param context: request context, used only if image_href is Glance href.
:raises: exception.ImageRefValidationFailed if no image service can
handle specified href.
:returns: Instance of an image service class that is able to download
specified image.
"""
scheme = urlparse.urlparse(image_href).scheme.lower()
if not scheme:
if uuidutils.is_uuid_like(str(image_href)):
cls = GlanceImageService
else:
raise exception.ImageRefValidationFailed(
image_href=image_href,
reason=_('Scheme-less image href is not a UUID.'))
else:
cls = protocol_mapping.get(scheme)
if not cls:
raise exception.ImageRefValidationFailed(
image_href=image_href,
reason=_('Image download protocol %s is not supported.'
) % scheme)
if cls == GlanceImageService:
return cls(client, context)
return cls()
| openstack/ironic | ironic/common/image_service.py | Python | apache-2.0 | 12,149 |
"""
This module contains helper functions for controlling caching. It does so by
managing the "Vary" header of responses. It includes functions to patch the
header of response objects directly and decorators that change functions to do
that header-patching themselves.
For information on the Vary header, see:
https://tools.ietf.org/html/rfc7231#section-7.1.4
Essentially, the "Vary" HTTP header defines which headers a cache should take
into account when building its cache key. Requests with the same path but
different header content for headers named in "Vary" need to get different
cache keys to prevent delivery of wrong content.
An example: i18n middleware would need to distinguish caches by the
"Accept-language" header.
"""
import hashlib
import logging
import re
import time
from django.conf import settings
from django.core.cache import caches
from django.http import HttpResponse, HttpResponseNotModified
from django.utils.encoding import force_bytes, force_text, iri_to_uri
from django.utils.http import (
http_date, parse_etags, parse_http_date_safe, quote_etag,
)
from django.utils.timezone import get_current_timezone_name
from django.utils.translation import get_language
cc_delim_re = re.compile(r'\s*,\s*')
logger = logging.getLogger('django.request')
def patch_cache_control(response, **kwargs):
"""
Patch the Cache-Control header by adding all keyword arguments to it.
The transformation is as follows:
* All keyword parameter names are turned to lowercase, and underscores
are converted to hyphens.
* If the value of a parameter is True (exactly True, not just a
true value), only the parameter name is added to the header.
* All other parameters are added with their value, after applying
str() to it.
"""
def dictitem(s):
t = s.split('=', 1)
if len(t) > 1:
return (t[0].lower(), t[1])
else:
return (t[0].lower(), True)
def dictvalue(t):
if t[1] is True:
return t[0]
else:
return '%s=%s' % (t[0], t[1])
if response.get('Cache-Control'):
cc = cc_delim_re.split(response['Cache-Control'])
cc = dict(dictitem(el) for el in cc)
else:
cc = {}
# If there's already a max-age header but we're being asked to set a new
# max-age, use the minimum of the two ages. In practice this happens when
# a decorator and a piece of middleware both operate on a given view.
if 'max-age' in cc and 'max_age' in kwargs:
kwargs['max_age'] = min(int(cc['max-age']), kwargs['max_age'])
# Allow overriding private caching and vice versa
if 'private' in cc and 'public' in kwargs:
del cc['private']
elif 'public' in cc and 'private' in kwargs:
del cc['public']
for (k, v) in kwargs.items():
cc[k.replace('_', '-')] = v
cc = ', '.join(dictvalue(el) for el in cc.items())
response['Cache-Control'] = cc
def get_max_age(response):
"""
Return the max-age from the response Cache-Control header as an integer,
or None if it wasn't found or wasn't an integer.
"""
if not response.has_header('Cache-Control'):
return
cc = dict(_to_tuple(el) for el in cc_delim_re.split(response['Cache-Control']))
try:
return int(cc['max-age'])
except (ValueError, TypeError, KeyError):
pass
def set_response_etag(response):
if not response.streaming:
response['ETag'] = quote_etag(hashlib.md5(response.content).hexdigest())
return response
def _precondition_failed(request):
logger.warning(
'Precondition Failed: %s', request.path,
extra={
'status_code': 412,
'request': request,
},
)
return HttpResponse(status=412)
def _not_modified(request, response=None):
new_response = HttpResponseNotModified()
if response:
# Preserve the headers required by Section 4.1 of RFC 7232, as well as
# Last-Modified.
for header in ('Cache-Control', 'Content-Location', 'Date', 'ETag', 'Expires', 'Last-Modified', 'Vary'):
if header in response:
new_response[header] = response[header]
# Preserve cookies as per the cookie specification: "If a proxy server
# receives a response which contains a Set-cookie header, it should
# propagate the Set-cookie header to the client, regardless of whether
# the response was 304 (Not Modified) or 200 (OK).
# https://curl.haxx.se/rfc/cookie_spec.html
new_response.cookies = response.cookies
return new_response
def get_conditional_response(request, etag=None, last_modified=None, response=None):
# Only return conditional responses on successful requests.
if response and not (200 <= response.status_code < 300):
return response
# Get HTTP request headers.
if_match_etags = parse_etags(request.META.get('HTTP_IF_MATCH', ''))
if_unmodified_since = request.META.get('HTTP_IF_UNMODIFIED_SINCE')
if if_unmodified_since:
if_unmodified_since = parse_http_date_safe(if_unmodified_since)
if_none_match_etags = parse_etags(request.META.get('HTTP_IF_NONE_MATCH', ''))
if_modified_since = request.META.get('HTTP_IF_MODIFIED_SINCE')
if if_modified_since:
if_modified_since = parse_http_date_safe(if_modified_since)
# Step 1 of section 6 of RFC 7232: Test the If-Match precondition.
if if_match_etags and not _if_match_passes(etag, if_match_etags):
return _precondition_failed(request)
# Step 2: Test the If-Unmodified-Since precondition.
if (not if_match_etags and if_unmodified_since and
not _if_unmodified_since_passes(last_modified, if_unmodified_since)):
return _precondition_failed(request)
# Step 3: Test the If-None-Match precondition.
if if_none_match_etags and not _if_none_match_passes(etag, if_none_match_etags):
if request.method in ('GET', 'HEAD'):
return _not_modified(request, response)
else:
return _precondition_failed(request)
# Step 4: Test the If-Modified-Since precondition.
if (not if_none_match_etags and if_modified_since and
not _if_modified_since_passes(last_modified, if_modified_since)):
if request.method in ('GET', 'HEAD'):
return _not_modified(request, response)
# Step 5: Test the If-Range precondition (not supported).
# Step 6: Return original response since there isn't a conditional response.
return response
def _if_match_passes(target_etag, etags):
"""
Test the If-Match comparison as defined in section 3.1 of RFC 7232.
"""
if not target_etag:
# If there isn't an ETag, then there can't be a match.
return False
elif etags == ['*']:
# The existence of an ETag means that there is "a current
# representation for the target resource", even if the ETag is weak,
# so there is a match to '*'.
return True
elif target_etag.startswith('W/'):
# A weak ETag can never strongly match another ETag.
return False
else:
# Since the ETag is strong, this will only return True if there's a
# strong match.
return target_etag in etags
def _if_unmodified_since_passes(last_modified, if_unmodified_since):
"""
Test the If-Unmodified-Since comparison as defined in section 3.4 of
RFC 7232.
"""
return last_modified and last_modified <= if_unmodified_since
def _if_none_match_passes(target_etag, etags):
"""
Test the If-None-Match comparison as defined in section 3.2 of RFC 7232.
"""
if not target_etag:
# If there isn't an ETag, then there isn't a match.
return True
elif etags == ['*']:
# The existence of an ETag means that there is "a current
# representation for the target resource", so there is a match to '*'.
return False
else:
# The comparison should be weak, so look for a match after stripping
# off any weak indicators.
target_etag = target_etag.strip('W/')
etags = (etag.strip('W/') for etag in etags)
return target_etag not in etags
def _if_modified_since_passes(last_modified, if_modified_since):
"""
Test the If-Modified-Since comparison as defined in section 3.3 of RFC 7232.
"""
return not last_modified or last_modified > if_modified_since
def patch_response_headers(response, cache_timeout=None):
"""
Add HTTP caching headers to the given HttpResponse: Expires and
Cache-Control.
Each header is only added if it isn't already set.
cache_timeout is in seconds. The CACHE_MIDDLEWARE_SECONDS setting is used
by default.
"""
if cache_timeout is None:
cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS
if cache_timeout < 0:
cache_timeout = 0 # Can't have max-age negative
if not response.has_header('Expires'):
response['Expires'] = http_date(time.time() + cache_timeout)
patch_cache_control(response, max_age=cache_timeout)
def add_never_cache_headers(response):
"""
Add headers to a response to indicate that a page should never be cached.
"""
patch_response_headers(response, cache_timeout=-1)
patch_cache_control(response, no_cache=True, no_store=True, must_revalidate=True)
def patch_vary_headers(response, newheaders):
"""
Add (or update) the "Vary" header in the given HttpResponse object.
newheaders is a list of header names that should be in "Vary". Existing
headers in "Vary" aren't removed.
"""
# Note that we need to keep the original order intact, because cache
# implementations may rely on the order of the Vary contents in, say,
# computing an MD5 hash.
if response.has_header('Vary'):
vary_headers = cc_delim_re.split(response['Vary'])
else:
vary_headers = []
# Use .lower() here so we treat headers as case-insensitive.
existing_headers = {header.lower() for header in vary_headers}
additional_headers = [newheader for newheader in newheaders
if newheader.lower() not in existing_headers]
response['Vary'] = ', '.join(vary_headers + additional_headers)
def has_vary_header(response, header_query):
"""
Check to see if the response has a given header name in its Vary header.
"""
if not response.has_header('Vary'):
return False
vary_headers = cc_delim_re.split(response['Vary'])
existing_headers = {header.lower() for header in vary_headers}
return header_query.lower() in existing_headers
def _i18n_cache_key_suffix(request, cache_key):
"""If necessary, add the current locale or time zone to the cache key."""
if settings.USE_I18N or settings.USE_L10N:
# first check if LocaleMiddleware or another middleware added
# LANGUAGE_CODE to request, then fall back to the active language
# which in turn can also fall back to settings.LANGUAGE_CODE
cache_key += '.%s' % getattr(request, 'LANGUAGE_CODE', get_language())
if settings.USE_TZ:
# The datetime module doesn't restrict the output of tzname().
# Windows is known to use non-standard, locale-dependent names.
# User-defined tzinfo classes may return absolutely anything.
# Hence this paranoid conversion to create a valid cache key.
tz_name = force_text(get_current_timezone_name(), errors='ignore')
cache_key += '.%s' % tz_name.encode('ascii', 'ignore').decode('ascii').replace(' ', '_')
return cache_key
def _generate_cache_key(request, method, headerlist, key_prefix):
"""Return a cache key from the headers given in the header list."""
ctx = hashlib.md5()
for header in headerlist:
value = request.META.get(header)
if value is not None:
ctx.update(force_bytes(value))
url = hashlib.md5(force_bytes(iri_to_uri(request.build_absolute_uri())))
cache_key = 'views.decorators.cache.cache_page.%s.%s.%s.%s' % (
key_prefix, method, url.hexdigest(), ctx.hexdigest())
return _i18n_cache_key_suffix(request, cache_key)
def _generate_cache_header_key(key_prefix, request):
"""Return a cache key for the header cache."""
url = hashlib.md5(force_bytes(iri_to_uri(request.build_absolute_uri())))
cache_key = 'views.decorators.cache.cache_header.%s.%s' % (
key_prefix, url.hexdigest())
return _i18n_cache_key_suffix(request, cache_key)
def get_cache_key(request, key_prefix=None, method='GET', cache=None):
"""
Return a cache key based on the request URL and query. It can be used
in the request phase because it pulls the list of headers to take into
account from the global URL registry and uses those to build a cache key
to check against.
If there isn't a headerlist stored, return None, indicating that the page
needs to be rebuilt.
"""
if key_prefix is None:
key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
cache_key = _generate_cache_header_key(key_prefix, request)
if cache is None:
cache = caches[settings.CACHE_MIDDLEWARE_ALIAS]
headerlist = cache.get(cache_key)
if headerlist is not None:
return _generate_cache_key(request, method, headerlist, key_prefix)
else:
return None
def learn_cache_key(request, response, cache_timeout=None, key_prefix=None, cache=None):
"""
Learn what headers to take into account for some request URL from the
response object. Store those headers in a global URL registry so that
later access to that URL will know what headers to take into account
without building the response object itself. The headers are named in the
Vary header of the response, but we want to prevent response generation.
The list of headers to use for cache key generation is stored in the same
cache as the pages themselves. If the cache ages some data out of the
cache, this just means that we have to build the response once to get at
the Vary header and so at the list of headers to use for the cache key.
"""
if key_prefix is None:
key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
if cache_timeout is None:
cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS
cache_key = _generate_cache_header_key(key_prefix, request)
if cache is None:
cache = caches[settings.CACHE_MIDDLEWARE_ALIAS]
if response.has_header('Vary'):
is_accept_language_redundant = settings.USE_I18N or settings.USE_L10N
# If i18n or l10n are used, the generated cache key will be suffixed
# with the current locale. Adding the raw value of Accept-Language is
# redundant in that case and would result in storing the same content
# under multiple keys in the cache. See #18191 for details.
headerlist = []
for header in cc_delim_re.split(response['Vary']):
header = header.upper().replace('-', '_')
if header == 'ACCEPT_LANGUAGE' and is_accept_language_redundant:
continue
headerlist.append('HTTP_' + header)
headerlist.sort()
cache.set(cache_key, headerlist, cache_timeout)
return _generate_cache_key(request, request.method, headerlist, key_prefix)
else:
# if there is no Vary header, we still need a cache key
# for the request.build_absolute_uri()
cache.set(cache_key, [], cache_timeout)
return _generate_cache_key(request, request.method, [], key_prefix)
def _to_tuple(s):
t = s.split('=', 1)
if len(t) == 2:
return t[0].lower(), t[1]
return t[0].lower(), True
| uranusjr/django | django/utils/cache.py | Python | bsd-3-clause | 15,727 |
from PyQt4 import QtGui
class BooksListWidget(QtGui.QWidget):
""" Uneditable list's books """
def __init__(self, label):
super(BooksListWidget, self).__init__()
# init label and table widgets
self.title_label = QtGui.QLabel(label)
self.books_list = QtGui.QListView()
# List settings
self.books_list.minimumHeight()
# Make the list uneditable
self.books_list.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
# Create a model for the list's books
self.model = QtGui.QStringListModel()
# Apply the model to the list view
self.books_list.setModel(self.model)
# Create the layout
self.main_layout = QtGui.QVBoxLayout()
self.main_layout.addWidget(self.title_label)
self.main_layout.addWidget(self.books_list)
# Set the layout
self.setLayout(self.main_layout)
def update_list(self, books_list):
""" Update the books list """
assert isinstance(books_list, list)
self.model.setStringList(books_list)
| franramirez688/Taric-Challange | taric_challange/gui/widgets/books_list.py | Python | mit | 1,089 |
result = 1
for i in range(1, int(input()) + 1):
result *= i
print(result)
| burakkose/HackerRank | Challenges/extra_long_factorials.py | Python | unlicense | 78 |
"""Utilities relating to data handling and processing.
This module does not define datatypes itself. See L{jazzparser.data}
for that.
"""
"""
============================== License ========================================
Copyright (C) 2008, 2010-12 University of Edinburgh, Mark Granroth-Wilding
This file is part of The Jazz Parser.
The Jazz Parser 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.
The Jazz Parser 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 The Jazz Parser. If not, see <http://www.gnu.org/licenses/>.
============================ End license ======================================
"""
__author__ = "Mark Granroth-Wilding <[email protected]>"
def hold_out(full, start, end):
if start is None or start == 0:
return full[end:]
elif end is None:
return full[:start]
else:
return full[:start] + full[end:]
def holdout_partition(input, partitions):
"""
Partitions the iterable input into the given number of partitions
and returns a list of subsets of the input with each of the
partitions excluded. Useful for doing heldout data evaluations.
"""
partition_size = len(input) / partitions
heldout_sets = []
for partition in range(partitions-1):
heldout_sets.append(hold_out(input, partition_size*partition, partition_size*(partition+1)))
# Last partition: throw in everything that's left
heldout_sets.append(hold_out(input, partition_size*(partitions-1), None))
return heldout_sets
def partition(input, partitions):
"""
The complement of holdout_partition. Simply splits the input
n ways.
"""
partition_size = len(input) / partitions
parts = []
for partition in range(partitions-1):
parts.append(input[partition_size*partition: partition_size*(partition+1)])
# Last partition: throw what's left in
parts.append(input[partition_size*(partitions-1):])
return parts
| markgw/jazzparser | src/jazzparser/utils/data.py | Python | gpl-3.0 | 2,389 |
from django.conf.urls import patterns, include, url
from django.conf.urls.static import static
from django.conf import settings
urlpatterns = patterns('',
url(r'^$', 'docbucket.views.home', name='home'),
url(r'^create/(?P<compiler>.+)$', 'docbucket.views.create', name='create'),
url(r'^list/$', 'docbucket.views.list', name='list'),
url(r'^list/(?P<tag_name>.+)/$', 'docbucket.views.list', name='list-tag'),
url(r'^show/(?P<doc_id>\d+)/$', 'docbucket.views.show', name='show'),
url(r'^search/$', 'docbucket.views.search', name='search'),
url(r'^_thumbnail/file/(?P<identifier>.+)$', 'docbucket.views.thumbnail', {'type': 'file'}, name='thumbnail-file'),
url(r'^_thumbnail/document/(?P<identifier>\d+)$', 'docbucket.views.thumbnail', {'type': 'document'}, name='thumbnail-document'),
url(r'^_document/(?P<doc_id>\d+)', 'docbucket.views.ajax_document', name='ajax_document'),
url(r'^_tags/', 'docbucket.views.ajax_tags', name='ajax_tags')
)
if settings.DEBUG:
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) | NaPs/Docbucket | docbucket/urls.py | Python | mit | 1,082 |
"""Dependency downloader for open_fortran_parser."""
import logging
import os
import pathlib
import platform
import typing as t
import urllib
import wget
_LOG = logging.getLogger(__name__)
def ensure_dependencies(
dependencies: t.Mapping[str, t.Tuple[urllib.parse.ParseResult, pathlib.Path]],
target_dir: pathlib.Path, download: bool = True, silent: bool = False) -> None:
"""Download missing depenedencies."""
if not target_dir.exists():
_LOG.warning('Creating directory "%s"...', target_dir)
os.makedirs(str(target_dir), exist_ok=True)
for dependency, (url_root, filename) in dependencies.items():
path = target_dir.joinpath(filename)
if path.is_file() and not silent:
_LOG.warning('%s is present already.', dependency)
continue
if not download:
_LOG.warning('%s is not present!', dependency)
continue
url = urllib.parse.urlunparse(url_root) + str(filename)
_LOG.warning('Downloading %s from URL "%s" to path "%s"...', dependency, url, path)
wget.download(url, str(path), bar=None if silent else wget.bar_adaptive)
if not silent:
print()
def cleanup_old_dependencies(
outdated_dependencies, current_dir: pathlib.Path,
backup_dir: t.Optional[pathlib.Path] = None):
if backup_dir is not None and not backup_dir.exists():
_LOG.warning('Creating directory "%s"...', backup_dir)
os.makedirs(str(backup_dir), exist_ok=True)
for dependency, filename in outdated_dependencies.items():
path = current_dir.joinpath(filename)
if not path.is_file():
_LOG.debug('%s already does not exist.', dependency)
continue
if backup_dir is None:
_LOG.warning('Deleting %s in path "%s"...', dependency, current_dir)
path.unlink()
else:
_LOG.warning('Moving %s from path "%s" to path "%s"...',
dependency, current_dir, backup_dir)
path.rename(backup_dir.joinpath(filename))
| mbdevpl/open-fortran-parser-xml | open_fortran_parser/dependencies.py | Python | apache-2.0 | 2,086 |
from edmunds.globals import abc, ABC
class BaseDriver(ABC):
"""
The base driver for storage-drivers
"""
def __init__(self, app):
"""
Initiate the instance
:param app: The application
:type app: Edmunds.Application
"""
self._app = app
@abc.abstractmethod
def write_stream(self, path, append=False, prefix=None):
"""
Get a write stream to a certain path
:param path: The path to the file
:type path: str
:param append: Append to the file
:type append: bool
:param prefix: The prefix
:type prefix: str
:return: The write stream
:rtype: Stream
"""
pass
@abc.abstractmethod
def read_stream(self, path, raise_errors=False, prefix=None):
"""
Get a read stream to a certain path
:param path: The path to the file
:type path: str
:param raise_errors: Raise the errors
:type raise_errors: bool
:param prefix: The prefix
:type prefix: str
:return: The read stream
:rtype: Stream
"""
pass
@abc.abstractmethod
def copy(self, path, new_path, raise_errors=False, prefix=None):
"""
Copy a certain path
:param path: The path to the file
:type path: str
:param new_path: The path to the new file
:type new_path: str
:param raise_errors: Raise the errors
:type raise_errors: bool
:param prefix: The prefix
:type prefix: str
:return: Success
:rtype: bool
"""
pass
@abc.abstractmethod
def delete(self, path, raise_errors=False, prefix=None):
"""
Delete a certain path
:param path: The path to the file
:type path: str
:param raise_errors: Raise the errors
:type raise_errors: bool
:param prefix: The prefix
:type prefix: str
:return: Success
:rtype: bool
"""
pass
@abc.abstractmethod
def exists(self, path, prefix=None):
"""
Check if a certain path exists
:param path: The path to the file
:type path: str
:param prefix: The prefix
:type prefix: str
:return: Exists
:rtype: bool
"""
pass
@abc.abstractmethod
def path(self, path, prefix=None):
"""
Get a processed path
:param path: The path to the file
:type path: str
:param prefix: The prefix
:type prefix: str
:return: Absolute path to file
:rtype: str
"""
pass
| LowieHuyghe/edmunds | edmunds/storage/drivers/basedriver.py | Python | apache-2.0 | 3,058 |
from __future__ import unicode_literals
from pydoc import deque
from threading import Thread
from Queue import Queue
import gc
import time
from traceback import print_exc
from django.db import connection
from py4j.java_gateway import JavaGateway
from py4j.protocol import Py4JJavaError
from codebase.models import CodeElementKind, CodeElement, MethodElement,\
ParameterElement, FieldElement
from docutil.progress_monitor import NullProgressMonitor
from codeutil.java_element import clean_java_name
JAVA_PARSER = 'java'
PARSER_WORKER = 4
HIERARCHY_WORKER = 2
class HierarchyWorker(Thread):
'''Worker that adds parents to code elements.'''
def __init__(self, hierarchies, codebase, progress_monitor):
'''
:param hierarchies: queue of [child_fqn, parent_fqn, parent_fqn, ...]
:param codebase:
:param progress_monitor:
'''
Thread.__init__(self)
self.hierarchies = hierarchies
self.progress_monitor = progress_monitor
self.codebase = codebase
self.setDaemon(True)
def run(self):
while True:
hierarchy = self.hierarchies.get()
if hierarchy is None:
# Sentinel value to indicate we are done!
break
child_fqn = hierarchy[0]
child = CodeElement.objects.filter(codebase=self.codebase).\
get(fqn=child_fqn)
for parent_fqn in hierarchy[1:]:
try:
parent_element = CodeElement.objects.\
filter(codebase=self.codebase).get(fqn=parent_fqn)
child.parents.add(parent_element)
except Exception:
# Not found!
# Probably because not in codebase!
pass
self.progress_monitor.work('Parsed {0} hierarchy: {1} parents'.\
format(child_fqn, len(hierarchy) - 1))
self.hierarchies.task_done()
self.hierarchies.task_done()
# Because django does not automatically close a connection created by
# a custom thread...
connection.close()
class CUWorker(Thread):
'''Worker that processes a compilation unit'''
def __init__(self, queue, codebase, hierarchies, gateway,
progress_monitor):
'''
:param queue: queue of (cu, package_code_element, cu_name, work_amount)
where cu is a Java CompilationUnit.
:param codebase:
:param hierarchies: queue of [child_fqn, parent_fqn, parent_fqn, ...]
:param gateway: Py4J gateway
:param progress_monitor:
'''
Thread.__init__(self)
self.setDaemon(True)
self.queue = queue
self.codebase = codebase
# Does not work as expected because if a thread is waiting while being
# a daemon and the last one, it seems that there may be glitches.
#self.daemon = True
self.hierarchies = hierarchies
self.gateway = gateway
self.progress_monitor = progress_monitor
self.class_kind = CodeElementKind.objects.get(kind='class')
self.annotation_kind = CodeElementKind.objects.get(kind='annotation')
self.enumeration_kind = CodeElementKind.objects.get(kind='enumeration')
self.field_kind = CodeElementKind.objects.get(kind='field')
self.method_kind = CodeElementKind.objects.get(kind='method')
self.method_parameter_kind = CodeElementKind.objects.get(
kind='method parameter')
self.annotation_field_kind = CodeElementKind.objects.get(
kind='annotation field')
self.enumeration_value_kind = CodeElementKind.objects.get(
kind='enumeration value')
self.ASTParser = self.gateway.jvm.org.eclipse.jdt.core.dom.ASTParser
self.JLS3 = self.gateway.jvm.org.eclipse.jdt.core.dom.AST.JLS3
self.ast_parser = self.ASTParser.newParser(self.JLS3)
self.IJavaElement = self.gateway.jvm.org.eclipse.jdt.core.IJavaElement
self.Modifier = self.gateway.jvm.org.eclipse.jdt.core.dom.Modifier
def _get_type_bindings(self, cunit):
children = cunit.getChildren()
new_types = []
type_type = self.IJavaElement.TYPE
for child in children:
if child.getElementType() == type_type:
new_types.append(child)
array = self.gateway.new_array(self.IJavaElement, len(new_types))
for i, type_element in enumerate(new_types):
array[i] = type_element
self.ast_parser.setSource(cunit)
bindings = self.ast_parser.createBindings(array, None)
return bindings
def run(self):
while True:
item = self.queue.get()
if item is None:
# Sentinel value to indicate we are done.
break
(cu, package_code_element, cu_name, work_amount) = item
self.progress_monitor.info('Parsing {0}'.format(cu_name))
try:
for type_binding in self._get_type_bindings(cu):
if type_binding is None:
# This is an anonymous class in a .class
continue
self._parse_type(type_binding, package_code_element)
except Exception:
print_exc()
# Useful for Py4J
gc.collect()
self.queue.task_done()
self.progress_monitor.work('Parsed {0}'.format(cu_name),
work_amount)
self.queue.task_done()
# Because django does not automatically close a connection created by
# a custom thread...
connection.close()
def _parse_type(self, type_binding, container_code_element):
if type_binding.isAnonymous():
return
java_element = type_binding.getJavaElement()
(simple_name, fqn) = clean_java_name(type_binding.getQualifiedName())
deprecated = type_binding.isDeprecated()
abstract = self.Modifier.isAbstract(type_binding.getModifiers()) or \
(type_binding.isInterface() and not type_binding.isAnnotation())
type_code_element = CodeElement(codebase=self.codebase,
simple_name=simple_name,
fqn=fqn,
eclipse_handle=java_element.getHandleIdentifier(),
parser=JAVA_PARSER,
deprecated=deprecated,
abstract=abstract)
type_code_element.binding = type_binding
if type_binding.isAnnotation():
type_code_element.kind = self.annotation_kind
elif type_binding.isEnum():
type_code_element.kind = self.enumeration_kind
else:
type_code_element.kind = self.class_kind
type_code_element.save()
type_code_element.containers.add(container_code_element)
self._parse_type_members(type_binding, type_code_element)
self._parse_type_hierarchy(type_binding, type_code_element)
def _parse_type_members(self, type_binding, type_code_element):
for method_binding in type_binding.getDeclaredMethods():
if method_binding.isAnnotationMember():
self._parse_annotation_field(method_binding, type_code_element)
else:
self._parse_method(method_binding, type_code_element)
for field_binding in type_binding.getDeclaredFields():
if field_binding.isEnumConstant():
self._parse_enumeration_value(field_binding, type_code_element)
else:
self._parse_field(field_binding, type_code_element)
for tbinding in type_binding.getDeclaredTypes():
self._parse_type(tbinding, type_code_element)
def _parse_type_hierarchy(self, type_binding, type_code_element):
supertypes = [type_code_element.fqn]
super_class = type_binding.getSuperclass()
if super_class != None:
(_, fqn) = clean_java_name(super_class.getQualifiedName())
supertypes.append(fqn)
for interface in type_binding.getInterfaces():
(_, fqn) = clean_java_name(interface.getQualifiedName())
supertypes.append(fqn)
# Save hierarchy for further processing
if len(supertypes) > 1:
self.hierarchies.append(supertypes)
def _parse_method(self, method_binding, container_code_element):
# method header
if self._is_private(method_binding):
return
java_element = method_binding.getJavaElement()
if java_element is None:
# This means that the method was inferred like default
# constructor.
# This is for compatibility with previous recodoc.
return
simple_name = method_binding.getName()
(_, fqn) = clean_java_name(
method_binding.getDeclaringClass().getQualifiedName())
fqn = fqn + '.' + simple_name
parameters = method_binding.getParameterTypes()
try:
parameter_names = java_element.getParameterNames()
except Py4JJavaError:
parameter_names = ["arg" for param in parameters]
params_length = len(parameters)
(return_simple_name, return_fqn) = clean_java_name(
method_binding.getReturnType().getQualifiedName())
deprecated = method_binding.isDeprecated()
type_binding = container_code_element.binding
abstract = self.Modifier.isAbstract(method_binding.getModifiers())\
or (type_binding.isInterface() and
not type_binding.isAnnotation())
method_code_element = MethodElement(codebase=self.codebase,
kind=self.method_kind, simple_name=simple_name,
fqn=fqn,
parameters_length=params_length,
eclipse_handle=java_element.getHandleIdentifier(),
return_simple_name=return_simple_name,
return_fqn=return_fqn,
parser=JAVA_PARSER,
deprecated=deprecated,
abstract=abstract)
# method container
method_code_element.save()
method_code_element.containers.add(container_code_element)
# parse parameters
for i, parameter in enumerate(parameters):
(type_simple_name, type_fqn) = clean_java_name(
parameter.getQualifiedName())
parameter_name = parameter_names[i]
if parameter_name.startswith('arg'):
parameter_name = ''
simple_name = fqn = parameter_name
parameter_code_element = ParameterElement(
codebase=self.codebase,
kind=self.method_parameter_kind,
simple_name=simple_name,
fqn=fqn,
type_simple_name=type_simple_name,
type_fqn=type_fqn,
index=i,
attcontainer=method_code_element,
parser=JAVA_PARSER)
parameter_code_element.save()
# If we ever need to get the deprecated replace
# method.getJavadoc()
# method.tags()
# look for tag.getTagName() == 'deprecated'
# look at subtag link or just plain text...
def _is_private(self, binding):
return self.Modifier.isPrivate(binding.getModifiers())
def _parse_field(self, field_binding, container_code_element):
if not self._is_private(field_binding):
java_element = field_binding.getJavaElement()
simple_name = field_binding.getName()
(_, fqn) = clean_java_name(
field_binding.getDeclaringClass().getQualifiedName())
fqn = fqn + '.' + simple_name
(type_simple_name, type_fqn) = clean_java_name(
field_binding.getType().getQualifiedName())
field_code_element = FieldElement(codebase=self.codebase,
kind=self.field_kind,
simple_name=simple_name,
fqn=fqn,
eclipse_handle=java_element.getHandleIdentifier(),
type_simple_name=type_simple_name,
type_fqn=type_fqn,
parser=JAVA_PARSER)
field_code_element.save()
field_code_element.containers.add(container_code_element)
def _parse_enumeration_value(self, field_binding, container_code_element):
if not self._is_private(field_binding):
java_element = field_binding.getJavaElement()
simple_name = field_binding.getName()
(_, fqn) = clean_java_name(
field_binding.getDeclaringClass().getQualifiedName())
fqn = fqn + '.' + simple_name
(type_simple_name, type_fqn) = clean_java_name(
field_binding.getType().getQualifiedName())
field_code_element = FieldElement(codebase=self.codebase,
kind=self.enumeration_value_kind,
simple_name=simple_name,
fqn=fqn,
eclipse_handle=java_element.getHandleIdentifier(),
type_simple_name=type_simple_name,
type_fqn=type_fqn,
parser=JAVA_PARSER)
field_code_element.save()
field_code_element.containers.add(container_code_element)
def _parse_annotation_field(self, method_binding, container_code_element):
if not self._is_private(method_binding):
java_element = method_binding.getJavaElement()
simple_name = method_binding.getName()
(_, fqn) = clean_java_name(
method_binding.getDeclaringClass().getQualifiedName())
fqn = fqn + '.' + simple_name
(type_simple_name, type_fqn) = clean_java_name(
method_binding.getReturnType().getQualifiedName())
field_code_element = FieldElement(codebase=self.codebase,
kind=self.annotation_field_kind,
simple_name=simple_name,
fqn=fqn,
eclipse_handle=java_element.getHandleIdentifier(),
type_simple_name=type_simple_name,
type_fqn=type_fqn,
attcontainer=container_code_element,
parser=JAVA_PARSER)
field_code_element.save()
field_code_element.containers.add(container_code_element)
class JavaParser(object):
'''Parses a Java codebase and creates the appropriate CodeElement.
This parser uses multiple threads to speed up the parsing. This parser
requires access to Eclipse/Py4J'''
JAVA_SRC_FOLDER = 'src'
def __init__(self, codebase, project_key, opt_input):
'''
:param project_key: The name of the project in the Eclipse workspace.
:param codebase: The codebase instance to which the CodeElement will
be associated with.
:param opt_input: Optional input. Not used by this parser.
'''
self.project_name = project_key
self.gateway = JavaGateway()
self.hierarchies = deque() # list of tuples. [(parent, child, child)]
self.codebase = codebase
self.queue = Queue()
self.package_kind = CodeElementKind.objects.get(kind='package')
if opt_input is None or opt_input.strip() == '' or opt_input == '-1':
self.proot_name = None
self.package_names = None
else:
inputs = opt_input.split(',')
self.proot_name = inputs[0].strip()
self.package_names = inputs[1:]
def _get_package_root(self):
ResourcePlugin = self.gateway.jvm.org.eclipse.core.resources.\
ResourcesPlugin
workspaceRoot = ResourcePlugin.getWorkspace().getRoot()
project = workspaceRoot.getProject(self.project_name)
java_project = self.gateway.jvm.org.eclipse.jdt.core.JavaCore.\
create(project)
if self.proot_name is None:
src_folder = project.getFolder(JavaParser.JAVA_SRC_FOLDER)
proot = java_project.getPackageFragmentRoot(src_folder)
else:
proot = None
for temp_proot in java_project.getAllPackageFragmentRoots():
if temp_proot.getElementName() == self.proot_name:
proot = temp_proot
break
return proot
def _should_filter_package(self, package_name):
if self.package_names is None:
return False
else:
should_keep = False
for pname in self.package_names:
if package_name.startswith(pname):
should_keep = True
break
return not should_keep
def _parse_packages(self, proot):
packages = []
for package in proot.getChildren():
if package.hasChildren():
package_name = package.getElementName()
if self._should_filter_package(package_name):
continue
package_code_element = CodeElement(codebase=self.codebase,
simple_name=package_name, fqn=package_name,
eclipse_handle=package.getHandleIdentifier(),
kind=self.package_kind, parser=JAVA_PARSER)
package_code_element.save()
packages.append((package, package_code_element))
return packages
def _need_class_files(self):
return self.proot_name is not None and self.proot_name.endswith('.jar')
def parse(self, progress_monitor=NullProgressMonitor()):
'''Parses the codebase and creates CodeElement instances.
:progress_monitor: A progress monitor to track the parsing progress.
'''
proot = self._get_package_root()
packages = self._parse_packages(proot)
progress_monitor.start('Parsing Java Project', len(packages))
# Start workers:
for _ in xrange(0, PARSER_WORKER):
worker = CUWorker(self.queue, self.codebase, self.hierarchies,
self.gateway, progress_monitor)
worker.start()
start = time.time()
for (package, package_code_element) in packages:
gc.collect() # for Py4J
if self._need_class_files():
cunits = package.getClassFiles()
else:
cunits = package.getCompilationUnits()
unit_length = float(len(cunits))
for cunit in cunits:
cu_name = cunit.getElementName()
if cu_name.find('$') > -1:
# Do not send internal classes: they will be parsed
# using type_binding.getDeclaredTypes()
continue
winput = (cunit, package_code_element, cu_name,
1.0 / unit_length)
self.queue.put(winput)
for _ in xrange(0, PARSER_WORKER):
self.queue.put(None)
progress_monitor.info('Done parsing packages. Waiting for CUs.')
self.queue.join()
progress_monitor.done()
self.gateway.close()
print('Time: ' + str(time.time() - start))
self.parse_hierarchy(progress_monitor)
def parse_hierarchy(self, progress_monitor=NullProgressMonitor()):
'''Builds the hierarchy of the parsed CodeElement instances.
Must be called *after* parse.
:param progress_monitor:
'''
queue = Queue()
for hierarchy in self.hierarchies:
queue.put(hierarchy)
progress_monitor.start('Parsing Java Hierarchy', len(self.hierarchies))
start = time.time()
for _ in xrange(0, HIERARCHY_WORKER):
# Sentinel value
queue.put(None)
worker = HierarchyWorker(queue, self.codebase, progress_monitor)
worker.start()
queue.join()
progress_monitor.done()
self.gateway.close()
print('Time: ' + str(time.time() - start))
| bartdag/recodoc2 | recodoc2/apps/codebase/parser/java_code_parser.py | Python | bsd-3-clause | 20,241 |
from rest_framework import viewsets
from rest_framework.permissions import IsAuthenticated
from .models import Submission
from .serializers import SubmissionSerializer
from django.views.generic import ListView, DetailView
from django.views.generic.edit import CreateView
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required
from problem.models import Problem
from django.shortcuts import get_object_or_404
from .forms import SubmissionForm
from django_tables2 import RequestConfig
from .tables import SubmissionTable
# from guardian.shortcuts import get_objects_for_user
class SubmissionViewSet(viewsets.ModelViewSet):
queryset = Submission.objects.all()
serializer_class = SubmissionSerializer
permission_classes = (IsAuthenticated,)
class SubmissionListView(ListView):
model = Submission
def get_context_data(self, **kwargs):
context = super(SubmissionListView, self).get_context_data(**kwargs)
submissions_table = SubmissionTable(self.get_queryset())
RequestConfig(self.request).configure(submissions_table)
# add filter here
context['submissions_table'] = submissions_table
return context
class SubmissionDetailView(DetailView):
model = Submission
def get_context_data(self, **kwargs):
context = super(SubmissionDetailView, self).get_context_data(**kwargs)
return context
class SubmissionCreateView(CreateView):
model = Submission
form_class = SubmissionForm
template_name_suffix = '_create_form'
@method_decorator(login_required)
def dispatch(self, request, pid=None, *args, **kwargs):
pid = self.kwargs['pid']
self.problem = get_object_or_404(Problem.objects.all(), pk=pid)
return super(SubmissionCreateView, self).dispatch(request, *args, **kwargs)
def get_form_kwargs(self):
kw = super(SubmissionCreateView, self).get_form_kwargs()
kw['qs'] = self.problem.allowed_lang.all()
return kw
def get_context_data(self, **kwargs):
context = super(SubmissionCreateView, self).get_context_data(**kwargs)
context['problem'] = self.problem
return context
def form_valid(self, form):
self.object = form.save(commit=False)
self.object.problem = self.problem
self.object.user = self.request.user
return super(SubmissionCreateView, self).form_valid(form)
| wangzitian0/BOJ-V4 | submission/views.py | Python | mit | 2,454 |
#!/usr/bin/env python
"""
Simplest demo of using PyGame to playback audio from Python
https://www.scivision.co/playing-sounds-from-numpy-arrays-in-python/
"""
import pygame
from time import sleep
from pyimagevideo import dialtone
fs = 8000 # Hz
x = (dialtone(fs) * 32768).astype('int16') # scale to int16 for sound card
pygame.mixer.pre_init(fs, size=-16, channels=1)
pygame.mixer.init()
sound = pygame.sndarray.make_sound(x)
sound.play()
sleep(0.01) # NOTE: Since sound playback is async, allow sound playback to start before Python exits
| scienceopen/pyimagevideo | audio_pygame.py | Python | gpl-3.0 | 549 |
from izrazi_cnf import *
#################### primeri za cnf, SAT ####################
p = Spr('p')
r = Spr('r')
q = Spr('q')
a = Spr('a')
b = Spr('b')
c = Spr('c')
d = Spr('d')
e = Spr('e')
f = Spr('f')
p1, p1_cnf = Ali(a), a
p2, p2_cnf = In(a,Neg(a)), F()
p3, p3_cnf = Ali(a,Neg(a)), T()
p4, p4_cnf = In(T(),F(),Ali(p,Neg(p))), F()
p5, p5_cnf = Ali(Neg(In(p,r,q))), Ali(Neg(r),Neg(p),Neg(q))
p6, p6_cnf = In(T(),In(p,Neg(p))), F()
p7, p7_cnf = In(a), a
p8, p8_cnf = Ali(p,In(q,p)), In(p,Ali(p,q))
p9, p9_cnf = In(p,Ali(q,Neg(p))), In(p,Ali(q,Neg(p)))
p10, p10_cnf = Ali(Ali(a)), a
p11, p11_cnf = Ali(Ali(a,b),In(Neg(a),b)), Ali(a,b)
p12, p12_cnf = In(Ali(p,q),Ali(p,r)), In(Ali(p,q),Ali(p,r))
p13, p13_cnf = In(In(p,q),In(q,r),In(r,p)), In(p,q,r)
p14, p14_cnf = Ali(In(p,q),In(a,b,Neg(p))), In(Ali(a,p),Ali(a,q),Ali(b,p),Ali(b,q),Ali(Neg(p),q))
p15, p15_cnf = In(Ali(In(p,r),In(a,b)),f), In(f, Ali(a,p),Ali(a,r),Ali(b,p),Ali(b,r))
p16 = Ali(In(a,Ali(Ali(b,d),In(e,f))),In(c,Ali(d,a)),e)
p17 = Ali(F(),Ali(a,b,c),In(Neg(a),e,f,Ali(c,d),T()),Neg(Ali(Neg(e),d)),In(b,f))
#################### primeri za sudoku ####################
## Neresljiv sudoku
sud1 = [(1,2,8),(1,4,3),(1,5,1),
(2,3,3),(2,6,5),(2,7,4),(2,9,1),
(3,4,7),(3,7,8),(3,8,5),
(4,1,9),(4,2,7),(4,6,2),(4,9,6),
(5,1,4),(5,2,6),(5,3,1),(5,7,7),(5,8,9),(5,9,4),
(6,1,2),(6,4,6),(6,8,8),(6,9,4),
(7,2,4),(7,3,7),(7,6,1),
(8,1,8),(8,3,9),(8,4,2),(8,7,3),
(9,5,7),(9,6,3),(9,8,1)]
## Sudokuji z resitvijo
sud2 = [(1,1,8),(1,5,9),(1,6,3),(1,7,7),(1,9,1),
(2,5,5),(2,7,3),(2,8,6),(2,9,9),
(3,3,5),(3,4,6),(3,5,7),
(4,6,8),(4,9,6),
(5,1,6),(5,2,7),(5,3,4),(5,4,9),(5,6,5),(5,7,2),(5,8,3),(5,9,8),
(6,1,1),(6,4,7),
(7,5,8),(7,6,9),(7,7,5),
(8,1,9),(8,2,1),(8,3,2),(8,5,3),
(9,1,5),(9,3,8),(9,4,4),(9,5,2),(9,9,7)]
sud3 = [(1,2,1),(1,5,6),(1,7,4),(1,8,3),(1,9,9),
(2,5,4),(2,6,3),(2,7,5),
(3,1,4),(3,4,9),(3,5,5),(3,6,1),(3,7,2),(3,8,8),
(4,5,2),(4,7,9),(4,8,5),(4,9,4),
(5,1,6),(5,2,9),(5,5,7),(5,6,4),(5,7,8),(5,8,1),(5,9,3),
(6,1,5),(6,3,3),(6,5,8),
(7,3,8),(7,6,5),
(8,3,1),(8,4,2),
(9,1,9),(9,3,4),(9,5,1),(9,8,7)]
sud4 = [(1,3,6),(1,5,7),(1,6,4),(1,8,8),(1,9,2),
(2,3,9),(2,6,5),(2,9,3),
(4,2,6),(4,4,5),(4,5,3),(4,6,2),
(5,4,1),(5,6,9),
(6,4,7),(6,5,8),(6,6,6),(6,8,2),
(7,1,7),(7,3,5),(7,5,9),(7,6,3),(7,8,6),
(8,1,6),(8,4,8),(8,7,3),
(9,1,1),(9,2,9),(9,4,6),(9,5,2),(9,7,8)]
sud5 = [(1,1,9),(1,2,2),(1,5,1),(1,6,5),
(2,3,5),(2,8,6),
(3,1,6),(3,2,1),(3,4,3),(3,9,4),
(4,1,2),(4,2,8),(4,5,4),
(5,1,1),(5,5,3),(5,9,6),
(6,5,8),(6,8,9),(6,9,5),
(7,1,4),(7,6,9),(7,8,5),(7,9,3),
(8,2,9),(8,7,6),
(9,4,8),(9,5,6),(9,8,4),(9,9,1)]
##Poln sudoku
sud6 = [(1,1,5),(1,2,3),(1,3,6),(1,4,9),(1,5,7),(1,6,4),(1,7,1),(1,8,8),(1,9,2),
(2,1,8),(2,2,7),(2,3,9),(2,4,2),(2,5,1),(2,6,5),(2,7,6),(2,8,4),(2,9,3),
(3,1,4),(3,2,2),(3,3,1),(3,4,3),(3,5,6),(3,6,8),(3,7,9),(3,8,7),(3,9,5),
(4,1,9),(4,2,6),(4,3,7),(4,4,5),(4,5,3),(4,6,2),(4,7,4),(4,8,1),(4,9,8),
(5,1,2),(5,2,5),(5,3,8),(5,4,1),(5,5,4),(5,6,9),(5,7,7),(5,8,3),(5,9,6),
(6,1,3),(6,2,1),(6,3,4),(6,4,7),(6,5,8),(6,6,6),(6,7,5),(6,8,2),(6,9,9),
(7,1,7),(7,2,8),(7,3,5),(7,4,4),(7,5,9),(7,6,3),(7,7,2),(7,8,6),(7,9,1),
(8,1,6),(8,2,4),(8,3,2),(8,4,8),(8,5,5),(8,6,1),(8,7,3),(8,8,9),(8,9,7),
(9,1,1),(9,2,9),(9,3,3),(9,4,6),(9,5,2),(9,6,7),(9,7,8),(9,8,5),(9,9,4)]
#################### primeri za barvanje grafa ####################
g1 = {'a':{'b'},'b':{'a','c'},'c':{'b','d'},'d':{'c','e'},'e':{'d'}}
g2 = {'a':{'b','f'},'b':{'a','c','f'},'c':{'b','d','f'},'d':{'c','e','f'},'e':{'d','f'},'f':{'a','b','c','d','e'}}
g3 = {'a':{'b','f','g'},'b':{'a','c'},'c':{'b','d','g'},'d':{'c','e'},'e':{'d','f','g'},'f':{'a','e','g'},'g':{'a','c','e','f'}}
g4 = {'a':{'b','c'},'b':{'a','e','f'},'c':{'a','d'},'d':{'c'},'e':{'b'},'f':{'b'}}
g5 = {1:{2,6,7},2:{1,7,5,3},3:{2,4},4:{3,5,6},5:{2,4,6},6:{1,5,4},7:{1,2}}
g6 = {1:{2,3,4,5,6},2:{1,3,4,5,6},3:{1,2,4,5,6},4:{1,2,3,5,6},5:{1,2,3,4,6},6:{1,2,3,4,5}} #poln graf na 6 vozliscih
g7 = {1:{2,5,6},2:{1,3,7},3:{2,4,8},4:{3,5,9},5:{4,1,10},6:{1,8,9},7:{2,9,10},8:{3,10,6},9:{4,6,7},10:{5,7,8}} #petersenov graf
g8 = {1:{2,4,5},2:{1,3,5,6},3:{2,5,6},4:{1,5},5:{1,2,3,4,6},6:{2,3,5}}
| JanaVi/LVR | primeri.py | Python | apache-2.0 | 4,471 |
"""Constants for the auth module."""
from datetime import timedelta
ACCESS_TOKEN_EXPIRATION = timedelta(minutes=30)
MFA_SESSION_EXPIRATION = timedelta(minutes=5)
GROUP_ID_ADMIN = "system-admin"
GROUP_ID_USER = "system-users"
GROUP_ID_READ_ONLY = "system-read-only"
| Danielhiversen/home-assistant | homeassistant/auth/const.py | Python | apache-2.0 | 267 |
from django.core.exceptions import ObjectDoesNotExist
from rest_framework.compat import NoReverseMatch
class MockObject(object):
def __init__(self, **kwargs):
self._kwargs = kwargs
for key, val in kwargs.items():
setattr(self, key, val)
def __str__(self):
kwargs_str = ', '.join([
'%s=%s' % (key, value)
for key, value in sorted(self._kwargs.items())
])
return '<MockObject %s>' % kwargs_str
class MockQueryset(object):
def __init__(self, iterable):
self.items = iterable
def __getitem__(self, val):
return self.items[val]
def get(self, **lookup):
for item in self.items:
if all([
getattr(item, key, None) == value
for key, value in lookup.items()
]):
return item
raise ObjectDoesNotExist()
class BadType(object):
"""
When used as a lookup with a `MockQueryset`, these objects
will raise a `TypeError`, as occurs in Django when making
queryset lookups with an incorrect type for the lookup value.
"""
def __eq__(self):
raise TypeError()
def mock_reverse(view_name, args=None, kwargs=None, request=None, format=None):
args = args or []
kwargs = kwargs or {}
value = (args + list(kwargs.values()) + ['-'])[0]
prefix = 'http://example.org' if request else ''
suffix = ('.' + format) if (format is not None) else ''
return '%s/%s/%s%s/' % (prefix, view_name, value, suffix)
def fail_reverse(view_name, args=None, kwargs=None, request=None, format=None):
raise NoReverseMatch()
| atombrella/django-rest-framework | tests/utils.py | Python | bsd-2-clause | 1,646 |
# Roundware Server is released under the GNU Affero General Public License v3.
# See COPYRIGHT.txt, AUTHORS.txt, and LICENSE.txt in the project root directory.
from __future__ import unicode_literals
from django.conf.urls import patterns, url, include
from roundware.api1 import views
import logging
logger = logging.getLogger(__name__)
urlpatterns = patterns('',
# V1 API
url(r'^$', 'api1.views.operations'),
url(r'^auth/', include('rest_framework.urls',
namespace='rest_framework')),
# V1 DRF API - V1 is partially REST.
url(r'^rest/$', views.APIRootView.as_view()),
url(r'^rest/asset/$', views.AssetList.as_view(),
name='api1-asset'),
url(r'^rest/assetlocation/$', views.AssetLocationList.as_view(),
name='api1-assetlocation'),
url(r'^rest/assetlocation/(?P<pk>[0-9]+)/$',
views.AssetLocationDetail.as_view(),
name='api1-assetlocation-detail'),
url(r'^rest/project/$', views.ProjectList.as_view(),
name='api1-project'),
url(r'^rest/event/$', views.EventList.as_view(),
name='api1-event'),
url(r'^rest/session/$', views.SessionList.as_view(),
name='api1-session'),
url(r'^rest/listeninghistoryitem/$',
views.ListeningHistoryItemList.as_view(),
name='api1-listeninghistoryitem'),
)
| yangjackascd/roundware-server | roundware/api1/urls.py | Python | agpl-3.0 | 1,338 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import factory
reload(factory)
from factory import *
def pyethapp_factory(branch='master'):
factory = BuildFactory()
for step in [
Git(
haltOnFailure=True,
logEnviron=False,
repourl='https://github.com/ethereum/pyethapp.git',
branch=branch,
mode='full',
method='copy',
codebase='pyethapp',
retry=(5, 3)
),
SetPropertyFromCommand(
haltOnFailure=True,
logEnviron=False,
name="set-version",
command='sed -ne "s/.*version=.*[^0-9]\([0-9]*\.[0-9]*\.[0-9]*\).*/\\1/p" setup.py',
property="version"
),
ShellCommand(
haltOnFailure=True,
logEnviron=False,
name="pip-requirements",
description="installing requirements",
descriptionDone="install requirements",
command=["pip", "install", "-r", "requirements.txt"]
),
ShellCommand(
haltOnFailure=True,
logEnviron=False,
name="upgrade-requirements",
description="upgrading test requirements",
descriptionDone="upgrade test requirements",
command=["pip", "install", "--upgrade", "--no-deps", "-r", "requirements.txt"]
),
ShellCommand(
haltOnFailure=True,
logEnviron=False,
name="pip-install",
description="installing",
descriptionDone="install",
command=["pip", "install", "-e", "."]
),
ShellCommand(
logEnviron=False,
description="running",
descriptionDone="run",
name="pyethapp",
command=["pyethapp", "--help"]
)
]: factory.addStep(step)
return factory
| vaporry/ethereum-buildbot | factories/pyethapp.py | Python | mit | 1,885 |
# -*- coding: utf-8 -*-
## This file is part of Invenio.
## Copyright (C) 2009, 2010, 2011 CERN.
##
## Invenio 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.
##
## Invenio 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 Invenio; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
"""
mod_python->WSGI Framework utilities
This code has been taken from mod_python original source code and rearranged
here to easying the migration from mod_python to wsgi.
The code taken from mod_python is under the following License.
"""
# Copyright 2004 Apache Software Foundation
#
# 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.
#
# Originally developed by Gregory Trubetskoy.
#
# $Id: apache.py 468216 2006-10-27 00:54:12Z grahamd $
from wsgiref.headers import Headers
import time
import re
import os
import cgi
import cStringIO
import tempfile
from types import TypeType, ClassType, BuiltinFunctionType, MethodType, ListType
from invenio.config import CFG_TMPDIR, CFG_TMPSHAREDDIR
from invenio.webinterface_handler_config import \
SERVER_RETURN, \
HTTP_LENGTH_REQUIRED, \
HTTP_BAD_REQUEST, \
InvenioWebInterfaceWSGIContentLenghtError, \
InvenioWebInterfaceWSGIContentTypeError, \
InvenioWebInterfaceWSGIContentMD5Error
class table(Headers):
add = Headers.add_header
iteritems = Headers.items
def __getitem__(self, name):
ret = Headers.__getitem__(self, name)
if ret is None:
return ''
else:
return str(ret)
## Some functions made public
exists_config_define = lambda dummy: True
## Some constants
class metaCookie(type):
def __new__(cls, clsname, bases, clsdict):
_valid_attr = (
"version", "path", "domain", "secure",
"comment", "expires", "max_age",
# RFC 2965
"commentURL", "discard", "port",
# Microsoft Extension
"httponly" )
# _valid_attr + property values
# (note __slots__ is a new Python feature, it
# prevents any other attribute from being set)
__slots__ = _valid_attr + ("name", "value", "_value",
"_expires", "__data__")
clsdict["_valid_attr"] = _valid_attr
clsdict["__slots__"] = __slots__
def set_expires(self, value):
if type(value) == type(""):
# if it's a string, it should be
# valid format as per Netscape spec
try:
t = time.strptime(value, "%a, %d-%b-%Y %H:%M:%S GMT")
except ValueError:
raise ValueError, "Invalid expires time: %s" % value
t = time.mktime(t)
else:
# otherwise assume it's a number
# representing time as from time.time()
t = value
value = time.strftime("%a, %d-%b-%Y %H:%M:%S GMT",
time.gmtime(t))
self._expires = "%s" % value
def get_expires(self):
return self._expires
clsdict["expires"] = property(fget=get_expires, fset=set_expires)
return type.__new__(cls, clsname, bases, clsdict)
class Cookie(object):
"""
This class implements the basic Cookie functionality. Note that
unlike the Python Standard Library Cookie class, this class represents
a single cookie (not a list of Morsels).
"""
__metaclass__ = metaCookie
DOWNGRADE = 0
IGNORE = 1
EXCEPTION = 3
def parse(Class, str, **kw):
"""
Parse a Cookie or Set-Cookie header value, and return
a dict of Cookies. Note: the string should NOT include the
header name, only the value.
"""
dict = _parse_cookie(str, Class, **kw)
return dict
parse = classmethod(parse)
def __init__(self, name, value, **kw):
"""
This constructor takes at least a name and value as the
arguments, as well as optionally any of allowed cookie attributes
as defined in the existing cookie standards.
"""
self.name, self.value = name, value
for k in kw:
setattr(self, k.lower(), kw[k])
# subclasses can use this for internal stuff
self.__data__ = {}
def __str__(self):
"""
Provides the string representation of the Cookie suitable for
sending to the browser. Note that the actual header name will
not be part of the string.
This method makes no attempt to automatically double-quote
strings that contain special characters, even though the RFC's
dictate this. This is because doing so seems to confuse most
browsers out there.
"""
result = ["%s=%s" % (self.name, self.value)]
# pylint: disable=E1101
# The attribute _valid_attr is provided by the metaclass 'metaCookie'.
for name in self._valid_attr:
if hasattr(self, name):
if name in ("secure", "discard", "httponly"):
result.append(name)
else:
result.append("%s=%s" % (name, getattr(self, name)))
# pylint: enable=E1101
return "; ".join(result)
def __repr__(self):
return '<%s: %s>' % (self.__class__.__name__,
str(self))
# This is a simplified and in some places corrected
# (at least I think it is) pattern from standard lib Cookie.py
_cookiePattern = re.compile(
r"(?x)" # Verbose pattern
r"[,\ ]*" # space/comma (RFC2616 4.2) before attr-val is eaten
r"(?P<key>" # Start of group 'key'
r"[^;\ =]+" # anything but ';', ' ' or '='
r")" # End of group 'key'
r"\ *(=\ *)?" # a space, then may be "=", more space
r"(?P<val>" # Start of group 'val'
r'"(?:[^\\"]|\\.)*"' # a doublequoted string
r"|" # or
r"[^;]*" # any word or empty string
r")" # End of group 'val'
r"\s*;?" # probably ending in a semi-colon
)
def _parse_cookie(str, Class, names=None):
# XXX problem is we should allow duplicate
# strings
result = {}
matchIter = _cookiePattern.finditer(str)
for match in matchIter:
key, val = match.group("key"), match.group("val")
# We just ditch the cookies names which start with a dollar sign since
# those are in fact RFC2965 cookies attributes. See bug [#MODPYTHON-3].
if key[0] != '$' and names is None or key in names:
result[key] = Class(key, val)
return result
def get_cookies(req, Class=Cookie, **kw):
"""
A shorthand for retrieveing and parsing cookies given
a Cookie class. The class must be one of the classes from
this module.
"""
if not req.headers_in.has_key("cookie"):
return {}
cookies = req.headers_in["cookie"]
if type(cookies) == type([]):
cookies = '; '.join(cookies)
return Class.parse(cookies, **kw)
def get_cookie(req, name, Class=Cookie, **kw):
cookies = get_cookies(req, Class, names=[name], **kw)
if cookies.has_key(name):
return cookies[name]
parse_qs = cgi.parse_qs
parse_qsl = cgi.parse_qsl
# Maximum line length for reading. (64KB)
# Fixes memory error when upload large files such as 700+MB ISOs.
readBlockSize = 65368
""" The classes below are a (almost) a drop-in replacement for the
standard cgi.py FieldStorage class. They should have pretty much the
same functionality.
These classes differ in that unlike cgi.FieldStorage, they are not
recursive. The class FieldStorage contains a list of instances of
Field class. Field class is incapable of storing anything in it.
These objects should be considerably faster than the ones in cgi.py
because they do not expect CGI environment, and are
optimized specifically for Apache and mod_python.
"""
class Field:
def __init__(self, name, *args, **kwargs):
self.name = name
# Some third party packages such as Trac create
# instances of the Field object and insert it
# directly into the list of form fields. To
# maintain backward compatibility check for
# where more than just a field name is supplied
# and invoke an additional initialisation step
# to process the arguments. Ideally, third party
# code should use the add_field() method of the
# form, but if they need to maintain backward
# compatibility with older versions of mod_python
# they will not have a choice but to use old
# way of doing things and thus we need this code
# for the forseeable future to cope with that.
if args or kwargs:
self.__bc_init__(*args, **kwargs)
def __bc_init__(self, file, ctype, type_options,
disp, disp_options, headers = {}):
self.file = file
self.type = ctype
self.type_options = type_options
self.disposition = disp
self.disposition_options = disp_options
if disp_options.has_key("filename"):
self.filename = disp_options["filename"]
else:
self.filename = None
self.headers = headers
def __repr__(self):
"""Return printable representation."""
return "Field(%s, %s)" % (`self.name`, `self.value`)
def __getattr__(self, name):
if name != 'value':
raise AttributeError, name
if self.file:
self.file.seek(0)
value = self.file.read()
self.file.seek(0)
else:
value = None
return value
def __del__(self):
self.file.close()
class StringField(str):
""" This class is basically a string with
added attributes for compatibility with std lib cgi.py. Basically, this
works the opposite of Field, as it stores its data in a string, but creates
a file on demand. Field creates a value on demand and stores data in a file.
"""
filename = None
headers = {}
ctype = "text/plain"
type_options = {}
disposition = None
disp_options = None
def __new__(cls, value):
'''Create StringField instance. You'll have to set name yourself.'''
obj = str.__new__(cls, value)
obj.value = value
return obj
def __str__(self):
return str.__str__(self)
def __getattr__(self, name):
if name != 'file':
raise AttributeError, name
self.file = cStringIO.StringIO(self.value)
return self.file
def __repr__(self):
"""Return printable representation (to pass unit tests)."""
return "Field(%s, %s)" % (`self.name`, `self.value`)
class FieldList(list):
def __init__(self):
self.__table = None
list.__init__(self)
def table(self):
if self.__table is None:
self.__table = {}
for item in self:
if item.name in self.__table:
self.__table[item.name].append(item)
else:
self.__table[item.name] = [item]
return self.__table
def __delitem__(self, *args):
self.__table = None
return list.__delitem__(self, *args)
def __delslice__(self, *args):
self.__table = None
return list.__delslice__(self, *args)
def __iadd__(self, *args):
self.__table = None
return list.__iadd__(self, *args)
def __imul__(self, *args):
self.__table = None
return list.__imul__(self, *args)
def __setitem__(self, *args):
self.__table = None
return list.__setitem__(self, *args)
def __setslice__(self, *args):
self.__table = None
return list.__setslice__(self, *args)
def append(self, *args):
self.__table = None
return list.append(self, *args)
def extend(self, *args):
self.__table = None
return list.extend(self, *args)
def insert(self, *args):
self.__table = None
return list.insert(self, *args)
def pop(self, *args):
self.__table = None
return list.pop(self, *args)
def remove(self, *args):
self.__table = None
return list.remove(self, *args)
class FieldStorage:
def __init__(self, req, keep_blank_values=0, strict_parsing=0, file_callback=None, field_callback=None, to_tmp_shared=False):
#
# Whenever readline is called ALWAYS use the max size EVEN when
# not expecting a long line. - this helps protect against
# malformed content from exhausting memory.
#
self.list = FieldList()
self.wsgi_input_consumed = False
# always process GET-style parameters
if req.args:
pairs = parse_qsl(req.args, keep_blank_values)
for pair in pairs:
self.add_field(pair[0], pair[1])
if req.method != "POST":
return
try:
clen = int(req.headers_in["content-length"])
except (KeyError, ValueError):
# absent content-length is not acceptable
raise SERVER_RETURN, HTTP_LENGTH_REQUIRED
self.clen = clen
self.count = 0
if not req.headers_in.has_key("content-type"):
ctype = "application/x-www-form-urlencoded"
else:
ctype = req.headers_in["content-type"]
if ctype.startswith("application/x-www-form-urlencoded"):
pairs = parse_qsl(req.read(clen), keep_blank_values)
self.wsgi_input_consumed = True
for pair in pairs:
self.add_field(pair[0], pair[1])
return
elif not ctype.startswith("multipart/"):
# we don't understand this content-type
return
self.wsgi_input_consumed = True
# figure out boundary
try:
i = ctype.lower().rindex("boundary=")
boundary = ctype[i+9:]
if len(boundary) >= 2 and boundary[0] == boundary[-1] == '"':
boundary = boundary[1:-1]
boundary = re.compile("--" + re.escape(boundary) + "(--)?\r?\n")
except ValueError:
raise SERVER_RETURN, HTTP_BAD_REQUEST
# read until boundary
self.read_to_boundary(req, boundary, None)
end_of_stream = False
while not end_of_stream and not self.eof(): # jjj JIM BEGIN WHILE
## parse headers
ctype, type_options = "text/plain", {}
disp, disp_options = None, {}
headers = table([])
line = req.readline(readBlockSize)
self.count += len(line)
if self.eof():
end_of_stream = True
match = boundary.match(line)
if (not line) or match:
# we stop if we reached the end of the stream or a stop
# boundary (which means '--' after the boundary) we
# continue to the next part if we reached a simple
# boundary in either case this would mean the entity is
# malformed, but we're tolerating it anyway.
end_of_stream = (not line) or (match.group(1) is not None)
continue
skip_this_part = False
while line not in ('\r','\r\n'):
nextline = req.readline(readBlockSize)
self.count += len(nextline)
if self.eof():
end_of_stream = True
while nextline and nextline[0] in [ ' ', '\t']:
line = line + nextline
nextline = req.readline(readBlockSize)
self.count += len(nextline)
if self.eof():
end_of_stream = True
# we read the headers until we reach an empty line
# NOTE : a single \n would mean the entity is malformed, but
# we're tolerating it anyway
h, v = line.split(":", 1)
headers.add(h, v)
h = h.lower()
if h == "content-disposition":
disp, disp_options = parse_header(v)
elif h == "content-type":
ctype, type_options = parse_header(v)
#
# NOTE: FIX up binary rubbish sent as content type
# from Microsoft IE 6.0 when sending a file which
# does not have a suffix.
#
if ctype.find('/') == -1:
ctype = 'application/octet-stream'
line = nextline
match = boundary.match(line)
if (not line) or match:
# we stop if we reached the end of the stream or a
# stop boundary (which means '--' after the
# boundary) we continue to the next part if we
# reached a simple boundary in either case this
# would mean the entity is malformed, but we're
# tolerating it anyway.
skip_this_part = True
end_of_stream = (not line) or (match.group(1) is not None)
break
if skip_this_part:
continue
if disp_options.has_key("name"):
name = disp_options["name"]
else:
name = None
# create a file object
# is this a file?
if disp_options.has_key("filename"):
if file_callback and callable(file_callback):
file = file_callback(disp_options["filename"])
else:
if to_tmp_shared:
file = tempfile.NamedTemporaryFile(dir=CFG_TMPSHAREDDIR)
else:
file = tempfile.NamedTemporaryFile(dir=CFG_TMPDIR)
else:
if field_callback and callable(field_callback):
file = field_callback()
else:
file = cStringIO.StringIO()
# read it in
self.read_to_boundary(req, boundary, file)
if self.eof():
end_of_stream = True
file.seek(0)
# make a Field
if disp_options.has_key("filename"):
field = Field(name)
field.filename = disp_options["filename"]
else:
field = StringField(file.read())
field.name = name
field.file = file
field.type = ctype
field.type_options = type_options
field.disposition = disp
field.disposition_options = disp_options
field.headers = headers
self.list.append(field)
def add_field(self, key, value):
"""Insert a field as key/value pair"""
item = StringField(value)
item.name = key
self.list.append(item)
def __setitem__(self, key, value):
table = self.list.table()
if table.has_key(key):
items = table[key]
for item in items:
self.list.remove(item)
item = StringField(value)
item.name = key
self.list.append(item)
def read_to_boundary(self, req, boundary, file):
previous_delimiter = None
while not self.eof():
line = req.readline(readBlockSize)
self.count += len(line)
if not line:
# end of stream
if file is not None and previous_delimiter is not None:
file.write(previous_delimiter)
return True
match = boundary.match(line)
if match:
# the line is the boundary, so we bail out
# if the two last chars are '--' it is the end of the entity
return match.group(1) is not None
if line[-2:] == '\r\n':
# the line ends with a \r\n, which COULD be part
# of the next boundary. We write the previous line delimiter
# then we write the line without \r\n and save it for the next
# iteration if it was not part of the boundary
if file is not None:
if previous_delimiter is not None: file.write(previous_delimiter)
file.write(line[:-2])
previous_delimiter = '\r\n'
elif line[-1:] == '\r':
# the line ends with \r, which is only possible if
# readBlockSize bytes have been read. In that case the
# \r COULD be part of the next boundary, so we save it
# for the next iteration
assert len(line) == readBlockSize
if file is not None:
if previous_delimiter is not None: file.write(previous_delimiter)
file.write(line[:-1])
previous_delimiter = '\r'
elif line == '\n' and previous_delimiter == '\r':
# the line us a single \n and we were in the middle of a \r\n,
# so we complete the delimiter
previous_delimiter = '\r\n'
else:
if file is not None:
if previous_delimiter is not None: file.write(previous_delimiter)
file.write(line)
previous_delimiter = None
def eof(self):
return self.clen <= self.count
def __getitem__(self, key):
"""Dictionary style indexing."""
found = self.list.table()[key]
if len(found) == 1:
return found[0]
else:
return found
def get(self, key, default):
try:
return self.__getitem__(key)
except (TypeError, KeyError):
return default
def keys(self):
"""Dictionary style keys() method."""
return self.list.table().keys()
def __iter__(self):
return iter(self.keys())
def __repr__(self):
return repr(self.list.table())
def has_key(self, key):
"""Dictionary style has_key() method."""
return (key in self.list.table())
__contains__ = has_key
def __len__(self):
"""Dictionary style len(x) support."""
return len(self.list.table())
def getfirst(self, key, default=None):
""" return the first value received """
try:
return self.list.table()[key][0]
except KeyError:
return default
def getlist(self, key):
""" return a list of received values """
try:
return self.list.table()[key]
except KeyError:
return []
def items(self):
"""Dictionary-style items(), except that items are returned in the same
order as they were supplied in the form."""
return [(item.name, item) for item in self.list]
def __delitem__(self, key):
table = self.list.table()
values = table[key]
for value in values:
self.list.remove(value)
def clear(self):
self.list = FieldList()
def parse_header(line):
"""Parse a Content-type like header.
Return the main content-type and a dictionary of options.
"""
plist = map(lambda a: a.strip(), line.split(';'))
key = plist[0].lower()
del plist[0]
pdict = {}
for p in plist:
i = p.find('=')
if i >= 0:
name = p[:i].strip().lower()
value = p[i+1:].strip()
if len(value) >= 2 and value[0] == value[-1] == '"':
value = value[1:-1]
pdict[name] = value
return key, pdict
def apply_fs_data(object, fs, **args):
"""
Apply FieldStorage data to an object - the object must be
callable. Examine the args, and match then with fs data,
then call the object, return the result.
"""
# we need to weed out unexpected keyword arguments
# and for that we need to get a list of them. There
# are a few options for callable objects here:
fc = None
expected = []
if hasattr(object, "func_code"):
# function
fc = object.func_code
expected = fc.co_varnames[0:fc.co_argcount]
elif hasattr(object, 'im_func'):
# method
fc = object.im_func.func_code
expected = fc.co_varnames[1:fc.co_argcount]
elif type(object) in (TypeType,ClassType):
# class
fc = object.__init__.im_func.func_code
expected = fc.co_varnames[1:fc.co_argcount]
elif type(object) is BuiltinFunctionType:
# builtin
fc = None
expected = []
elif hasattr(object, '__call__'):
# callable object
if type(object.__call__) is MethodType:
fc = object.__call__.im_func.func_code
expected = fc.co_varnames[1:fc.co_argcount]
else:
# abuse of objects to create hierarchy
return apply_fs_data(object.__call__, fs, **args)
# add form data to args
for field in fs.list:
if field.filename:
val = field
else:
val = field.value
args.setdefault(field.name, []).append(val)
# replace lists with single values
for arg in args:
if ((type(args[arg]) is ListType) and
(len(args[arg]) == 1)):
args[arg] = args[arg][0]
# remove unexpected args unless co_flags & 0x08,
# meaning function accepts **kw syntax
if fc is None:
args = {}
elif not (fc.co_flags & 0x08):
for name in args.keys():
if name not in expected:
del args[name]
return object(**args)
RE_CDISPOSITION_FILENAME = re.compile(r'filename=(?P<filename>[\w\.]*)')
def handle_file_post(req, allowed_mimetypes=None):
"""
Handle the POST of a file.
@return: the a tuple with the full path to the file saved on disk,
and it's mimetype as provided by the request.
@rtype: (string, string)
"""
from invenio.bibdocfile import decompose_file, md5
## We retrieve the length
clen = req.headers_in["Content-Length"]
if clen is None:
raise InvenioWebInterfaceWSGIContentLenghtError("Content-Length header is missing")
try:
clen = int(clen)
assert (clen > 1)
except (ValueError, AssertionError):
raise InvenioWebInterfaceWSGIContentLenghtError("Content-Length header should contain a positive integer")
## Let's take the content type
ctype = req.headers_in["Content-Type"]
if allowed_mimetypes and ctype not in allowed_mimetypes:
raise InvenioWebInterfaceWSGIContentTypeError("Content-Type not in allowed list of content types: %s" % allowed_mimetypes)
## Let's optionally accept a suggested filename
suffix = prefix = ''
g = RE_CDISPOSITION_FILENAME.search(req.headers_in.get("Content-Disposition", ""))
if g:
dummy, prefix, suffix = decompose_file(g.group("filename"))
## Let's optionally accept an MD5 hash (and use it later for comparison)
cmd5 = req.headers_in["Content-MD5"]
if cmd5:
the_md5 = md5()
## Ok. We can initialize the file
fd, path = tempfile.mkstemp(suffix=suffix, prefix=prefix, dir=CFG_TMPDIR)
the_file = os.fdopen(fd, 'w')
## Let's read the file
while True:
chunk = req.read(min(10240, clen))
if len(chunk) < min(10240, clen):
## We expected to read at least clen (which is different than 0)
## but chunk was shorter! Gosh! Error! Panic!
the_file.close()
os.close(fd)
os.remove(path)
raise InvenioWebInterfaceWSGIContentLenghtError("File shorter than what specified in Content-Length")
if cmd5:
## MD5 was in the header let's compute it
the_md5.update(chunk)
## And let's definitively write the content to disk :-)
the_file.write(chunk)
clen -= len(chunk)
if clen == 0:
## That's it. Everything was read.
break
if cmd5 and the_md5.hexdigest().lower() != cmd5.strip().lower():
## Let's check the MD5
the_file.close()
os.close(fd)
os.remove(path)
raise InvenioWebInterfaceWSGIContentMD5Error("MD5 checksum does not match")
## Let's clean everything up
the_file.close()
return (path, ctype)
| Dziolas/invenio | modules/webstyle/lib/webinterface_handler_wsgi_utils.py | Python | gpl-2.0 | 29,713 |
##
## File: user_stats.py
##
## Author: Schuyler Martin <[email protected]>
##
## Description: Python class that defines a datagram for storing statistics
## on users
##
from datagrams.datagram import Datagram
class UserStats(Datagram):
'''
Class for storing statistics on a user
'''
def __init__(self, uid="", init_map=None):
'''
UserStat constructor, uses optional named parameters
:param: uid UID of user that these stats belong to
:param: init_map Dictionary that maps class attributes to values
This map, if it is passed in, will replace all attributes that
are seen in the dictionary. This is how we load an object from
JSON in the DB
'''
super().__init__(uid, init_map)
# number of questions a student has asked or a tutor has answered
self.q_count = 0
# number of times logged into the system
self.login_count = 0
# override attributes in the map
if (init_map != None):
if ("q_count" in init_map):
self.q_count = init_map["q_count"]
if ("login_count" in init_map):
self.login_count = init_map["login_count"]
def __str__(self):
'''
Converts to a string equivalent
'''
title = "User Stats for " + self.uid + "\n"
return title + super().__str__()
def stat_count(self, var_name):
'''
Returns the stats measure of a specific variable
:param: var_name Variable to fetch
:return: Current variable count
'''
return self.__dict__[var_name]
def stat_increment(self, var_name, value=1):
'''
Increments the stats measure of a specific variable
:param: var_name Variable to increment
:param: value Optional parameter, how much to increment by
:return: Current variable count
'''
self.__dict__[var_name] += value
return self.stat_count(var_name)
| RIT-CS-Mentoring-Center-Queueing/mmcga_project | server/datagrams/user_stats.py | Python | mit | 2,044 |
from .core import *
from .viz import *
__version__ = "0.0.5"
| nmarincic/numbasom | numbasom/__init__.py | Python | mit | 61 |
#---------------------------------------------------------------------------
# Introdução a Programação de Computadores - IPC
# Universidade do Estado do Amazonas - UEA
# Prof. Jucimar Jr
#
# Adham Lucas da Silva Oliveira 1715310059
# Gabriel Barroso da Silva Lima 1715310011
# Guilherme Silva de Oliveira 1715310034
# Natália Cavalcante Xavier 1715310021
# Tiago Ferreira Aranha 1715310047
#
# Fazer um algoritmo em Python que:
# a) Leia o valor inteiro de n (n 1000) e os n valores de uma variável composta A de
# valores numéricos, ordenados de forma crescente;
# b) Determine e imprima, para cada número que se repete no conjunto, a quantidade de
# vezes em que ele aparece repetido;
# c) Elimine os elementos repetidos, formando um novo conjunto;
# d) Imprima o conjunto obtido no item c.
#---------------------------------------------------------------------------
n = int(input("digite a quantidade de números: "))
digitados = []
repete = 0
for i in range (0, n):
numero = int(input("digite o número: "))
digitados.append(numero)
i = 1
digitados.append(digitados[0]-1)
while i < n:
while digitados[i] == digitados[i-1]:
repete += 1
digitados.remove(i)
n -= 1
else:
if repete > 0:
print ("número", digitados[i-1], "repete", repete, "vez(es)")
repete = 0
i += 1
digitados.remove(digitados[0]-1)
for i in range (0, n):
print (digitados[i]) | jucimarjr/IPC_2017-1 | lista06/lista06_lista02_questao23.py | Python | apache-2.0 | 1,566 |
Enter file contents here"""
object_name.py: Put the text of the current NVDA navigator object into a new window.
To install, place this file in the globalPlugins folder. You can get to this folder by typing the following into your run box (windows key + r):
%appdata%\nvda\globalPlugins
Once this is done, simply reload NVDA.
To use, focus the object you want to view the text for, then press NVDA+CTRL+N.
This file written by Chris Norman for use in Coventry Samaritans.
Feel free to distribute, use, learn from, edit or whatever. I only ask that if you do use or modify it, you send me an email just so I can feel good about myself! :-)
My email address, should you want to stroke my ego, complain or get help is
[email protected]
"""
from globalPluginHandler import GlobalPlugin
from api import getFocusObject
from ui import message
frame = None # The frame when it opens. Gets reset upon close.
class GlobalPlugin(GlobalPlugin):
"""The plugin required to make this whole thing work."""
def script_objectName(self, gesture):
"""Pops up the text of the current object in a new window."""
text = getattr(getFocusObject(), 'windowText', None)
if text != None:
text = text.strip('\n')
if not text:
message('No text.')
else:
global frame
if frame:
frame.setText(text)
else:
frame = ObjectNameFrame(text)
__gestures = {
'kb:NVDA+control+n': 'objectName'
}
import wx
class ObjectNameFrame(wx.Frame):
"""The frame to show."""
def __init__(self, text):
"""Text is the text to populate the frame with."""
super(ObjectNameFrame, self).__init__(None, title = 'Object Text')
p = wx.Panel(self)
s = wx.BoxSizer(wx.HORIZONTAL)
s1 = wx.BoxSizer(wx.VERTICAL)
s1.Add(wx.StaticText(p, label = '&Object Text'), 0, wx.GROW)
self.text = wx.TextCtrl(p, style = wx.TE_MULTILINE)
s1.Add(self.text, 1, wx.GROW)
s.Add(s1, 1, wx.GROW)
s2 = wx.BoxSizer(wx.VERTICAL)
self.closeButton = wx.Button(p, label = 'Close &Window')
s2.Add(self.closeButton, 1, wx.GROW)
self.closeButton.Bind(wx.EVT_BUTTON, lambda event: self.Close(True))
self.findText = '' # The text that the user searched for last time.
self.findButton = wx.Button(p, label = '&Find...')
s2.Add(self.findButton, 1, wx.GROW)
self.findButton.Bind(wx.EVT_BUTTON, self.find)
self.findAgainButton = wx.Button(p, label = 'Find A&gain')
s2.Add(self.findAgainButton, 1, wx.GROW)
self.findAgainButton.Bind(wx.EVT_BUTTON, lambda event: self.find(text = self.findText))
s.Add(s2, 0, wx.GROW)
p.SetSizerAndFit(s)
self.menu = wx.MenuBar()
self.editMenu = wx.Menu()
self.Bind(wx.EVT_MENU, self.find, self.editMenu.Append(wx.ID_FIND, '&Find...\tCTRL+F', 'Search for a string.'))
self.Bind(wx.EVT_MENU, lambda event: self.find(text = self.findText), self.editMenu.Append(wx.ID_ANY, 'Find A&gain\tF3', 'Search again.'))
self.menu.Append(self.editMenu, '&Edit')
self.SetMenuBar(self.menu)
self.Bind(wx.EVT_CLOSE, self.onClose)
self.setText(text)
def Show(self, value = True):
"""Show the window, maximizing in the process."""
res = super(ObjectNameFrame, self).Show(value)
self.Maximize(True)
return res
def find(self, event = None, text = None):
"""Find function."""
if text == None:
dlg = wx.TextEntryDialog(self, 'Enter a string to search for', 'Find', self.findText)
if dlg.ShowModal() == wx.ID_OK:
text = dlg.GetValue()
dlg.Destroy()
if text:
self.findText = text
text = text.lower()
i = self.text.GetInsertionPoint()
f = self.text.GetValue().lower().find(text, i)
if f >= 0:
f += self.text.GetValue().count('\n', 0, f)
self.text.SetSelection(f, f + len(text))
else:
wx.Bell()
return self.find()
def setText(self, text):
"""Set the text field to the provided text."""
self.text.SetValue(text)
self.Raise()
self.Show(True)
def onClose(self, event):
"""Close the window, clearing frame first."""
global frame
frame = None
event.Skip()
| chrisnorman7/object_name | object_name.py | Python | gpl-2.0 | 3,969 |
#encoding=utf-8
import ldap
SERVER_NAME = '192.168.0.9'
SERVER_PORT = 389
try:
conn = ldap.open("127.0.0.1")
conn.protocol_version = ldap.VERSION3 #设置ldap协议版本
username = "cn=Manager,o=example.com" #身份信息
password = "secret" #访问密码
conn.simple_bind_s(username,password) # 开始绑定，验证成功的话不会抛出异常
except ldap.LDAPError, e: #捕获出错信息
print e
| solvery/lang-features | python/network/ldap_1/ldap_client_1.py | Python | gpl-2.0 | 431 |
# -*- coding: utf-8 -*-
import unittest
import numpy as np
import sys
sys.path.append('..')
from rt1.scatter import Scatter
class TestScatter(unittest.TestCase):
def test_p(self):
S = Scatter()
theta_0 = np.pi/2.
theta_s = 0.234234
phi_0 = np.pi/2.
phi_s = 0.
p = S.scat_angle(theta_0, theta_s, phi_0, phi_s, a=[-1.,1.,1.]) # cos(theta)=0
self.assertAlmostEqual(p, 0.,10)
theta_0 = 0.
theta_s = 0.
phi_0 = np.pi/2.
phi_s = 0.12345
p = S.scat_angle(theta_0, theta_s, phi_0, phi_s, a=[-.7,1.,1.]) # cos(theta)=-1
self.assertAlmostEqual(p, -.7,10)
if __name__ == "__main__":
unittest.main()
| TUW-GEO/rt1 | tests/test_scatter.py | Python | apache-2.0 | 717 |
# coding=utf-8
# Distributed under the MIT software license, see the accompanying
# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
import argparse
import os
import simplejson as json
import grpc
from google.protobuf.json_format import MessageToJson
from qrl.core import config
from qrl.core.AddressState import AddressState
from qrl.crypto.xmss import XMSS
from qrl.core.txs.Transaction import Transaction
from qrl.core.txs.TransferTransaction import TransferTransaction
from pyqrllib.pyqrllib import hstr2bin, bin2hstr
from qrl.generated import qrl_pb2_grpc, qrl_pb2, qrlmining_pb2, qrlmining_pb2_grpc
from flask import Flask, Response, request
from jsonrpc.backend.flask import api
app = Flask(__name__)
def read_slaves(slaves_filename):
with open(slaves_filename, 'r') as f:
slave_data = json.load(f)
slave_data[0] = bytes(hstr2bin(slave_data[0]))
return slave_data
def get_addr_state(addr: bytes) -> AddressState:
stub = get_public_stub()
response = stub.GetAddressState(request=qrl_pb2.GetAddressStateReq(address=addr))
return AddressState(response.state)
def set_unused_ots_key(xmss, addr_state, start=0):
for i in range(start, 2 ** xmss.height):
if not addr_state.ots_key_reuse(i):
xmss.set_ots_index(i)
return True
return False
def valid_payment_permission(public_stub, master_address_state, payment_xmss, json_slave_txn):
access_type = master_address_state.get_slave_permission(payment_xmss.pk)
if access_type == -1:
tx = Transaction.from_json(json_slave_txn)
public_stub.PushTransaction(request=qrl_pb2.PushTransactionReq(transaction_signed=tx.pbdata))
return None
if access_type == 0:
return True
return False
def get_unused_payment_xmss(public_stub):
global payment_slaves
global payment_xmss
master_address = payment_slaves[0]
master_address_state = get_addr_state(master_address)
if payment_xmss:
addr_state = get_addr_state(payment_xmss.address)
if set_unused_ots_key(payment_xmss, addr_state, payment_xmss.ots_index):
if valid_payment_permission(public_stub, master_address_state, payment_xmss, payment_slaves[2]):
return payment_xmss
else:
payment_xmss = None
if not payment_xmss:
unused_ots_found = False
for slave_seed in payment_slaves[1]:
xmss = XMSS.from_extended_seed(slave_seed)
addr_state = get_addr_state(xmss.address)
if set_unused_ots_key(xmss, addr_state): # Unused ots_key_found
payment_xmss = xmss
unused_ots_found = True
break
if not unused_ots_found: # Unused ots_key_found
return None
if not valid_payment_permission(public_stub, master_address_state, payment_xmss, payment_slaves[2]):
return None
return payment_xmss
@app.route('/api/<api_method_name>')
def api_proxy(api_method_name):
"""
Proxy JSON RPC requests to the gRPC server as well as converts back gRPC response
to JSON.
:param api_method_name:
:return:
"""
stub = qrl_pb2_grpc.PublicAPIStub(grpc.insecure_channel('{}:{}'.format(config.user.public_api_host,
config.user.public_api_port)))
public_api = qrl_pb2.DESCRIPTOR.services_by_name['PublicAPI']
api_method = public_api.FindMethodByName(api_method_name)
api_request = getattr(qrl_pb2, api_method.input_type.name)()
for arg in request.args:
if arg not in api_method.input_type.fields_by_name:
raise Exception('Invalid args %s', arg)
data_type = type(getattr(api_request, arg))
if data_type == bool and request.args[arg].lower() == 'false':
continue
value = data_type(request.args.get(arg, type=data_type))
setattr(api_request, arg, value)
resp = getattr(stub, api_method_name)(api_request, timeout=10)
return Response(response=MessageToJson(resp, sort_keys=True), status=200, mimetype='application/json')
def get_mining_stub():
global mining_stub
return mining_stub
def get_public_stub():
global public_stub
return public_stub
@api.dispatcher.add_method
def getlastblockheader(height=0):
stub = get_mining_stub()
request = qrlmining_pb2.GetLastBlockHeaderReq(height=height)
grpc_response = stub.GetLastBlockHeader(request=request, timeout=10)
block_header = {
'difficulty': grpc_response.difficulty,
'height': grpc_response.height,
'timestamp': grpc_response.timestamp,
'reward': grpc_response.reward,
'hash': grpc_response.hash,
'depth': grpc_response.depth
}
resp = {
"block_header": block_header,
"status": "OK"
}
return resp
@api.dispatcher.add_method
def getblockheaderbyheight(height):
return getlastblockheader(height)
@api.dispatcher.add_method
def getblocktemplate(reserve_size, wallet_address):
stub = get_mining_stub()
request = qrlmining_pb2.GetBlockToMineReq(wallet_address=wallet_address.encode())
grpc_response = stub.GetBlockToMine(request=request, timeout=10)
resp = {
'blocktemplate_blob': grpc_response.blocktemplate_blob,
'difficulty': grpc_response.difficulty,
'height': grpc_response.height,
'reserved_offset': grpc_response.reserved_offset,
'seed_hash': grpc_response.seed_hash,
'status': 'OK'
}
return resp
@api.dispatcher.add_method
def submitblock(blob):
stub = get_mining_stub()
request = qrlmining_pb2.SubmitMinedBlockReq(blob=bytes(hstr2bin(blob)))
response = stub.SubmitMinedBlock(request=request, timeout=10)
if response.error:
raise Exception # Mining pool expected exception when block submission fails
return MessageToJson(response, sort_keys=True)
@api.dispatcher.add_method
def getblockminingcompatible(height):
stub = get_mining_stub()
request = qrlmining_pb2.GetBlockMiningCompatibleReq(height=height)
response = stub.GetBlockMiningCompatible(request=request, timeout=10)
return MessageToJson(response, sort_keys=True)
@api.dispatcher.add_method
def transfer(destinations, fee, mixin, unlock_time):
if len(destinations) > config.dev.transaction_multi_output_limit:
raise Exception('Payment Failed: Amount exceeds the allowed limit')
addrs_to = []
amounts = []
for tx in destinations:
addrs_to.append(bytes(hstr2bin(tx['address'][1:]))) # Skipping 'Q'
amounts.append(tx['amount'])
stub = get_public_stub()
xmss = get_unused_payment_xmss(stub)
if not xmss:
raise Exception('Payment Failed: No Unused Payment XMSS found')
tx = TransferTransaction.create(addrs_to=addrs_to,
amounts=amounts,
message_data=None,
fee=fee,
xmss_pk=xmss.pk,
master_addr=payment_slaves[0])
tx.sign(xmss)
response = stub.PushTransaction(request=qrl_pb2.PushTransactionReq(transaction_signed=tx.pbdata))
if response.error_code != 3:
raise Exception('Transaction Submission Failed, Response Code: %s', response.error_code)
response = {'tx_hash': bin2hstr(tx.txhash)}
return response
app.add_url_rule('/json_rpc', 'api', api.as_view(), methods=['POST'])
def parse_arguments():
parser = argparse.ArgumentParser(description='QRL node')
parser.add_argument('--qrldir', '-d', dest='qrl_dir', default=config.user.qrl_dir,
help="Use a different directory for node data/configuration")
parser.add_argument('--network-type', dest='network_type', choices=['mainnet', 'testnet'],
default='mainnet', required=False, help="Runs QRL Testnet Node")
return parser.parse_args()
def main():
args = parse_arguments()
qrl_dir_post_fix = ''
copy_files = []
if args.network_type == 'testnet':
qrl_dir_post_fix = '-testnet'
package_directory = os.path.dirname(os.path.abspath(__file__))
copy_files.append(os.path.join(package_directory, 'network/testnet/genesis.yml'))
copy_files.append(os.path.join(package_directory, 'network/testnet/config.yml'))
config.user.qrl_dir = os.path.expanduser(os.path.normpath(args.qrl_dir) + qrl_dir_post_fix)
config.create_path(config.user.qrl_dir, copy_files)
config.user.load_yaml(config.user.config_path)
global payment_slaves, payment_xmss
global mining_stub, public_stub
mining_stub = qrlmining_pb2_grpc.MiningAPIStub(grpc.insecure_channel('{0}:{1}'.format(config.user.mining_api_host,
config.user.mining_api_port)))
public_stub = qrl_pb2_grpc.PublicAPIStub(grpc.insecure_channel('{0}:{1}'.format(config.user.public_api_host,
config.user.public_api_port)))
payment_xmss = None
payment_slaves = read_slaves(config.user.mining_pool_payment_wallet_path)
app.run(host=config.user.grpc_proxy_host, port=config.user.grpc_proxy_port)
if __name__ == '__main__':
main()
| cyyber/QRL | src/qrl/grpcProxy.py | Python | mit | 9,400 |
VERSION = '1.5.2-dev'
| twosigma/waiter | cli/waiter/version.py | Python | apache-2.0 | 22 |
#!/usr/bin/python3
from qgmap import *
if __name__ == '__main__' :
def goCoords() :
def resetError() :
coordsEdit.setStyleSheet('')
try : latitude, longitude = coordsEdit.text().split(",")
except ValueError :
coordsEdit.setStyleSheet("color: red;")
QtCore.QTimer.singleShot(500, resetError)
else :
gmap.centerAt(latitude, longitude)
gmap.moveMarker("MyDragableMark", latitude, longitude)
def goAddress() :
def resetError() :
addressEdit.setStyleSheet('')
coords = gmap.centerAtAddress(addressEdit.text())
if coords is None :
addressEdit.setStyleSheet("color: red;")
QtCore.QTimer.singleShot(500, resetError)
return
gmap.moveMarker("MyDragableMark", *coords)
coordsEdit.setText("{}, {}".format(*coords))
def onMarkerMoved(key, latitude, longitude) :
print("Moved!!", key, latitude, longitude)
coordsEdit.setText("{}, {}".format(latitude, longitude))
def onMarkerRClick(key) :
print("RClick on ", key)
gmap.setMarkerOptions(key, draggable=False)
def onMarkerLClick(key) :
print("LClick on ", key)
def onMarkerDClick(key) :
print("DClick on ", key)
gmap.setMarkerOptions(key, draggable=True)
def onMapMoved(latitude, longitude) :
print("Moved to ", latitude, longitude)
def onMapRClick(latitude, longitude) :
print("RClick on ", latitude, longitude)
def onMapLClick(latitude, longitude) :
print("LClick on ", latitude, longitude)
def onMapDClick(latitude, longitude) :
print("DClick on ", latitude, longitude)
app = QtGui.QApplication([])
w = QtGui.QDialog()
h = QtGui.QVBoxLayout(w)
l = QtGui.QFormLayout()
h.addLayout(l)
addressEdit = QtGui.QLineEdit()
l.addRow('Address:', addressEdit)
addressEdit.editingFinished.connect(goAddress)
coordsEdit = QtGui.QLineEdit()
l.addRow('Coords:', coordsEdit)
coordsEdit.editingFinished.connect(goCoords)
gmap = QGoogleMap(w)
gmap.mapMoved.connect(onMapMoved)
gmap.markerMoved.connect(onMarkerMoved)
gmap.mapClicked.connect(onMapLClick)
gmap.mapDoubleClicked.connect(onMapDClick)
gmap.mapRightClicked.connect(onMapRClick)
gmap.markerClicked.connect(onMarkerLClick)
gmap.markerDoubleClicked.connect(onMarkerDClick)
gmap.markerRightClicked.connect(onMarkerRClick)
h.addWidget(gmap)
gmap.setSizePolicy(
QtGui.QSizePolicy.MinimumExpanding,
QtGui.QSizePolicy.MinimumExpanding)
w.show()
gmap.waitUntilReady()
gmap.centerAt(41.35,2.05)
gmap.setZoom(13)
coords = gmap.centerAtAddress("Pau Casals 3, Santa Coloma de Cervelló")
# Many icons at: https://sites.google.com/site/gmapsdevelopment/
gmap.addMarker("MyDragableMark", *coords, **dict(
icon="http://google.com/mapfiles/ms/micons/blue-dot.png",
draggable=True,
title = "Move me!"
))
# Some Static points
for place in [
"Pau Casals 13, Santa Coloma de Cervelló",
"Ferrer 20, Santa Coloma de Cervelló",
]:
gmap.addMarkerAtAddress(place,
icon="http://google.com/mapfiles/ms/micons/green-dot.png",
)
gmap.setZoom(17)
app.exec_()
| vokimon/python-qgmap | qgmap-example.py | Python | gpl-3.0 | 2,964 |
# coding=utf-8
"""
Copyright 2015 Load Impact
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
from datetime import datetime
from loadimpact.clients import Client
from loadimpact.exceptions import CoercionError
from loadimpact.fields import (
Field, DataStoreListField, DateTimeField, DictField, IntegerField,
StringField)
from loadimpact.resources import Resource
from loadimpact.utils import UTC
class MockClient(Client):
def _requests_request(self, method, *args, **kwargs):
pass
class MockResource(Resource):
fields = {}
def __init__(self, client, field_cls, field_value=None):
self.__class__.fields['field'] = field_cls
super(MockResource, self).__init__(client, field=field_value)
class TestFieldsField(unittest.TestCase):
def test_coerce(self):
self.assertRaises(NotImplementedError, Field.coerce, None)
class TestFieldsDataStoreListField(unittest.TestCase):
def setUp(self):
self.client = MockClient()
def test_coerce(self):
coerced = DataStoreListField.coerce([1, 2, 3, 4, 5])
self.assertEqual(coerced, [1, 2, 3, 4, 5])
def test_coerce_from_list_of_dicts(self):
coerced = DataStoreListField.coerce([{'id': 6}, {'id': 7}, {'id': 8}])
self.assertEqual(coerced, [6, 7, 8])
def test_get(self):
r = MockResource(self.client, DataStoreListField, [1, 2, 3, 4, 5])
self.assertEqual(r.field, [1, 2, 3, 4, 5])
class TestFieldsDateTimeField(unittest.TestCase):
def setUp(self):
self.now = datetime.utcnow().replace(tzinfo=UTC(), microsecond=0)
self.client = MockClient()
def test_coerce(self):
value = '%s+00:00' % self.now.strftime(DateTimeField.format)
coerced = DateTimeField.coerce(value)
self.assertEqual(coerced, self.now)
def test_coerce_bad_format(self):
self.assertRaises(CoercionError, DateTimeField.coerce, '2013-01-01')
def test_construct_bad_format(self):
self.assertRaises(CoercionError, MockResource, self.client,
DateTimeField, '2013-01-01')
def test_get(self):
value = '%s+00:00' % self.now.strftime(DateTimeField.format)
r = MockResource(self.client, DateTimeField, value)
self.assertEqual(r.field, self.now)
class TestFieldsIntegerField(unittest.TestCase):
def setUp(self):
self.client = MockClient()
def test_coerce(self):
coerced = IntegerField.coerce(1)
self.assertEqual(coerced, 1)
def test_coerce_from_string(self):
coerced = IntegerField.coerce('1')
self.assertEqual(coerced, 1)
def test_get(self):
r = MockResource(self.client, IntegerField, 1)
self.assertEqual(r.field, 1)
| loadimpact/loadimpact-sdk-python | test/test_fields.py | Python | apache-2.0 | 3,246 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Created on Feb 20, 2013
@author: maribelacosta
'''
class Revision(object):
'''
classdocs
'''
def __init__(self):
self.id = 0 # Fake sequential id. Starts in 0.
self.wikipedia_id = 0 # Wikipedia revision id.
self.contributor_id = 0; # Id of the contributor who performed the revision.
self.contributor_name = '' # Name of the contributor who performed the revision.
self.contributor_ip = '' # Name of the contributor who performed the revision.
self.paragraphs = {} # Dictionary of paragraphs. It is of the form {paragraph_hash : [Paragraph]}.
self.ordered_paragraphs = [] # Ordered paragraph hash.
self.length = 0 # Content length (bytes).
self.total_tokens = 0 # Number of tokens in the revision.
self.timestamp = 0
def __repr__(self):
return str(id(self))
def to_dict(self):
revision = {}
revision.update({'obj' : []})
for paragraph_hash in self.ordered_paragraphs:
p = []
for paragraph in self.paragraphs[paragraph_hash]:
p.append(repr(paragraph))
revision['obj'].append(p)
return revision
| priyankamandikal/wiki_accuracy_review | structures/Revision.py | Python | mit | 1,304 |
"""A filter that reduces CitcomS vtk input data.
"""
#Author: Martin Weier
#Copyright (C) 2006 California Institute of Technology
#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
#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 St, Fifth Floor, Boston, MA 02110-1301 USA
# Enthought library imports.
from enthought.traits import Instance, Range, Int, Float, Enum, Trait, Button
from enthought.traits.ui import View, Group, Item
from enthought.tvtk.api import tvtk
# Local imports
from enthought.mayavi.core.filter import Filter
from CitcomSSphere import *
######################################################################
# `Threshold` class.
######################################################################
class CitcomSreduce(Filter):
# The version of this class. Used for persistence.
__version__ = 0
# The threshold filter.
probe_filter = Instance(tvtk.ProbeFilter, ())
citcomsgrid = CitcomSSphere()
sphere = Instance(tvtk.SphereSource,())
# Upper threshold (this is a dynamic trait that is changed when
# input data changes).
Radius = Range(0.0, 1.0, 0.0, desc='adjust radius')
theta = Range(3, 40, 3, desc='the theta resolution')
phi = Range(3, 40, 3, desc='the upper threshold of the filter')
Selected_Source = Enum( 'Sphere','CitcomSGrid',)
radius_max = Float(1.0)
set_radius_max = Button('Set Radius Max')
# Our view.
view = View(Item(name="Selected_Source"),
Group(Item(name='Radius'),
Item(name='theta'),
Item(name='phi'),
Item(name='radius_max'),
Item(name='set_radius_max', style='simple', label='Simple'),
show_border = True
),
)
grid_source = True
######################################################################
# `Filter` interface.
######################################################################
def setup_pipeline(self):
"""Override this method so that it *creates* its tvtk
pipeline.
This method is invoked when the object is initialized via
`__init__`. Note that at the time this method is called, the
tvtk data pipeline will *not* yet be setup. So upstream data
will not be available. The idea is that you simply create the
basic objects and setup those parts of the pipeline not
dependent on upstream sources and filters.
"""
# Just setup the default output of this filter.
s = self.sphere
s.set(radius=0.0,theta_resolution=20,phi_resolution=20)
self.probe_filter.input = s.output
self.outputs = [self.probe_filter.output]
def update_pipeline(self):
"""Override this method so that it *updates* the tvtk pipeline
when data upstream is known to have changed.
This method is invoked (automatically) when the input fires a
`pipeline_changed` event.
"""
# By default we set the input to the first output of the first
# input.
fil = self.probe_filter
fil.source = self.inputs[0].outputs[0]
self._calc_grid(0,self.theta,self.phi)
fil.update()
self.outputs[0] = fil.output
self.pipeline_changed = True
def update_data(self):
"""Override this method to do what is necessary when upstream
data changes.
This method is invoked (automatically) when any of the inputs
sends a `data_changed` event.
"""
self.probe_filter.source = self.inputs[0].outputs[0]
self.probe_filter.update()
# Propagate the data_changed event.
self.data_changed = True
def _calc_grid(self,radius,resolution_x,resolution_y):
fil = self.probe_filter
coords = []
if self.Selected_Source == 'CitcomSGrid':
for i in xrange(12):
coords += self.citcomsgrid.coords_of_cap(radius,self.theta,self.phi,i)
grid = tvtk.UnstructuredGrid()
#Connectivity for 2d-Data
#There is no need to interpolate with the CitcomS grid surface. If this is however
#wanted uncomment this code to create the CitcomS surface information
#for capnr in xrange(12):
# i=1
# for n in xrange((resolution_x+1)*(resolution_y+1) - (resolution_x+1)):
# if i%(resolution_x+1)!=0 :
# n0 = n+(capnr*((resolution_x+1)*(resolution_y+1)))
# n1 = n0+1
# n2 = n0+resolution_y+1
# n3 = n2+1
# grid.insert_next_cell(8,[n0,n1,n2,n3])
# i+=1
##
grid.points = coords
fil.input = grid
if self.Selected_Source == 'Sphere':
sphere = tvtk.SphereSource()
sphere.radius = radius
sphere.theta_resolution = resolution_x
sphere.phi_resolution = resolution_y
#Rotate the Sphere so that the poles are at the right location
transL = tvtk.Transform()
trans1 = tvtk.TransformPolyDataFilter()
trans2 = tvtk.TransformPolyDataFilter()
trans1.input = sphere.output
transL.rotate_y(90)
transL.update()
trans1.transform = transL
trans1.update()
trans2.input = trans1.output
transL.rotate_z(90)
transL.update()
trans2.transform = transL
trans2.update()
fil.input = trans2.output
fil.update()
######################################################################
# Non-public interface
######################################################################
def _Radius_changed(self, new_value):
fil = self.probe_filter
#self.sphere.radius = new_value
self._calc_grid(new_value,self.theta,self.phi)
fil.update()
self.data_changed = True
def _theta_changed(self, new_value):
fil = self.probe_filter
self._calc_grid(self.Radius,new_value,self.phi)
fil.update()
self.data_changed = True
def _phi_changed(self, new_value):
fil = self.probe_filter
self._calc_grid(self.Radius,self.theta,new_value)
fil.update()
self.data_changed = True
def _Selected_Source_changed(self,new_value):
self._calc_grid(self.Radius, self.theta, self.phi)
self.outputs[0] = self.probe_filter.output
self.data_changed = True
self.pipeline_changed = True
def _radius_max_changed(self,new_value):
if self.Radius > new_value:
self.Radius = new_value
if new_value <= 0.0:
self.radius_max = 0.0
def _set_radius_max_fired(self):
trait = Range(0.0, self.radius_max, self.Radius,
desc='adjust radius')
self.add_trait('Radius', trait)
| geodynamics/citcoms | visual/Mayavi2/original_plugins/plugins/filter/CitcomSreduce.py | Python | gpl-2.0 | 7,907 |
# Copyright (c) 2014. Mount Sinai School of Medicine
#
# 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 print_function, division, absolute_import
from os.path import join
from .static_data import MATRIX_DIR
def read_coefficients(
key_type='row',
verbose=True,
filename=join(MATRIX_DIR, 'pmbec.mat')):
"""
Parameters
------------
filename : str
Location of PMBEC coefficient matrix
key_type : str
'row' : every key is a single amino acid,
which maps to a dictionary for that row
'pair' : every key is a tuple of amino acids
'pair_string' : every key is a string of two amino acid characters
verbose : bool
Print rows of matrix as we read them
"""
d = {}
if key_type == 'row':
def add_pair(row_letter, col_letter, value):
if row_letter not in d:
d[row_letter] = {}
d[row_letter][col_letter] = value
elif key_type == 'pair':
def add_pair(row_letter, col_letter, value):
d[(row_letter, col_letter)] = value
else:
assert key_type == 'pair_string', \
"Invalid dictionary key type: %s" % key_type
def add_pair(row_letter, col_letter, value):
d["%s%s" % (row_letter, col_letter)] = value
with open(filename, 'r') as f:
lines = [line for line in f.read().split('\n') if len(line) > 0]
header = lines[0]
if verbose:
print(header)
residues = [x for x in header.split(' ') if len(x) == 1 and x != ' ' and x != '\t']
assert len(residues) == 20
if verbose:
print(residues)
for line in lines[1:]:
cols = [
x
for x in line.split(' ')
if len(x) > 0 and x != ' ' and x != '\t'
]
assert len(cols) == 21, "Expected 20 values + letter, got %s" % cols
row_letter = cols[0]
for i, col in enumerate(cols[1:]):
col_letter = residues[i]
assert col_letter != ' ' and col_letter != '\t'
value = float(col)
add_pair(row_letter, col_letter, value)
return d
if __name__ == '__main__':
d = read_coefficients(key_type='pair_string')
print("PMBEC matrix")
for k in sorted(d):
print(k, d[k])
| dmnfarrell/epitopemap | modules/pepdata/pmbec.py | Python | apache-2.0 | 2,894 |
import bbcode
import markdown
import html
from c2corg_ui.format.wikilinks import C2CWikiLinkExtension
from c2corg_ui.format.img import C2CImageExtension
from c2corg_ui.format.video import C2CVideoExtension
from c2corg_ui.format.important import C2CImportantExtension
from c2corg_ui.format.warning import C2CWarningExtension
from markdown.extensions.nl2br import Nl2BrExtension
from markdown.extensions.toc import TocExtension
_markdown_parser = None
_bbcode_parser = None
_parsers_settings = None
def configure_parsers(settings):
global _parsers_settings
_parsers_settings = {
'api_url': settings.get('api_url')
}
def _get_markdown_parser():
global _markdown_parser
if not _markdown_parser:
extensions = [
C2CWikiLinkExtension(),
C2CImageExtension(api_url=_parsers_settings['api_url']),
C2CVideoExtension(),
C2CImportantExtension(),
C2CWarningExtension(),
Nl2BrExtension(),
TocExtension(marker='[toc]', baselevel=2),
]
_markdown_parser = markdown.Markdown(output_format='xhtml5',
extensions=extensions)
return _markdown_parser
def _get_bbcode_parser():
global _bbcode_parser
if not _bbcode_parser:
_bbcode_parser = bbcode.Parser(escape_html=False, newline='\n')
return _bbcode_parser
def parse_code(text, md=True, bb=True):
if bb:
text = _get_bbcode_parser().format(text)
if md:
text = _get_markdown_parser().convert(text)
return text
def sanitize(text):
return html.escape(text)
| Courgetteandratatouille/v6_ui | c2corg_ui/format/__init__.py | Python | agpl-3.0 | 1,630 |
class Solution(object):
def fizzBuzz(self, n):
"""
:type n: int
:rtype: List[str]
"""
num_str_arr = [""] * n
for i in range(1, n+1):
num_str = ""
if i % 3 != 0 and i % 5 != 0:
num_str = str(i)
else:
if i % 3 == 0:
num_str = "Fizz"
if i % 5 == 0:
num_str += "Buzz"
num_str_arr[i-1] = num_str
return num_str_arr
| zqfan/leetcode | algorithms/412. Fizz Buzz/solution.py | Python | gpl-3.0 | 506 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
if __name__ != '__main__':
__dicErros__ = {
00: "[Erro]: Arquivo contendo o código fonte não foi passado!",
01: "[Erro]: O arquivo passado possui extensão incompatível.",
02: "[Erro]: Erro lexico na linha "
}
__listaErros__ = []
def getErro(chave, linha, coluna):
"""A função retorna a string do erro correspondente contido no
dicionário de erros."""
if(linha is None and coluna is None):
return __dicErros__[chave]
return __dicErros__[chave] + str(linha) + " e coluna " + str(coluna)
def getListaErros():
"""A função retorna a lista de erros encontrados no código
fonte."""
return __listaErros__
def setListaErros(erro):
"""A função acrescenta ao final da lista de erros uma nova string
de um erro encontrado."""
return __listaErros__.append(erro)
| Lucasgscruz/AnalisadorLexico | src/erros.py | Python | gpl-3.0 | 952 |
#!/usr/bin/env python3
# coding: utf-8
import logging
import api
# :REFACTOR:
import datetime
def set_timer(seconds, func):
period = datetime.timedelta(seconds=seconds)
def on_timeout():
func()
io_loop.add_timeout(period, on_timeout)
io_loop.add_timeout(period, on_timeout)
if __name__ == "__main__":
from api import connect_to_dvr, StreamState
from tornado import gen
from tornado.ioloop import IOLoop
io_loop = IOLoop.instance()
host, port = "localhost", 8000
if False:
@gen.engine
def process(callback=None):
stream = yield gen.Task(connect, host, port)
if stream:
stream.close()
if callback:
callback(None)
io_loop.stop()
process()
io_loop.start()
if True:
test_timer = False
if test_timer:
def on_test_timer():
print("!")
set_timer(1, on_test_timer)
else:
def write_func(stream, is_first):
stream.write(b"Hello\n")
print("written!")
obj = api.make_struct()
def on_timeout():
connect_to_dvr(obj, (host, port), write_func)
set_timer(1, on_timeout)
io_loop.start()
| BradburyLab/show_tv | show_tv/test_connection.py | Python | gpl-3.0 | 1,417 |
#!/usr/bin/env python
#
# This file is protected by Copyright. Please refer to the COPYRIGHT file
# distributed with this source distribution.
#
# This file is part of REDHAWK server.
#
# REDHAWK server is free software: you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# REDHAWK server is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see http://www.gnu.org/licenses/.
#
from tornado.testing import main
import unittest
from tests import *
def all():
return unittest.TestLoader().loadTestsFromModule(__import__(__name__))
if __name__ == '__main__':
main()
| RedhawkSDR/rtl-demo-app | server/test.py | Python | lgpl-3.0 | 1,041 |
#!/usr/bin/env python
import matplotlib.pyplot as plt
import numpy as np
# Number of "papers using libmesh" by year.
#
# Note 1: this does not count citations "only," the authors must have actually
# used libmesh in part of their work. Therefore, these counts do not include
# things like Wolfgang citing us in his papers to show how Deal.II is
# superior...
#
# Note 2: I typically update this data after regenerating the web page,
# since bibtex2html renumbers the references starting from "1" each year.
#
# Note 3: These citations include anything that is not a dissertation/thesis.
# So, some are conference papers, some are journal articles, etc.
#
# Note 4: The libmesh paper came out in 2006, but there are some citations
# prior to that date, obviously. These counts include citations of the
# website libmesh.sf.net as well...
#
# Note 5: Preprints are listed as the "current year + 1" and are constantly
# being moved to their respective years after being published.
data = [
'\'04', 5,
'\'05', 2,
'\'06', 13,
'\'07', 8,
'\'08', 23,
'\'09', 29,
'\'10', 25,
'\'11', 32,
'\'12', 53,
'\'13', 78,
'\'14', 63,
'\'15', 79,
'\'16', 84,
'\'17', 31,
'T', 62
]
# Extract the x-axis labels from the data array
xlabels = data[0::2]
# Extract the publication counts from the data array
n_papers = data[1::2]
# The number of data points
N = len(xlabels);
# Get a reference to the figure
fig = plt.figure()
# 111 is equivalent to Matlab's subplot(1,1,1) command
ax = fig.add_subplot(111)
# Create an x-axis for plotting
x = np.linspace(1, N, N)
# Width of the bars
width = 0.8
# Make the bar chart. Plot years in blue, preprints and theses in green.
ax.bar(x[0:N-1], n_papers[0:N-1], width, color='b')
ax.bar(x[N-1:N], n_papers[N-1:N], width, color='g')
# Label the x-axis
plt.xlabel('T=PhD, MS, and BS Theses')
# Set up the xtick locations and labels. Note that you have to offset
# the position of the ticks by width/2, where width is the width of
# the bars.
ax.set_xticks(np.linspace(1,N,N) + width/2)
ax.set_xticklabels(xlabels)
# Create a title string
title_string = 'Papers by People Using LibMesh, (' + str(sum(n_papers)) + ' Total)'
fig.suptitle(title_string)
# Save as PDF
plt.savefig('libmesh_citations.pdf')
# Local Variables:
# python-indent: 2
# End:
| vikramvgarg/libmesh | doc/statistics/libmesh_citations.py | Python | lgpl-2.1 | 2,350 |
# core.py
#
# by Shaun Astbury
#
# Import required modules.
try:
from osgeo import ogr, osr
except:
import ogr
import osr
import os
ogr.UseExceptions()
# Driver names matched to driver instances.
drivers = {ogr.GetDriver(i).GetName(): ogr.GetDriver(i) for i in
range(ogr.GetDriverCount())}
# OGR Geometry methods for exporting geometries to other formats.
export_geometries = {'wkt': ogr.Geometry.ExportToWkt,
'wkb': ogr.Geometry.ExportToWkb,
'kml': ogr.Geometry.ExportToKML,
'json': ogr.Geometry.ExportToJson,
'gml': ogr.Geometry.ExportToGML}
# OSR SpatialReference methods for exporting to other formats.
export_sr = {'pwkt': osr.SpatialReference.ExportToPrettyWkt,
'wkt': osr.SpatialReference.ExportToWkt,
'proj4': osr.SpatialReference.ExportToProj4,
'pci': osr.SpatialReference.ExportToPCI,
'xml': osr.SpatialReference.ExportToXML,
'epsg': osr.SpatialReference.GetAttrValue}
# Matches extensions to drivers.
extensions = {}
for driver in drivers:
driver = drivers[driver]
data = driver.GetMetadata()
if "DMD_EXTENSIONS" in data:
exts = data["DMD_EXTENSIONS"]
exts = exts.split(" ")
for ext in exts:
extensions["." + ext] = driver
# Match single geometries to multi versions and vice versa.
geom_dict = {'POINT': 'MULTIPOINT',
'LINESTRING': 'MULTILINESTRING',
'POLYGON': 'MULTIPOLYGON',
'MULTIPOINT': 'POINT',
'MULTILINESTRING': 'LINESTRING',
'MULTIPOLYGON': 'POLYGON'}
# OGR geometry type codes to names.
geom_types = {ogr.wkbUnknown: 'UNKNOWN',
ogr.wkbPoint: 'POINT',
ogr.wkbLineString: 'LINESTRING',
ogr.wkbPolygon: 'POLYGON',
ogr.wkbMultiPoint: 'MULTIPOINT',
ogr.wkbMultiLineString: 'MULTILINESTRING',
ogr.wkbMultiPolygon: 'MULTIPOLYGON',
ogr.wkbGeometryCollection: 'GEOMETRYCOLLECTION',
ogr.wkbNone: 'NONE',
ogr.wkbLinearRing: 'LINEARRING'}
# OGR geometry creation functions.
import_geometries = {'wkt': ogr.CreateGeometryFromWkt,
'wkb': ogr.CreateGeometryFromWkb,
'json': ogr.CreateGeometryFromJson,
'gml': ogr.CreateGeometryFromGML,
'ogr': ogr.Geometry.Clone}
# OSR SpatialReference methods for importing from other formats.
import_sr = {'wkt': osr.SpatialReference.ImportFromWkt,
'proj4': osr.SpatialReference.ImportFromProj4,
'url': osr.SpatialReference.ImportFromUrl,
'esri': osr.SpatialReference.ImportFromESRI,
'epsg': osr.SpatialReference.ImportFromEPSG,
'epsga': osr.SpatialReference.ImportFromEPSGA,
'pci': osr.SpatialReference.ImportFromPCI,
'usgs': osr.SpatialReference.ImportFromUSGS,
'xml': osr.SpatialReference.ImportFromXML,
'erm': osr.SpatialReference.ImportFromERM}
# OGR Geometry spatial predicate methods.
spatial_queries = {'CONTAINS': ogr.Geometry.Contains,
'CROSSES': ogr.Geometry.Crosses,
'DISJOINT': ogr.Geometry.Disjoint,
'EQUALS': ogr.Geometry.Equals,
'INTERSECTS': ogr.Geometry.Intersects,
'OVERLAPS': ogr.Geometry.Overlaps,
'TOUCHES': ogr.Geometry.Touches,
'WITHIN': ogr.Geometry.Within}
def add_attribute(iterable, value=None):
"""
Add an attribute to Features in a generator.
Parameters:
- iterable:
The features to iterate over (list/tuple/generator).
- value (optional):
Default value for attribute.
Yields:
- feature:
The result of the tested record (Feature).
"""
for feature in iterable:
feature.attributes.append(value)
yield feature
def cascaded_union(geoms):
"""
Union multiple OGR Geometries into a single Geometry.
Parameters:
- geoms:
The OGR Geometries to iterate over (list/tuple/generator).
Returns:
- geom:
The resulting geometry (ogr.Geometry).
"""
geometry = ogr.Geometry(ogr.wkbMultiPolygon)
for geom in geoms:
geometry.AddGeometry(geom)
geom = geometry.UnionCascaded()
del geometry
return geom
def create_layer(datasource, field_definitions, geometry_type, fields=None,
features=None, spatial_ref=None, layer=None, driver=None):
"""
Create a data source and layer file, and populate with Features.
Parameters:
- datasource:
Path to the output data source, potentially including the layer
name (str).
- field_definitions:
Feature definitions object or Layer field_definitions dict
(ogr.FeatureDefn/dict).
- geometry_type:
OGR geometry type for the output (int).
- fields (optional):
Field names for the output (list/tuple).
- features (optional):
The features to iterate over (list/tuple/generator).
- spatial_ref (optional):
OSR SpatialReference to set for the output (osr.SpatialReference).
- layer (optional):
Name for the output layer, if not given in datasource (str).
- driver (optional):
OGR name for the driver to use for the output (str).
Returns:
- ds:
The opened data source (ogr.DataSource).
- out_layer:
The created layer (ogr.Layer).
"""
_, ds = open_ds(datasource, driver, True, "rw")
layers = ds.GetLayerCount()
if layer is None:
layer = get_layer(datasource)
if layer.upper() in (ds.GetLayerByIndex(i).GetName().upper()
for i in xrange(layers)):
ds.DeleteLayer(layer)
out_layer = ds.CreateLayer(layer, spatial_ref, geometry_type)
if isinstance(field_definitions, ogr.FeatureDefn):
defn = field_definitions
else:
for field in field_definitions:
field_type, precision, width = field_definitions[field]
field_def = ogr.FieldDefn(field, field_type)
if precision:
field_def.SetPrecision(precision)
if width:
field_def.SetWidth(width)
out_layer.CreateField(field_def)
defn = out_layer.GetLayerDefn()
if features:
for feature in features:
if spatial_ref:
feature = feature.transform(spatial_ref, in_place=False)
feat = create_ogr_feature(defn, feature.ogr_geom,
feature.attributes, fields)
out_layer.CreateFeature(feat)
return ds, out_layer
def create_ogr_feature(definition, ogr_geom, attributes=[], fields=None):
"""
Create an OGR Feature object from a OGR Geometry, OGR FeatureDefn, and a
set of attributes.
Parameters:
- field_definitions:
Feature definitions object or Layer field_definitions dict
(ogr.FeatureDefn/dict).
- ogr_geom:
OGR geometry for the output (ogr.Geometry).
- attributes (optional):
The attributes to include in the output feature (list/tuple).
- fields (optional):
Field names for the output (list/tuple).
Returns:
- feature:
The created Feature object (ogr.Feature).
"""
feature = ogr.Feature(definition)
if fields is None:
fields = [definition.GetFieldDefn(i).GetName() for
i in xrange(definition.GetFieldCount())]
feature.SetGeometry(ogr_geom)
for field, attribute in zip(fields, attributes):
feature.SetField(field, attribute)
return feature
def extent_to_polygon(minx, miny, maxx, maxy):
"""
Create an OGR Geometry from a bounding box extent.
Parameters:
- minx:
Minimum x value for extent (int/float).
- miny:
Minimum y value for extent (int/float).
- maxx:
Maximum x value for extent (int/float).
- maxy:
Maxmum y value for extent (int/float).
Returns:
- ogr_geom:
The resultant OGR Geometry (ogr.Geometry)
"""
extent = "POLYGON (("
extent += "{0} {1}, {2} {1}, {2} {3}, {0} {3}, {0} {1}".format(
minx, miny, maxx, maxy)
extent += "))"
return import_geometries['wkt'](extent)
def get_layer(datasource):
"""
Gets the layer name of single-layer data sources. If not possible (e.g.
database connection strings), raises an exception.
Parameters:
- datasource:
File path for the datasource, or an OGR DataSource instance
(ogr.DataSource/str).
Returns:
- layer_name:
The name of the layer, determined as the basename of the input
data source, excluding any file extension (str).
"""
try:
if isinstance(datasource, ogr.DataSource):
datasource = datasource.GetName()
layer_name = os.path.basename(os.path.splitext(datasource)[0])
return layer_name
except:
print "\nNo layer parameter supplied when required by data source."
raise Exception()
def map_geom(func, iterable, *args, **kwargs):
"""
Apply spatial operations to Features in an iterable.
Parameters:
- func:
The function to use (func).
- iterable:
The features to iterate over (list/tuple/generator).
Yields:
- feature:
The result of the spatial operation (Feature).
"""
for i in iterable:
feature = func(i, *args, **kwargs)
if feature is not None:
yield feature
def open_ds(datasource, driver=None, create=False, mode="r"):
"""
Opens OGR DataSources.
Parameters:
- datasource:
File system path to an OGR-readable data source, or a database
connection string (str).
- driver (optional):
Name of the driver to use, in OGR format (str). If not
supplied, this will be determined from the file extension, or
by attempting all drivers (str).
- create (optional):
If True, create a new data source, otherwise if not found, raise an
exception (default) (bool).
- mode (optional):
Set "r" for read only, or "rw" for read/write. OGR 0/1 is also
accepted. Read only is default (int/str).
Returns:
- driver:
The driver used to open the DataSource (ogr.Driver).
- ds:
The opened OGR DataSource (ogr.DataSource).
"""
modes = {"r": 0, "rw": 1}
if mode in modes:
mode = modes[mode]
elif mode not in modes.values:
print "\nSupplied mode parameter value not valid."
raise Exception()
ext = os.path.splitext(datasource)[1]
if driver is None:
if ext in extensions:
driver = extensions[ext]
elif create:
print "\nNo driver parameter supplied to create data source."
raise Exception()
elif not isinstance(driver, ogr.Driver):
try:
driver = ogr.GetDriverByName(driver)
except:
print ("\nSupplied driver parameter value not valid, or driver " +
"not available.")
raise Exception()
if os.path.exists(datasource):
try:
if driver is None:
ds = ogr.Open(datasource, mode)
driver = ds.GetDriver()
else:
ds = driver.Open(datasource, mode)
except:
print ("\nFailed to open data source, file " +
"format not supported.")
raise Exception()
else:
if create:
try:
if not os.path.exists(os.path.dirname(datasource)):
os.makedirs(os.path.dirname(datasource))
ds = driver.CreateDataSource(datasource)
except:
print "\nCould not create Data Source {0}.".format(datasource)
raise Exception()
else:
print "\nData Source {0} does not exist.".format(datasource)
raise Exception()
return driver, ds
def spatial_query(query, iterable, feature):
"""
Filter Features in an iterable by spatial predicate.
Parameters:
- query:
The spatial predicate function to use (func).
- iterable:
The features to iterate over (list/tuple/generator).
- feature:
The operation feature to apply (Feature)
Yields:
- feature:
The result of the spatial operation (Feature).
"""
for i in iterable:
result = query(i, feature)
if result:
yield i
def update_attributes(iterable, field, value, fields, clause=None):
"""
Alter the value of an Feature attribute in an iterable.
Parameters:
- iterable:
The features to iterate over (list/tuple/generator).
- field:
The field to adjust (str).
- fields:
The fields present in the clause (list/tuple).
- clause:
The input query string (str).
Yields:
- feature:
The result of the spatial operation (Feature).
"""
idx = fields.index(field)
if clause:
query = Query(fields, clause)
for feature in iterable:
if query.test(feature.attributes):
feature.attributes[idx] = value
yield feature
else:
for feature in iterable:
feature.attributes[idx] = value
yield feature
def update_feature(func, iterable, *args):
"""
Apply spatial operations to Features in an iterable.
Parameters:
- func:
The function to use (func).
- iterable:
The features to iterate over (list/tuple/generator).
Yields:
- feature:
The result of the spatial operation (Feature).
"""
for feature in iterable:
func(feature, *args)
yield feature
class Query(object):
"""
Basic query evaluator. Will test any input to the query - no validation or
parsing, just replaces fields with test values and calls eval.
Methods:
- test:
Tests the attributes of a records against the acceptable input
clause.
Attributes:
- clause:
The input query string (str).
- fields:
The fields present in the clause (list/tuple).
"""
def __init__(self, fields, clause):
"""
Basic query evaluator. Will test any input to the query - no validation
or parsing, just replaces fields with test values and calls eval.
Parameters:
- fields:
Names of all fields present in the tested records, which should
match the clause (list/tuple).
- clause:
Query string to apply to the inputs. Input must be valid
Python, using unquoted field names and field values as they
would be defined in Python, e.g. field_1 >= 1 or field_2 == "A"
(str).
"""
self.fields = fields
self.clause = clause
def test(self, record):
"""
Test a record against the clause, extracting its values based on field
indicies.
Parameters:
- record:
The values to test. Attributes must be set in the order of the
instance fields attribute (list/tuple).
Returns:
- result:
The result of the tested record (bool).
"""
test = self.clause[:]
for field in self.fields:
test_value = record[self.fields.index(field)]
if type(test_value) in (str, unicode):
test = test.replace(field + ' ', + test_value + '" ')
else:
test = test.replace(field + ' ', str(test_value) + ' ')
test = test.replace(" = ", " == ")
return eval(test)
| ssast/easyogr | core.py | Python | gpl-3.0 | 17,159 |
# Ensure that tests are importing the local copy of trex rather than
# any system-installed copy of trex that might exist in the path.
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir))
import trex
sys.path.pop(0)
| anthonyalmarza/trex | tests/__init__.py | Python | mit | 259 |
"""
After running the recipe in this directory, we get a large JSON file called all_covid19_datasets.json.
This script reads that JSON file, adds to it using the directives pull from a Google sheet, and
produces a new JSON file called demo_data.json.
"""
import csv
import dataclasses
import json
import os
import pathlib
import time
from typing import Dict, List
from datahub.metadata.schema_classes import (
AuditStampClass,
CorpUserInfoClass,
CorpUserSnapshotClass,
DatasetLineageTypeClass,
DatasetSnapshotClass,
EditableSchemaMetadataClass,
GlobalTagsClass,
MetadataChangeEventClass,
OwnerClass,
OwnershipClass,
OwnershipTypeClass,
UpstreamClass,
UpstreamLineageClass,
)
DEMO_DATA_DIR = pathlib.Path("./examples/demo_data")
INPUT_ALL_DATASETS = DEMO_DATA_DIR / "all_covid19_datasets.json"
OUTPUT_ENRICHED = DEMO_DATA_DIR / "demo_data.json"
DIRECTIVES_CSV = DEMO_DATA_DIR / "directives.csv"
@dataclasses.dataclass
class Directive:
table: str
drop: bool
owners: List[str]
depends_on: List[str]
def read_mces(path: os.PathLike) -> List[MetadataChangeEventClass]:
with open(path) as f:
objs = json.load(f)
mces = [MetadataChangeEventClass.from_obj(obj) for obj in objs]
return mces
def write_mces(path: os.PathLike, mces: List[MetadataChangeEventClass]) -> None:
objs = [mce.to_obj() for mce in mces]
with open(path, "w") as f:
json.dump(objs, f, indent=4)
def parse_directive(row: Dict) -> Directive:
return Directive(
table=row["table"],
drop=bool(row["drop"]),
owners=[x.strip() for x in row["owners"].split(",") if x],
depends_on=[x.strip() for x in row["depends_on"].split(",") if x],
)
def fetch_directives() -> List[Directive]:
with open(DIRECTIVES_CSV, "r") as f:
reader = csv.DictReader(f)
rows = [parse_directive(row) for row in reader]
return rows
def dataset_name_to_urn(name: str) -> str:
return f"urn:li:dataset:(urn:li:dataPlatform:bigquery,{name},PROD)"
def clean_owner_name(name: str) -> str:
clean = "".join(c for c in name if c.isalpha())
return clean
def owner_name_to_urn(name: str) -> str:
return f"urn:li:corpuser:{name}"
def create_owner_entity_mce(owner: str) -> MetadataChangeEventClass:
clean_name = clean_owner_name(owner)
return MetadataChangeEventClass(
proposedSnapshot=CorpUserSnapshotClass(
urn=owner_name_to_urn(clean_name),
aspects=[
CorpUserInfoClass(
active=True,
displayName=owner,
fullName=owner,
email=f"{clean_name}[email protected]",
)
],
)
)
def create_ownership_aspect_mce(directive: Directive) -> MetadataChangeEventClass:
return MetadataChangeEventClass(
proposedSnapshot=DatasetSnapshotClass(
urn=dataset_name_to_urn(directive.table),
aspects=[
OwnershipClass(
owners=[
OwnerClass(
owner=owner_name_to_urn(clean_owner_name(owner)),
type=OwnershipTypeClass.DATAOWNER,
)
for owner in directive.owners
],
lastModified=AuditStampClass(
time=int(time.time() * 1000),
actor="urn:li:corpuser:datahub",
),
)
],
)
)
def create_lineage_aspect_mce(directive: Directive) -> MetadataChangeEventClass:
return MetadataChangeEventClass(
proposedSnapshot=DatasetSnapshotClass(
urn=dataset_name_to_urn(directive.table),
aspects=[
UpstreamLineageClass(
upstreams=[
UpstreamClass(
dataset=dataset_name_to_urn(upstream),
type=DatasetLineageTypeClass.TRANSFORMED,
auditStamp=AuditStampClass(
time=int(time.time() * 1000),
actor="urn:li:corpuser:datahub",
),
)
for upstream in directive.depends_on
]
)
],
)
)
def create_global_tags_aspect_mce(directive: Directive) -> MetadataChangeEventClass:
return MetadataChangeEventClass(
proposedSnapshot=DatasetSnapshotClass(
urn=dataset_name_to_urn(directive.table),
aspects=[GlobalTagsClass(tags=[])],
)
)
def create_editable_schema_info_aspect_mce(
directive: Directive,
) -> MetadataChangeEventClass:
return MetadataChangeEventClass(
proposedSnapshot=DatasetSnapshotClass(
urn=dataset_name_to_urn(directive.table),
aspects=[
EditableSchemaMetadataClass(
created=AuditStampClass(
time=int(time.time() * 1000),
actor="urn:li:corpuser:datahub",
),
lastModified=AuditStampClass(
time=int(time.time() * 1000),
actor="urn:li:corpuser:datahub",
),
editableSchemaFieldInfo=[],
)
],
)
)
if __name__ == "__main__":
datasets = read_mces(INPUT_ALL_DATASETS)
all_directives = fetch_directives()
directives = [directive for directive in all_directives if not directive.drop]
all_dataset_urns = {
dataset_name_to_urn(directive.table) for directive in all_directives
}
allowed_urns = {
dataset_name_to_urn(directive.table)
for directive in all_directives
if not directive.drop
}
missing_dataset_directives = [
dataset.proposedSnapshot.urn
for dataset in datasets
if dataset.proposedSnapshot.urn not in all_dataset_urns
]
assert not missing_dataset_directives
filtered_dataset_mces = [
dataset for dataset in datasets if dataset.proposedSnapshot.urn in allowed_urns
]
owner_names = {owner for directive in directives for owner in directive.owners}
owner_entity_mces = [
create_owner_entity_mce(owner) for owner in sorted(owner_names)
]
ownership_aspect_mces = [
create_ownership_aspect_mce(directive)
for directive in directives
if directive.owners
]
lineage_aspect_mces = [
create_lineage_aspect_mce(directive)
for directive in directives
if directive.depends_on
]
global_tags_aspect_mces = [
create_global_tags_aspect_mce(directive)
for directive in directives
if not directive.drop
]
editable_schema_info_aspect_mces = [
create_editable_schema_info_aspect_mce(directive)
for directive in directives
if not directive.drop
]
enriched_mces = (
filtered_dataset_mces
+ owner_entity_mces
+ ownership_aspect_mces
+ lineage_aspect_mces
+ global_tags_aspect_mces
+ editable_schema_info_aspect_mces
)
write_mces(OUTPUT_ENRICHED, enriched_mces)
| linkedin/WhereHows | metadata-ingestion/examples/demo_data/enrich.py | Python | apache-2.0 | 7,385 |
# Copyright 2002-2005 Vladimir Prus.
# Copyright 2002-2003 Dave Abrahams.
# Copyright 2006 Rene Rivera.
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
import TestCmd
import copy
import fnmatch
import glob
import math
import os
import os.path
import re
import shutil
import StringIO
import subprocess
import sys
import tempfile
import time
import traceback
import tree
import types
from xml.sax.saxutils import escape
class TestEnvironmentError(Exception):
pass
annotations = []
def print_annotation(name, value, xml):
"""Writes some named bits of information about the current test run."""
if xml:
print escape(name) + " {{{"
print escape(value)
print "}}}"
else:
print name + " {{{"
print value
print "}}}"
def flush_annotations(xml=0):
global annotations
for ann in annotations:
print_annotation(ann[0], ann[1], xml)
annotations = []
def clear_annotations():
global annotations
annotations = []
defer_annotations = 0
def set_defer_annotations(n):
global defer_annotations
defer_annotations = n
def annotate_stack_trace(tb=None):
if tb:
trace = TestCmd.caller(traceback.extract_tb(tb), 0)
else:
trace = TestCmd.caller(traceback.extract_stack(), 1)
annotation("stacktrace", trace)
def annotation(name, value):
"""Records an annotation about the test run."""
annotations.append((name, value))
if not defer_annotations:
flush_annotations()
def get_toolset():
toolset = None
for arg in sys.argv[1:]:
if not arg.startswith("-"):
toolset = arg
return toolset or "gcc"
# Detect the host OS.
cygwin = hasattr(os, "uname") and os.uname()[0].lower().startswith("cygwin")
windows = cygwin or os.environ.get("OS", "").lower().startswith("windows")
if cygwin:
default_os = "cygwin"
elif windows:
default_os = "windows"
elif hasattr(os, "uname"):
default_os = os.uname()[0].lower()
def prepare_prefixes_and_suffixes(toolset, target_os=default_os):
prepare_suffix_map(toolset, target_os)
prepare_library_prefix(toolset, target_os)
def prepare_suffix_map(toolset, target_os=default_os):
"""
Set up suffix translation performed by the Boost Build testing framework
to accommodate different toolsets generating targets of the same type using
different filename extensions (suffixes).
"""
global suffixes
suffixes = {}
if target_os in ["windows", "cygwin"]:
if toolset == "gcc":
suffixes[".lib"] = ".a" # mingw static libs use suffix ".a".
suffixes[".obj"] = ".o"
if target_os == "cygwin":
suffixes[".implib"] = ".lib.a"
else:
suffixes[".implib"] = ".lib"
else:
suffixes[".exe"] = ""
suffixes[".dll"] = ".so"
suffixes[".lib"] = ".a"
suffixes[".obj"] = ".o"
suffixes[".implib"] = ".no_implib_files_on_this_platform"
if target_os == "darwin":
suffixes[".dll"] = ".dylib"
def prepare_library_prefix(toolset, target_os=default_os):
"""
Setup whether Boost Build is expected to automatically prepend prefixes
to its built library targets.
"""
global lib_prefix
lib_prefix = "lib"
global dll_prefix
if target_os == "cygwin":
dll_prefix = "cyg"
elif target_os == "windows" and toolset != "gcc":
dll_prefix = None
else:
dll_prefix = "lib"
def re_remove(sequence, regex):
me = re.compile(regex)
result = filter(lambda x: me.match(x), sequence)
if not result:
raise ValueError()
for r in result:
sequence.remove(r)
def glob_remove(sequence, pattern):
result = fnmatch.filter(sequence, pattern)
if not result:
raise ValueError()
for r in result:
sequence.remove(r)
class Tester(TestCmd.TestCmd):
"""Main tester class for Boost Build.
Optional arguments:
`arguments` - Arguments passed to the run executable.
`executable` - Name of the executable to invoke.
`match` - Function to use for compating actual and
expected file contents.
`boost_build_path` - Boost build path to be passed to the run
executable.
`translate_suffixes` - Whether to update suffixes on the the file
names passed from the test script so they
match those actually created by the current
toolset. For example, static library files
are specified by using the .lib suffix but
when the "gcc" toolset is used it actually
creates them using the .a suffix.
`pass_toolset` - Whether the test system should pass the
specified toolset to the run executable.
`use_test_config` - Whether the test system should tell the run
executable to read in the test_config.jam
configuration file.
`ignore_toolset_requirements` - Whether the test system should tell the run
executable to ignore toolset requirements.
`workdir` - Absolute directory where the test will be
run from.
`pass_d0` - If set, when tests are not explicitly run
in verbose mode, they are run as silent
(-d0 & --quiet Boost Jam options).
Optional arguments inherited from the base class:
`description` - Test description string displayed in case
of a failed test.
`subdir` - List of subdirectories to automatically
create under the working directory. Each
subdirectory needs to be specified
separately, parent coming before its child.
`verbose` - Flag that may be used to enable more
verbose test system output. Note that it
does not also enable more verbose build
system output like the --verbose command
line option does.
"""
def __init__(self, arguments=None, executable="bjam",
match=TestCmd.match_exact, boost_build_path=None,
translate_suffixes=True, pass_toolset=True, use_test_config=True,
ignore_toolset_requirements=False, workdir="", pass_d0=False,
**keywords):
assert arguments.__class__ is not str
self.original_workdir = os.path.dirname(__file__)
if workdir and not os.path.isabs(workdir):
raise ("Parameter workdir <%s> must point to an absolute "
"directory: " % workdir)
self.last_build_timestamp = 0
self.translate_suffixes = translate_suffixes
self.use_test_config = use_test_config
self.toolset = get_toolset()
self.pass_toolset = pass_toolset
self.ignore_toolset_requirements = ignore_toolset_requirements
prepare_prefixes_and_suffixes(pass_toolset and self.toolset or "gcc")
use_default_bjam = "--default-bjam" in sys.argv
if not use_default_bjam:
jam_build_dir = ""
if os.name == "nt":
jam_build_dir = "bin.ntx86"
elif (os.name == "posix") and os.__dict__.has_key("uname"):
if os.uname()[0].lower().startswith("cygwin"):
jam_build_dir = "bin.cygwinx86"
if ("TMP" in os.environ and
os.environ["TMP"].find("~") != -1):
print("Setting $TMP to /tmp to get around problem "
"with short path names")
os.environ["TMP"] = "/tmp"
elif os.uname()[0] == "Linux":
cpu = os.uname()[4]
if re.match("i.86", cpu):
jam_build_dir = "bin.linuxx86"
else:
jam_build_dir = "bin.linux" + os.uname()[4]
elif os.uname()[0] == "SunOS":
jam_build_dir = "bin.solaris"
elif os.uname()[0] == "Darwin":
if os.uname()[4] == "i386":
jam_build_dir = "bin.macosxx86"
elif os.uname()[4] == "x86_64":
jam_build_dir = "bin.macosxx86_64"
else:
jam_build_dir = "bin.macosxppc"
elif os.uname()[0] == "AIX":
jam_build_dir = "bin.aix"
elif os.uname()[0] == "IRIX64":
jam_build_dir = "bin.irix"
elif os.uname()[0] == "FreeBSD":
jam_build_dir = "bin.freebsd"
elif os.uname()[0] == "OSF1":
jam_build_dir = "bin.osf"
else:
raise ("Do not know directory where Jam is built for this "
"system: %s/%s" % (os.name, os.uname()[0]))
else:
raise ("Do not know directory where Jam is built for this "
"system: %s" % os.name)
# Find where jam_src is located. Try for the debug version if it is
# lying around.
srcdir = os.path.join(os.path.dirname(__file__), "..", "src")
dirs = [os.path.join(srcdir, "engine", jam_build_dir + ".debug"),
os.path.join(srcdir, "engine", jam_build_dir)]
for d in dirs:
if os.path.exists(d):
jam_build_dir = d
break
else:
print("Cannot find built Boost.Jam")
sys.exit(1)
verbosity = ["-d0", "--quiet"]
if not pass_d0:
verbosity = []
if "--verbose" in sys.argv:
keywords["verbose"] = True
verbosity = ["-d2"]
self.verbosity = verbosity
if boost_build_path is None:
boost_build_path = self.original_workdir + "/.."
program_list = []
if use_default_bjam:
program_list.append(executable)
else:
program_list.append(os.path.join(jam_build_dir, executable))
program_list.append('-sBOOST_BUILD_PATH="' + boost_build_path + '"')
if arguments:
program_list += arguments
TestCmd.TestCmd.__init__(self, program=program_list, match=match,
workdir=workdir, inpath=use_default_bjam, **keywords)
os.chdir(self.workdir)
def cleanup(self):
try:
TestCmd.TestCmd.cleanup(self)
os.chdir(self.original_workdir)
except AttributeError:
# When this is called during TestCmd.TestCmd.__del__ we can have
# both 'TestCmd' and 'os' unavailable in our scope. Do nothing in
# this case.
pass
def set_toolset(self, toolset, target_os=default_os):
self.toolset = toolset
self.pass_toolset = True
prepare_prefixes_and_suffixes(toolset, target_os)
#
# Methods that change the working directory's content.
#
def set_tree(self, tree_location):
# It is not possible to remove the current directory.
d = os.getcwd()
os.chdir(os.path.dirname(self.workdir))
shutil.rmtree(self.workdir, ignore_errors=False)
if not os.path.isabs(tree_location):
tree_location = os.path.join(self.original_workdir, tree_location)
shutil.copytree(tree_location, self.workdir)
os.chdir(d)
def make_writable(unused, dir, entries):
for e in entries:
name = os.path.join(dir, e)
os.chmod(name, os.stat(name).st_mode | 0222)
os.path.walk(".", make_writable, None)
def write(self, file, content, wait=True):
nfile = self.native_file_name(file)
self.__makedirs(os.path.dirname(nfile), wait)
f = open(nfile, "wb")
try:
f.write(content)
finally:
f.close()
self.__ensure_newer_than_last_build(nfile)
def copy(self, src, dst):
try:
self.write(dst, self.read(src, binary=True))
except:
self.fail_test(1)
def copy_preserving_timestamp(self, src, dst):
src_name = self.native_file_name(src)
dst_name = self.native_file_name(dst)
stats = os.stat(src_name)
self.write(dst, self.__read(src, binary=True))
os.utime(dst_name, (stats.st_atime, stats.st_mtime))
def touch(self, names, wait=True):
if names.__class__ is str:
names = [names]
for name in names:
path = self.native_file_name(name)
if wait:
self.__ensure_newer_than_last_build(path)
else:
os.utime(path, None)
def rm(self, names):
if not type(names) == types.ListType:
names = [names]
if names == ["."]:
# If we are deleting the entire workspace, there is no need to wait
# for a clock tick.
self.last_build_timestamp = 0
# Avoid attempts to remove the current directory.
os.chdir(self.original_workdir)
for name in names:
n = glob.glob(self.native_file_name(name))
if n: n = n[0]
if not n:
n = self.glob_file(name.replace("$toolset", self.toolset + "*")
)
if n:
if os.path.isdir(n):
shutil.rmtree(n, ignore_errors=False)
else:
os.unlink(n)
# Create working dir root again in case we removed it.
if not os.path.exists(self.workdir):
os.mkdir(self.workdir)
os.chdir(self.workdir)
def expand_toolset(self, name):
"""
Expands $toolset placeholder in the given file to the name of the
toolset currently being tested.
"""
self.write(name, self.read(name).replace("$toolset", self.toolset))
def dump_stdio(self):
annotation("STDOUT", self.stdout())
annotation("STDERR", self.stderr())
def run_build_system(self, extra_args=None, subdir="", stdout=None,
stderr="", status=0, match=None, pass_toolset=None,
use_test_config=None, ignore_toolset_requirements=None,
expected_duration=None, **kw):
assert extra_args.__class__ is not str
if os.path.isabs(subdir):
print("You must pass a relative directory to subdir <%s>." % subdir
)
return
self.previous_tree, dummy = tree.build_tree(self.workdir)
self.wait_for_time_change_since_last_build()
if match is None:
match = self.match
if pass_toolset is None:
pass_toolset = self.pass_toolset
if use_test_config is None:
use_test_config = self.use_test_config
if ignore_toolset_requirements is None:
ignore_toolset_requirements = self.ignore_toolset_requirements
try:
kw["program"] = []
kw["program"] += self.program
if extra_args:
kw["program"] += extra_args
if stdout is None and not any(a.startswith("-d") for a in kw["program"]):
kw["program"] += self.verbosity
if pass_toolset:
kw["program"].append("toolset=" + self.toolset)
if use_test_config:
kw["program"].append('--test-config="%s"' % os.path.join(
self.original_workdir, "test-config.jam"))
if ignore_toolset_requirements:
kw["program"].append("--ignore-toolset-requirements")
if "--python" in sys.argv:
# -z disables Python optimization mode.
# this enables type checking (all assert
# and if __debug__ statements).
kw["program"].extend(["--python", "-z"])
if "--stacktrace" in sys.argv:
kw["program"].append("--stacktrace")
kw["chdir"] = subdir
self.last_program_invocation = kw["program"]
build_time_start = time.time()
apply(TestCmd.TestCmd.run, [self], kw)
build_time_finish = time.time()
except:
self.dump_stdio()
raise
old_last_build_timestamp = self.last_build_timestamp
self.tree, self.last_build_timestamp = tree.build_tree(self.workdir)
self.difference = tree.tree_difference(self.previous_tree, self.tree)
if self.difference.empty():
# If nothing has been changed by this build and sufficient time has
# passed since the last build that actually changed something,
# there is no need to wait for touched or newly created files to
# start getting newer timestamps than the currently existing ones.
self.last_build_timestamp = old_last_build_timestamp
self.difference.ignore_directories()
self.unexpected_difference = copy.deepcopy(self.difference)
if (status and self.status) is not None and self.status != status:
expect = ""
if status != 0:
expect = " (expected %d)" % status
annotation("failure", '"%s" returned %d%s' % (kw["program"],
self.status, expect))
annotation("reason", "unexpected status returned by bjam")
self.fail_test(1)
if stdout is not None and not match(self.stdout(), stdout):
stdout_test = match(self.stdout(), stdout)
annotation("failure", "Unexpected stdout")
annotation("Expected STDOUT", stdout)
annotation("Actual STDOUT", self.stdout())
stderr = self.stderr()
if stderr:
annotation("STDERR", stderr)
self.maybe_do_diff(self.stdout(), stdout, stdout_test)
self.fail_test(1, dump_stdio=False)
# Intel tends to produce some messages to stderr which make tests fail.
intel_workaround = re.compile("^xi(link|lib): executing.*\n", re.M)
actual_stderr = re.sub(intel_workaround, "", self.stderr())
if stderr is not None and not match(actual_stderr, stderr):
stderr_test = match(actual_stderr, stderr)
annotation("failure", "Unexpected stderr")
annotation("Expected STDERR", stderr)
annotation("Actual STDERR", self.stderr())
annotation("STDOUT", self.stdout())
self.maybe_do_diff(actual_stderr, stderr, stderr_test)
self.fail_test(1, dump_stdio=False)
if expected_duration is not None:
actual_duration = build_time_finish - build_time_start
if actual_duration > expected_duration:
print("Test run lasted %f seconds while it was expected to "
"finish in under %f seconds." % (actual_duration,
expected_duration))
self.fail_test(1, dump_stdio=False)
self.__ignore_junk()
def glob_file(self, name):
name = self.adjust_name(name)
result = None
if hasattr(self, "difference"):
for f in (self.difference.added_files +
self.difference.modified_files +
self.difference.touched_files):
if fnmatch.fnmatch(f, name):
result = self.__native_file_name(f)
break
if not result:
result = glob.glob(self.__native_file_name(name))
if result:
result = result[0]
return result
def __read(self, name, binary=False):
try:
openMode = "r"
if binary:
openMode += "b"
else:
openMode += "U"
f = open(name, openMode)
result = f.read()
f.close()
return result
except:
annotation("failure", "Could not open '%s'" % name)
self.fail_test(1)
return ""
def read(self, name, binary=False):
name = self.glob_file(name)
return self.__read(name, binary=binary)
def read_and_strip(self, name):
if not self.glob_file(name):
return ""
f = open(self.glob_file(name), "rb")
lines = f.readlines()
f.close()
result = "\n".join(x.rstrip() for x in lines)
if lines and lines[-1][-1] != "\n":
return result + "\n"
return result
def fail_test(self, condition, dump_difference=True, dump_stdio=True,
dump_stack=True):
if not condition:
return
if dump_difference and hasattr(self, "difference"):
f = StringIO.StringIO()
self.difference.pprint(f)
annotation("changes caused by the last build command",
f.getvalue())
if dump_stdio:
self.dump_stdio()
if "--preserve" in sys.argv:
print
print "*** Copying the state of working dir into 'failed_test' ***"
print
path = os.path.join(self.original_workdir, "failed_test")
if os.path.isdir(path):
shutil.rmtree(path, ignore_errors=False)
elif os.path.exists(path):
raise "Path " + path + " already exists and is not a directory"
shutil.copytree(self.workdir, path)
print "The failed command was:"
print " ".join(self.last_program_invocation)
if dump_stack:
annotate_stack_trace()
sys.exit(1)
# A number of methods below check expectations with actual difference
# between directory trees before and after a build. All the 'expect*'
# methods require exact names to be passed. All the 'ignore*' methods allow
# wildcards.
# All names can be either a string or a list of strings.
def expect_addition(self, names):
for name in self.adjust_names(names):
try:
glob_remove(self.unexpected_difference.added_files, name)
except:
annotation("failure", "File %s not added as expected" % name)
self.fail_test(1)
def ignore_addition(self, wildcard):
self.__ignore_elements(self.unexpected_difference.added_files,
wildcard)
def expect_removal(self, names):
for name in self.adjust_names(names):
try:
glob_remove(self.unexpected_difference.removed_files, name)
except:
annotation("failure", "File %s not removed as expected" % name)
self.fail_test(1)
def ignore_removal(self, wildcard):
self.__ignore_elements(self.unexpected_difference.removed_files,
wildcard)
def expect_modification(self, names):
for name in self.adjust_names(names):
try:
glob_remove(self.unexpected_difference.modified_files, name)
except:
annotation("failure", "File %s not modified as expected" %
name)
self.fail_test(1)
def ignore_modification(self, wildcard):
self.__ignore_elements(self.unexpected_difference.modified_files,
wildcard)
def expect_touch(self, names):
d = self.unexpected_difference
for name in self.adjust_names(names):
# We need to check both touched and modified files. The reason is
# that:
# (1) Windows binaries such as obj, exe or dll files have slight
# differences even with identical inputs due to Windows PE
# format headers containing an internal timestamp.
# (2) Intel's compiler for Linux has the same behaviour.
filesets = [d.modified_files, d.touched_files]
while filesets:
try:
glob_remove(filesets[-1], name)
break
except ValueError:
filesets.pop()
if not filesets:
annotation("failure", "File %s not touched as expected" % name)
self.fail_test(1)
def ignore_touch(self, wildcard):
self.__ignore_elements(self.unexpected_difference.touched_files,
wildcard)
def ignore(self, wildcard):
self.ignore_addition(wildcard)
self.ignore_removal(wildcard)
self.ignore_modification(wildcard)
self.ignore_touch(wildcard)
def expect_nothing(self, names):
for name in self.adjust_names(names):
if name in self.difference.added_files:
annotation("failure",
"File %s added, but no action was expected" % name)
self.fail_test(1)
if name in self.difference.removed_files:
annotation("failure",
"File %s removed, but no action was expected" % name)
self.fail_test(1)
pass
if name in self.difference.modified_files:
annotation("failure",
"File %s modified, but no action was expected" % name)
self.fail_test(1)
if name in self.difference.touched_files:
annotation("failure",
"File %s touched, but no action was expected" % name)
self.fail_test(1)
def __ignore_junk(self):
# Not totally sure about this change, but I do not see a good
# alternative.
if windows:
self.ignore("*.ilk") # MSVC incremental linking files.
self.ignore("*.pdb") # MSVC program database files.
self.ignore("*.rsp") # Response files.
self.ignore("*.tds") # Borland debug symbols.
self.ignore("*.manifest") # MSVC DLL manifests.
self.ignore("bin/standalone/msvc/*/msvc-setup.bat")
# Debug builds of bjam built with gcc produce this profiling data.
self.ignore("gmon.out")
self.ignore("*/gmon.out")
# Boost Build's 'configure' functionality (unfinished at the time)
# produces this file.
self.ignore("bin/config.log")
self.ignore("bin/project-cache.jam")
# Compiled Python files created when running Python based Boost Build.
self.ignore("*.pyc")
# OSX/Darwin files and dirs.
self.ignore("*.dSYM/*")
def expect_nothing_more(self):
if not self.unexpected_difference.empty():
annotation("failure", "Unexpected changes found")
output = StringIO.StringIO()
self.unexpected_difference.pprint(output)
annotation("unexpected changes", output.getvalue())
self.fail_test(1)
def expect_output_lines(self, lines, expected=True):
self.__expect_lines(self.stdout(), lines, expected)
def expect_content_lines(self, filename, line, expected=True):
self.__expect_lines(self.read_and_strip(filename), line, expected)
def expect_content(self, name, content, exact=False):
actual = self.read(name)
content = content.replace("$toolset", self.toolset + "*")
matched = False
if exact:
matched = fnmatch.fnmatch(actual, content)
else:
def sorted_(x):
x.sort(lambda x, y: cmp(x.lower().replace("\\","/"), y.lower().replace("\\","/")))
return x
actual_ = map(lambda x: sorted_(x.split()), actual.splitlines())
content_ = map(lambda x: sorted_(x.split()), content.splitlines())
if len(actual_) == len(content_):
matched = map(
lambda x, y: map(lambda n, p: fnmatch.fnmatch(n, p), x, y),
actual_, content_)
matched = reduce(
lambda x, y: x and reduce(
lambda a, b: a and b,
y, True),
matched, True)
if not matched:
print "Expected:\n"
print content
print "Got:\n"
print actual
self.fail_test(1)
def maybe_do_diff(self, actual, expected, result=None):
if os.environ.get("DO_DIFF"):
e = tempfile.mktemp("expected")
a = tempfile.mktemp("actual")
f = open(e, "w")
f.write(expected)
f.close()
f = open(a, "w")
f.write(actual)
f.close()
print("DIFFERENCE")
# Current diff should return 1 to indicate 'different input files'
# but some older diff versions may return 0 and depending on the
# exact Python/OS platform version, os.system() call may gobble up
# the external process's return code and return 0 itself.
if os.system('diff -u "%s" "%s"' % (e, a)) not in [0, 1]:
print('Unable to compute difference: diff -u "%s" "%s"' % (e, a
))
os.unlink(e)
os.unlink(a)
elif type(result) is TestCmd.MatchError:
print(result.message)
else:
print("Set environmental variable 'DO_DIFF' to examine the "
"difference.")
# Internal methods.
def adjust_lib_name(self, name):
global lib_prefix
global dll_prefix
result = name
pos = name.rfind(".")
if pos != -1:
suffix = name[pos:]
if suffix == ".lib":
(head, tail) = os.path.split(name)
if lib_prefix:
tail = lib_prefix + tail
result = os.path.join(head, tail)
elif suffix == ".dll":
(head, tail) = os.path.split(name)
if dll_prefix:
tail = dll_prefix + tail
result = os.path.join(head, tail)
# If we want to use this name in a Jamfile, we better convert \ to /,
# as otherwise we would have to quote \.
result = result.replace("\\", "/")
return result
def adjust_suffix(self, name):
if not self.translate_suffixes:
return name
pos = name.rfind(".")
if pos == -1:
return name
suffix = name[pos:]
return name[:pos] + suffixes.get(suffix, suffix)
# Acceps either a string or a list of strings and returns a list of
# strings. Adjusts suffixes on all names.
def adjust_names(self, names):
if names.__class__ is str:
names = [names]
r = map(self.adjust_lib_name, names)
r = map(self.adjust_suffix, r)
r = map(lambda x, t=self.toolset: x.replace("$toolset", t + "*"), r)
return r
def adjust_name(self, name):
return self.adjust_names(name)[0]
def __native_file_name(self, name):
return os.path.normpath(os.path.join(self.workdir, *name.split("/")))
def native_file_name(self, name):
return self.__native_file_name(self.adjust_name(name))
def wait_for_time_change(self, path, touch):
"""
Wait for newly assigned file system modification timestamps for the
given path to become large enough for the timestamp difference to be
correctly recognized by both this Python based testing framework and
the Boost Jam executable being tested. May optionally touch the given
path to set its modification timestamp to the new value.
"""
self.__wait_for_time_change(path, touch, last_build_time=False)
def wait_for_time_change_since_last_build(self):
"""
Wait for newly assigned file system modification timestamps to
become large enough for the timestamp difference to be
correctly recognized by the Python based testing framework.
Does not care about Jam's timestamp resolution, since we
only need this to detect touched files.
"""
if self.last_build_timestamp:
timestamp_file = "timestamp-3df2f2317e15e4a9"
open(timestamp_file, "wb").close()
self.__wait_for_time_change_impl(timestamp_file,
self.last_build_timestamp,
self.__python_timestamp_resolution(timestamp_file, 0), 0)
os.unlink(timestamp_file)
def __build_timestamp_resolution(self):
"""
Returns the minimum path modification timestamp resolution supported
by the used Boost Jam executable.
"""
dir = tempfile.mkdtemp("bjam_version_info")
try:
jam_script = "timestamp_resolution.jam"
f = open(os.path.join(dir, jam_script), "w")
try:
f.write("EXIT $(JAM_TIMESTAMP_RESOLUTION) : 0 ;")
finally:
f.close()
p = subprocess.Popen([self.program[0], "-d0", "-f%s" % jam_script],
stdout=subprocess.PIPE, cwd=dir, universal_newlines=True)
out, err = p.communicate()
finally:
shutil.rmtree(dir, ignore_errors=False)
if p.returncode != 0:
raise TestEnvironmentError("Unexpected return code (%s) when "
"detecting Boost Jam's minimum supported path modification "
"timestamp resolution version information." % p.returncode)
if err:
raise TestEnvironmentError("Unexpected error output (%s) when "
"detecting Boost Jam's minimum supported path modification "
"timestamp resolution version information." % err)
r = re.match("([0-9]{2}):([0-9]{2}):([0-9]{2}\\.[0-9]{9})$", out)
if not r:
# Older Boost Jam versions did not report their minimum supported
# path modification timestamp resolution and did not actually
# support path modification timestamp resolutions finer than 1
# second.
# TODO: Phase this support out to avoid such fallback code from
# possibly covering up other problems.
return 1
if r.group(1) != "00" or r.group(2) != "00": # hours, minutes
raise TestEnvironmentError("Boost Jam with too coarse minimum "
"supported path modification timestamp resolution (%s:%s:%s)."
% (r.group(1), r.group(2), r.group(3)))
return float(r.group(3)) # seconds.nanoseconds
def __ensure_newer_than_last_build(self, path):
"""
Updates the given path's modification timestamp after waiting for the
newly assigned file system modification timestamp to become large
enough for the timestamp difference between it and the last build
timestamp to be correctly recognized by both this Python based testing
framework and the Boost Jam executable being tested. Does nothing if
there is no 'last build' information available.
"""
if self.last_build_timestamp:
self.__wait_for_time_change(path, touch=True, last_build_time=True)
def __expect_lines(self, data, lines, expected):
"""
Checks whether the given data contains the given lines.
Data may be specified as a single string containing text lines
separated by newline characters.
Lines may be specified in any of the following forms:
* Single string containing text lines separated by newlines - the
given lines are searched for in the given data without any extra
data lines between them.
* Container of strings containing text lines separated by newlines
- the given lines are searched for in the given data with extra
data lines allowed between lines belonging to different strings.
* Container of strings containing text lines separated by newlines
and containers containing strings - the same as above with the
internal containers containing strings being interpreted as if
all their content was joined together into a single string
separated by newlines.
A newline at the end of any multi-line lines string is interpreted as
an expected extra trailig empty line.
"""
# str.splitlines() trims at most one trailing newline while we want the
# trailing newline to indicate that there should be an extra empty line
# at the end.
splitlines = lambda x : (x + "\n").splitlines()
if data is None:
data = []
elif data.__class__ is str:
data = splitlines(data)
if lines.__class__ is str:
lines = [splitlines(lines)]
else:
expanded = []
for x in lines:
if x.__class__ is str:
x = splitlines(x)
expanded.append(x)
lines = expanded
if _contains_lines(data, lines) != bool(expected):
output = []
if expected:
output = ["Did not find expected lines:"]
else:
output = ["Found unexpected lines:"]
first = True
for line_sequence in lines:
if line_sequence:
if first:
first = False
else:
output.append("...")
output.extend(" > " + line for line in line_sequence)
output.append("in output:")
output.extend(" > " + line for line in data)
annotation("failure", "\n".join(output))
self.fail_test(1)
def __ignore_elements(self, list, wildcard):
"""Removes in-place 'list' elements matching the given 'wildcard'."""
list[:] = filter(lambda x, w=wildcard: not fnmatch.fnmatch(x, w), list)
def __makedirs(self, path, wait):
"""
Creates a folder with the given path, together with any missing
parent folders. If WAIT is set, makes sure any newly created folders
have modification timestamps newer than the ones left behind by the
last build run.
"""
try:
if wait:
stack = []
while path and path not in stack and not os.path.isdir(path):
stack.append(path)
path = os.path.dirname(path)
while stack:
path = stack.pop()
os.mkdir(path)
self.__ensure_newer_than_last_build(path)
else:
os.makedirs(path)
except Exception:
pass
def __python_timestamp_resolution(self, path, minimum_resolution):
"""
Returns the modification timestamp resolution for the given path
supported by the used Python interpreter/OS/filesystem combination.
Will not check for resolutions less than the given minimum value. Will
change the path's modification timestamp in the process.
Return values:
0 - nanosecond resolution supported
positive decimal - timestamp resolution in seconds
"""
# Note on Python's floating point timestamp support:
# Python interpreter versions prior to Python 2.3 did not support
# floating point timestamps. Versions 2.3 through 3.3 may or may not
# support it depending on the configuration (may be toggled by calling
# os.stat_float_times(True/False) at program startup, disabled by
# default prior to Python 2.5 and enabled by default since). Python 3.3
# deprecated this configuration and 3.4 removed support for it after
# which floating point timestamps are always supported.
ver = sys.version_info[0:2]
python_nanosecond_support = ver >= (3, 4) or (ver >= (2, 3) and
os.stat_float_times())
# Minimal expected floating point difference used to account for
# possible imprecise floating point number representations. We want
# this number to be small (at least smaller than 0.0001) but still
# large enough that we can be sure that increasing a floating point
# value by 2 * eta guarantees the value read back will be increased by
# at least eta.
eta = 0.00005
stats_orig = os.stat(path)
def test_time(diff):
"""Returns whether a timestamp difference is detectable."""
os.utime(path, (stats_orig.st_atime, stats_orig.st_mtime + diff))
return os.stat(path).st_mtime > stats_orig.st_mtime + eta
# Test for nanosecond timestamp resolution support.
if not minimum_resolution and python_nanosecond_support:
if test_time(2 * eta):
return 0
# Detect the filesystem timestamp resolution. Note that there is no
# need to make this code 'as fast as possible' as, this function gets
# called before having to sleep until the next detectable modification
# timestamp value and that, since we already know nanosecond resolution
# is not supported, will surely take longer than whatever we do here to
# detect this minimal detectable modification timestamp resolution.
step = 0.1
if not python_nanosecond_support:
# If Python does not support nanosecond timestamp resolution we
# know the minimum possible supported timestamp resolution is 1
# second.
minimum_resolution = max(1, minimum_resolution)
index = max(1, int(minimum_resolution / step))
while step * index < minimum_resolution:
# Floating point number representation errors may cause our
# initially calculated start index to be too small if calculated
# directly.
index += 1
while True:
# Do not simply add up the steps to avoid cumulative floating point
# number representation errors.
next = step * index
if next > 10:
raise TestEnvironmentError("File systems with too coarse "
"modification timestamp resolutions not supported.")
if test_time(next):
return next
index += 1
def __wait_for_time_change(self, path, touch, last_build_time):
"""
Wait until a newly assigned file system modification timestamp for
the given path is large enough for the timestamp difference between it
and the last build timestamp or the path's original file system
modification timestamp (depending on the last_build_time flag) to be
correctly recognized by both this Python based testing framework and
the Boost Jam executable being tested. May optionally touch the given
path to set its modification timestamp to the new value.
"""
assert self.last_build_timestamp or not last_build_time
stats_orig = os.stat(path)
if last_build_time:
start_time = self.last_build_timestamp
else:
start_time = stats_orig.st_mtime
build_resolution = self.__build_timestamp_resolution()
assert build_resolution >= 0
# Check whether the current timestamp is already new enough.
if stats_orig.st_mtime > start_time and (not build_resolution or
stats_orig.st_mtime >= start_time + build_resolution):
return
resolution = self.__python_timestamp_resolution(path, build_resolution)
assert resolution >= build_resolution
self.__wait_for_time_change_impl(path, start_time, resolution, build_resolution)
if not touch:
os.utime(path, (stats_orig.st_atime, stats_orig.st_mtime))
def __wait_for_time_change_impl(self, path, start_time, resolution, build_resolution):
# Implementation notes:
# * Theoretically time.sleep() API might get interrupted too soon
# (never actually encountered).
# * We encountered cases where we sleep just long enough for the
# filesystem's modifiction timestamp to change to the desired value,
# but after waking up, the read timestamp is still just a tiny bit
# too small (encountered on Windows). This is most likely caused by
# imprecise floating point timestamp & sleep interval representation
# used by Python. Note though that we never encountered a case where
# more than one additional tiny sleep() call was needed to remedy
# the situation.
# * We try to wait long enough for the timestamp to change, but do not
# want to waste processing time by waiting too long. The main
# problem is that when we have a coarse resolution, the actual times
# get rounded and we do not know the exact sleep time needed for the
# difference between two such times to pass. E.g. if we have a 1
# second resolution and the original and the current file timestamps
# are both 10 seconds then it could be that the current time is
# 10.99 seconds and that we can wait for just one hundredth of a
# second for the current file timestamp to reach its next value, and
# using a longer sleep interval than that would just be wasting
# time.
while True:
os.utime(path, None)
c = os.stat(path).st_mtime
if resolution:
if c > start_time and (not build_resolution or c >= start_time
+ build_resolution):
break
if c <= start_time - resolution:
# Move close to the desired timestamp in one sleep, but not
# close enough for timestamp rounding to potentially cause
# us to wait too long.
if start_time - c > 5:
if last_build_time:
error_message = ("Last build time recorded as "
"being a future event, causing a too long "
"wait period. Something must have played "
"around with the system clock.")
else:
error_message = ("Original path modification "
"timestamp set to far into the future or "
"something must have played around with the "
"system clock, causing a too long wait "
"period.\nPath: '%s'" % path)
raise TestEnvironmentError(message)
_sleep(start_time - c)
else:
# We are close to the desired timestamp so take baby sleeps
# to avoid sleeping too long.
_sleep(max(0.01, resolution / 10))
else:
if c > start_time:
break
_sleep(max(0.01, start_time - c))
class List:
def __init__(self, s=""):
elements = []
if s.__class__ is str:
# Have to handle escaped spaces correctly.
elements = s.replace("\ ", "\001").split()
else:
elements = s
self.l = [e.replace("\001", " ") for e in elements]
def __len__(self):
return len(self.l)
def __getitem__(self, key):
return self.l[key]
def __setitem__(self, key, value):
self.l[key] = value
def __delitem__(self, key):
del self.l[key]
def __str__(self):
return str(self.l)
def __repr__(self):
return "%s.List(%r)" % (self.__module__, " ".join(self.l))
def __mul__(self, other):
result = List()
if not isinstance(other, List):
other = List(other)
for f in self:
for s in other:
result.l.append(f + s)
return result
def __rmul__(self, other):
if not isinstance(other, List):
other = List(other)
return List.__mul__(other, self)
def __add__(self, other):
result = List()
result.l = self.l[:] + other.l[:]
return result
def _contains_lines(data, lines):
data_line_count = len(data)
expected_line_count = reduce(lambda x, y: x + len(y), lines, 0)
index = 0
for expected in lines:
if expected_line_count > data_line_count - index:
return False
expected_line_count -= len(expected)
index = _match_line_sequence(data, index, data_line_count -
expected_line_count, expected)
if index < 0:
return False
return True
def _match_line_sequence(data, start, end, lines):
if not lines:
return start
for index in xrange(start, end - len(lines) + 1):
data_index = index
for expected in lines:
if not fnmatch.fnmatch(data[data_index], expected):
break;
data_index += 1
else:
return data_index
return -1
def _sleep(delay):
if delay > 5:
raise TestEnvironmentError("Test environment error: sleep period of "
"more than 5 seconds requested. Most likely caused by a file with "
"its modification timestamp set to sometime in the future.")
time.sleep(delay)
###############################################################################
#
# Initialization.
#
###############################################################################
# Make os.stat() return file modification times as floats instead of integers
# to get the best possible file timestamp resolution available. The exact
# resolution depends on the underlying file system and the Python os.stat()
# implementation. The better the resolution we achieve, the shorter we need to
# wait for files we create to start getting new timestamps.
#
# Additional notes:
# * os.stat_float_times() function first introduced in Python 2.3. and
# suggested for deprecation in Python 3.3.
# * On Python versions 2.5+ we do not need to do this as there os.stat()
# returns floating point file modification times by default.
# * Windows CPython implementations prior to version 2.5 do not support file
# modification timestamp resolutions of less than 1 second no matter whether
# these timestamps are returned as integer or floating point values.
# * Python documentation states that this should be set in a program's
# __main__ module to avoid affecting other libraries that might not be ready
# to support floating point timestamps. Since we use no such external
# libraries, we ignore this warning to make it easier to enable this feature
# in both our single & multiple-test scripts.
if (2, 3) <= sys.version_info < (2, 5) and not os.stat_float_times():
os.stat_float_times(True)
# Quickie tests. Should use doctest instead.
if __name__ == "__main__":
assert str(List("foo bar") * "/baz") == "['foo/baz', 'bar/baz']"
assert repr("foo/" * List("bar baz")) == "__main__.List('foo/bar foo/baz')"
assert _contains_lines([], [])
assert _contains_lines([], [[]])
assert _contains_lines([], [[], []])
assert _contains_lines([], [[], [], []])
assert not _contains_lines([], [[""]])
assert not _contains_lines([], [["a"]])
assert _contains_lines([""], [])
assert _contains_lines(["a"], [])
assert _contains_lines(["a", "b"], [])
assert _contains_lines(["a", "b"], [[], [], []])
assert _contains_lines([""], [[""]])
assert not _contains_lines([""], [["a"]])
assert not _contains_lines(["a"], [[""]])
assert _contains_lines(["a", "", "b", ""], [["a"]])
assert _contains_lines(["a", "", "b", ""], [[""]])
assert _contains_lines(["a", "", "b"], [["b"]])
assert not _contains_lines(["a", "b"], [[""]])
assert not _contains_lines(["a", "", "b", ""], [["c"]])
assert _contains_lines(["a", "", "b", "x"], [["x"]])
data = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
assert _contains_lines(data, [["1", "2"]])
assert not _contains_lines(data, [["2", "1"]])
assert not _contains_lines(data, [["1", "3"]])
assert not _contains_lines(data, [["1", "3"]])
assert _contains_lines(data, [["1"], ["2"]])
assert _contains_lines(data, [["1"], [], [], [], ["2"]])
assert _contains_lines(data, [["1"], ["3"]])
assert not _contains_lines(data, [["3"], ["1"]])
assert _contains_lines(data, [["3"], ["7"], ["8"]])
assert not _contains_lines(data, [["1"], ["3", "5"]])
assert not _contains_lines(data, [["1"], [""], ["5"]])
assert not _contains_lines(data, [["1"], ["5"], ["3"]])
assert not _contains_lines(data, [["1"], ["5", "3"]])
assert not _contains_lines(data, [[" 3"]])
assert not _contains_lines(data, [["3 "]])
assert not _contains_lines(data, [["3", ""]])
assert not _contains_lines(data, [["", "3"]])
print("tests passed")
| nawawi/poedit | deps/boost/tools/build/test/BoostBuild.py | Python | mit | 53,880 |
import getopt
import os
import sys
import logging
from pcs import (
settings,
usage,
utils,
)
from pcs.cli.common import (
capabilities,
completion,
errors,
parse_args,
routing,
)
from pcs.cli.reports import process_library_reports, output
from pcs.cli.routing import (
acl,
alert,
booth,
client,
cluster,
config,
constraint,
dr,
host,
node,
pcsd,
prop,
qdevice,
quorum,
resource,
status,
stonith,
tag,
)
from pcs.lib.errors import LibraryError
def _non_root_run(argv_cmd):
"""
This function will run commands which has to be run as root for users which
are not root. If it required to run such command as root it will do that by
sending it to the local pcsd and then it will exit.
"""
# matching the commands both in here and in pcsd expects -o and --options
# to be at the end of a command
argv_and_options = argv_cmd[:]
for option, value in utils.pcs_options.items():
if parse_args.is_option_expecting_value(option):
argv_and_options.extend([option, value])
else:
argv_and_options.append(option)
# specific commands need to be run under root account, pass them to pcsd
# don't forget to allow each command in pcsd.rb in "post /run_pcs do"
root_command_list = [
["cluster", "auth", "..."],
["cluster", "corosync", "..."],
["cluster", "destroy", "..."],
["cluster", "disable", "..."],
["cluster", "enable", "..."],
["cluster", "node", "..."],
["cluster", "pcsd-status", "..."], # TODO deprecated, remove command
["cluster", "start", "..."],
["cluster", "stop", "..."],
["cluster", "sync", "..."],
# ['config', 'restore', '...'], # handled in config.config_restore
["host", "auth", "..."],
["host", "deauth", "..."],
["pcsd", "deauth", "..."],
["pcsd", "status", "..."],
["pcsd", "sync-certificates"],
["quorum", "device", "status", "..."],
["quorum", "status", "..."],
["status"],
["status", "corosync", "..."],
["status", "pcsd", "..."],
["status", "quorum", "..."],
["status", "status", "..."],
]
for root_cmd in root_command_list:
if (argv_and_options == root_cmd) or (
root_cmd[-1] == "..."
and argv_and_options[: len(root_cmd) - 1] == root_cmd[:-1]
):
# handle interactivity of 'pcs cluster auth'
if argv_and_options[0:2] in [["cluster", "auth"], ["host", "auth"]]:
if "-u" not in utils.pcs_options:
username = utils.get_terminal_input("Username: ")
argv_and_options.extend(["-u", username])
if "-p" not in utils.pcs_options:
password = utils.get_terminal_password()
argv_and_options.extend(["-p", password])
# call the local pcsd
err_msgs, exitcode, std_out, std_err = utils.call_local_pcsd(
argv_and_options
)
if err_msgs:
for msg in err_msgs:
utils.err(msg, False)
sys.exit(1)
if std_out.strip():
print(std_out)
if std_err.strip():
sys.stderr.write(std_err)
sys.exit(exitcode)
usefile = False
filename = ""
def main(argv=None):
# pylint: disable=global-statement
# pylint: disable=too-many-branches
# pylint: disable=too-many-locals
# pylint: disable=too-many-statements
if completion.has_applicable_environment(os.environ):
print(
completion.make_suggestions(
os.environ, usage.generate_completion_tree_from_usage()
)
)
sys.exit()
argv = argv if argv else sys.argv[1:]
utils.subprocess_setup()
global filename, usefile
utils.pcs_options = {}
# we want to support optional arguments for --wait, so if an argument
# is specified with --wait (ie. --wait=30) then we use them
waitsecs = None
new_argv = []
for arg in argv:
if arg.startswith("--wait="):
tempsecs = arg.replace("--wait=", "")
if tempsecs:
waitsecs = tempsecs
arg = "--wait"
new_argv.append(arg)
argv = new_argv
try:
if "--" in argv:
pcs_options, argv = getopt.gnu_getopt(
argv, parse_args.PCS_SHORT_OPTIONS, parse_args.PCS_LONG_OPTIONS
)
else:
# DEPRECATED
# TODO remove
# We want to support only the -- version
(
args_without_negative_nums,
args_filtered_out,
) = parse_args.filter_out_non_option_negative_numbers(argv)
if args_filtered_out:
options_str = "', '".join(args_filtered_out)
output.warn(
f"Using '{options_str}' without '--' is deprecated, those "
"parameters will be considered position independent "
"options in future pcs versions"
)
pcs_options, dummy_argv = getopt.gnu_getopt(
args_without_negative_nums,
parse_args.PCS_SHORT_OPTIONS,
parse_args.PCS_LONG_OPTIONS,
)
argv = parse_args.filter_out_options(argv)
except getopt.GetoptError as err:
usage.main()
print(err)
if err.opt in {"V", "clone", "device", "watchdog"}:
# Print error messages which point users to the changes section in
# pcs manpage.
# TODO remove
# To be removed in the next significant version.
print(f"Hint: {errors.HINT_SYNTAX_CHANGE}")
sys.exit(1)
full = False
for option, dummy_value in pcs_options:
if option == "--full":
full = True
break
for opt, val in pcs_options:
if not opt in utils.pcs_options:
utils.pcs_options[opt] = val
else:
# If any options are a list then they've been entered twice which
# isn't valid
utils.err("%s can only be used once" % opt)
if opt in ("-h", "--help"):
if not argv:
usage.main()
sys.exit()
else:
argv = [argv[0], "help"] + argv[1:]
elif opt == "-f":
usefile = True
filename = val
utils.usefile = usefile
utils.filename = filename
elif opt == "--corosync_conf":
settings.corosync_conf_file = val
elif opt == "--version":
print(settings.pcs_version)
if full:
print(
" ".join(
sorted(
[
feat["id"]
for feat in capabilities.get_pcs_capabilities()
]
)
)
)
sys.exit()
elif opt == "--fullhelp":
usage.full_usage()
sys.exit()
elif opt == "--wait":
utils.pcs_options[opt] = waitsecs
elif opt == "--request-timeout":
request_timeout_valid = False
try:
timeout = int(val)
if timeout > 0:
utils.pcs_options[opt] = timeout
request_timeout_valid = True
except ValueError:
pass
if not request_timeout_valid:
utils.err(
(
"'{0}' is not a valid --request-timeout value, use "
"a positive integer"
).format(val)
)
# initialize logger
logging.getLogger("pcs")
if (os.getuid() != 0) and (argv and argv[0] != "help") and not usefile:
_non_root_run(argv)
cmd_map = {
"resource": resource.resource_cmd,
"cluster": cluster.cluster_cmd,
"stonith": stonith.stonith_cmd,
"property": prop.property_cmd,
"constraint": constraint.constraint_cmd,
"acl": acl.acl_cmd,
"status": status.status_cmd,
"config": config.config_cmd,
"pcsd": pcsd.pcsd_cmd,
"node": node.node_cmd,
"quorum": quorum.quorum_cmd,
"qdevice": qdevice.qdevice_cmd,
"alert": alert.alert_cmd,
"booth": booth.booth_cmd,
"host": host.host_cmd,
"client": client.client_cmd,
"dr": dr.dr_cmd,
"tag": tag.tag_cmd,
"help": lambda lib, argv, modifiers: usage.main(),
}
try:
routing.create_router(cmd_map, [])(
utils.get_library_wrapper(), argv, utils.get_input_modifiers()
)
except LibraryError as e:
process_library_reports(e.args)
except errors.CmdLineInputError:
if argv and argv[0] in cmd_map:
usage.show(argv[0], [])
else:
usage.main()
sys.exit(1)
| feist/pcs | pcs/app.py | Python | gpl-2.0 | 9,230 |
from collections import OrderedDict
import json
from django.db import models
from django.contrib.postgres.fields import JSONField as Builtin_JSONField
from django.core.serializers.json import Serializer as Builtin_Serializer
from django.utils.encoding import smart_text
class JSONField(Builtin_JSONField):
def value_from_object(self, obj):
value = getattr(obj, self.attname)
if value:
return json.loads(value)
else:
return None
| Fakor/congov | web/values/models.py | Python | mit | 484 |
#!/usr/bin/env python
""" sha1Hash_test.py
Unit tests for sha1.py
"""
from crypto.hash.sha1Hash import SHA1
import unittest
import struct
assert struct.calcsize('!IIIII') == 20, '5 integers should be 20 bytes'
class SHA1_FIPS180_TestCases(unittest.TestCase):
""" SHA-1 tests from FIPS180-1 Appendix A, B and C """
def testFIPS180_1_Appendix_A(self):
""" APPENDIX A. A SAMPLE MESSAGE AND ITS MESSAGE DIGEST """
hashAlg = SHA1()
message = 'abc'
message_digest = 0xA9993E36L, 0x4706816AL, 0xBA3E2571L, 0x7850C26CL, 0x9CD0D89DL
md_string = _toBString(message_digest)
assert( hashAlg(message) == md_string ), 'FIPS180 Appendix A test Failed'
def testFIPS180_1_Appendix_B(self):
""" APPENDIX B. A SECOND SAMPLE MESSAGE AND ITS MESSAGE DIGEST """
hashAlg = SHA1()
message = 'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq'
message_digest = 0x84983E44L, 0x1C3BD26EL, 0xBAAE4AA1L, 0xF95129E5L, 0xE54670F1L
md_string = _toBString(message_digest)
assert( hashAlg(message) == md_string ), 'FIPS180 Appendix B test Failed'
def testFIPS180_1_Appendix_C(self):
""" APPENDIX C. A THIRD SAMPLE MESSAGE AND ITS MESSAGE DIGEST
Let the message be the binary-coded form of the ASCII string which consists
of 1,000,000 repetitions of "a". """
hashAlg = SHA1()
message = 1000000*'a'
message_digest = 0x34AA973CL, 0xD4C4DAA4L, 0xF61EEB2BL, 0xDBAD2731L, 0x6534016FL
md_string = _toBString(message_digest)
assert( hashAlg(message) == md_string ), 'FIPS180 Appendix C test Failed'
def _toBlock(binaryString):
""" Convert binary string to blocks of 5 words of uint32() """
return [uint32(word) for word in struct.unpack('!IIIII', binaryString)]
def _toBString(block):
""" Convert block (5 words of 32 bits to binary string """
return ''.join([struct.pack('!I',word) for word in block])
if __name__ == '__main__':
# Run the tests from the command line
unittest.main()
| realms-team/basestation-fw | libs/smartmeshsdk-REL-1.3.0.1/external_libs/cryptopy/crypto/hash/sha1Hash_test.py | Python | bsd-3-clause | 2,119 |
import json
from corehq.apps.api.models import ApiUser, PERMISSION_POST_SMS
from corehq.apps.domain.models import Domain
from corehq.apps.hqcase.utils import update_case
from corehq.apps.sms.api import (send_sms, send_sms_to_verified_number,
send_sms_with_backend, send_sms_with_backend_name)
from corehq.apps.sms.mixin import BadSMSConfigException
from corehq.apps.sms.models import (SMS, QueuedSMS,
SQLMobileBackendMapping, SQLMobileBackend, MobileBackendInvitation,
PhoneLoadBalancingMixin, BackendMap)
from corehq.apps.sms.tasks import handle_outgoing
from corehq.apps.sms.tests.util import BaseSMSTest, delete_domain_phone_numbers
from corehq.form_processor.interfaces.dbaccessors import CaseAccessors
from corehq.form_processor.tests.utils import run_with_all_backends
from corehq.messaging.smsbackends.apposit.models import SQLAppositBackend
from corehq.messaging.smsbackends.grapevine.models import SQLGrapevineBackend
from corehq.messaging.smsbackends.http.models import SQLHttpBackend
from corehq.messaging.smsbackends.mach.models import SQLMachBackend
from corehq.messaging.smsbackends.megamobile.models import SQLMegamobileBackend
from corehq.messaging.smsbackends.push.models import PushBackend
from corehq.messaging.smsbackends.sislog.models import SQLSislogBackend
from corehq.messaging.smsbackends.smsgh.models import SQLSMSGHBackend
from corehq.messaging.smsbackends.telerivet.models import SQLTelerivetBackend
from corehq.messaging.smsbackends.test.models import SQLTestSMSBackend
from corehq.messaging.smsbackends.tropo.models import SQLTropoBackend
from corehq.messaging.smsbackends.twilio.models import SQLTwilioBackend
from corehq.messaging.smsbackends.unicel.models import SQLUnicelBackend, InboundParams
from corehq.messaging.smsbackends.yo.models import SQLYoBackend
from corehq.util.test_utils import create_test_case
from datetime import datetime
from dimagi.utils.couch.cache.cache_core import get_redis_client
from django.test import TestCase
from django.test.client import Client
from django.test.utils import override_settings
from mock import patch
from urllib import urlencode
class AllBackendTest(BaseSMSTest):
def setUp(self):
super(AllBackendTest, self).setUp()
self.domain_obj = Domain(name='all-backend-test')
self.domain_obj.save()
self.create_account_and_subscription(self.domain_obj.name)
self.domain_obj = Domain.get(self.domain_obj.get_id)
self.test_phone_number = '99912345'
self.unicel_backend = SQLUnicelBackend(
name='UNICEL',
is_global=True,
hq_api_id=SQLUnicelBackend.get_api_id()
)
self.unicel_backend.save()
self.mach_backend = SQLMachBackend(
name='MACH',
is_global=True,
hq_api_id=SQLMachBackend.get_api_id()
)
self.mach_backend.save()
self.tropo_backend = SQLTropoBackend(
name='TROPO',
is_global=True,
hq_api_id=SQLTropoBackend.get_api_id()
)
self.tropo_backend.save()
self.http_backend = SQLHttpBackend(
name='HTTP',
is_global=True,
hq_api_id=SQLHttpBackend.get_api_id()
)
self.http_backend.save()
self.telerivet_backend = SQLTelerivetBackend(
name='TELERIVET',
is_global=True,
hq_api_id=SQLTelerivetBackend.get_api_id()
)
self.telerivet_backend.set_extra_fields(
**dict(
webhook_secret='telerivet-webhook-secret'
)
)
self.telerivet_backend.save()
self.test_backend = SQLTestSMSBackend(
name='TEST',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.test_backend.save()
self.grapevine_backend = SQLGrapevineBackend(
name='GRAPEVINE',
is_global=True,
hq_api_id=SQLGrapevineBackend.get_api_id()
)
self.grapevine_backend.save()
self.twilio_backend = SQLTwilioBackend(
name='TWILIO',
is_global=True,
hq_api_id=SQLTwilioBackend.get_api_id()
)
self.twilio_backend.save()
self.megamobile_backend = SQLMegamobileBackend(
name='MEGAMOBILE',
is_global=True,
hq_api_id=SQLMegamobileBackend.get_api_id()
)
self.megamobile_backend.save()
self.smsgh_backend = SQLSMSGHBackend(
name='SMSGH',
is_global=True,
hq_api_id=SQLSMSGHBackend.get_api_id()
)
self.smsgh_backend.save()
self.apposit_backend = SQLAppositBackend(
name='APPOSIT',
is_global=True,
hq_api_id=SQLAppositBackend.get_api_id()
)
self.apposit_backend.save()
self.sislog_backend = SQLSislogBackend(
name='SISLOG',
is_global=True,
hq_api_id=SQLSislogBackend.get_api_id()
)
self.sislog_backend.save()
self.yo_backend = SQLYoBackend(
name='YO',
is_global=True,
hq_api_id=SQLYoBackend.get_api_id()
)
self.yo_backend.save()
self.push_backend = PushBackend(
name='PUSH',
is_global=True,
hq_api_id=PushBackend.get_api_id()
)
self.push_backend.save()
def _test_outbound_backend(self, backend, msg_text, mock_send):
SQLMobileBackendMapping.set_default_domain_backend(self.domain_obj.name, backend)
send_sms(self.domain_obj.name, None, self.test_phone_number, msg_text)
sms = SMS.objects.get(
domain=self.domain_obj.name,
direction='O',
text=msg_text
)
self.assertTrue(mock_send.called)
msg_arg = mock_send.call_args[0][0]
self.assertEqual(msg_arg.date, sms.date)
self.assertEqual(sms.backend_api, backend.hq_api_id)
self.assertEqual(sms.backend_id, backend.couch_id)
def _verify_inbound_request(self, backend_api_id, msg_text, backend_couch_id=None):
sms = SMS.objects.get(
domain=self.domain_obj.name,
direction='I',
text=msg_text
)
self.assertEqual(sms.backend_api, backend_api_id)
if backend_couch_id:
self.assertEqual(sms.backend_id, backend_couch_id)
def _simulate_inbound_request_with_payload(self, url,
content_type, payload):
with create_test_case(
self.domain_obj.name,
'participant',
'contact',
case_properties={
'contact_phone_number': self.test_phone_number,
'contact_phone_number_is_verified': '1',
},
drop_signals=False):
response = Client().post(url, payload, content_type=content_type)
self.assertEqual(response.status_code, 200)
def _simulate_inbound_request(self, url, phone_param,
msg_param, msg_text, post=False, additional_params=None,
expected_response_code=200, is_megamobile=False):
fcn = Client().post if post else Client().get
payload = {
phone_param: self.test_phone_number,
msg_param: msg_text,
}
if additional_params:
payload.update(additional_params)
contact_phone_prefix = '63' if is_megamobile else ''
with create_test_case(
self.domain_obj.name,
'participant',
'contact',
case_properties={
'contact_phone_number': contact_phone_prefix + self.test_phone_number,
'contact_phone_number_is_verified': '1',
},
drop_signals=False):
response = fcn(url, payload)
self.assertEqual(response.status_code, expected_response_code)
@patch('corehq.messaging.smsbackends.unicel.models.SQLUnicelBackend.send')
@patch('corehq.messaging.smsbackends.mach.models.SQLMachBackend.send')
@patch('corehq.messaging.smsbackends.tropo.models.SQLTropoBackend.send')
@patch('corehq.messaging.smsbackends.http.models.SQLHttpBackend.send')
@patch('corehq.messaging.smsbackends.telerivet.models.SQLTelerivetBackend.send')
@patch('corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send')
@patch('corehq.messaging.smsbackends.grapevine.models.SQLGrapevineBackend.send')
@patch('corehq.messaging.smsbackends.twilio.models.SQLTwilioBackend.send')
@patch('corehq.messaging.smsbackends.megamobile.models.SQLMegamobileBackend.send')
@patch('corehq.messaging.smsbackends.smsgh.models.SQLSMSGHBackend.send')
@patch('corehq.messaging.smsbackends.apposit.models.SQLAppositBackend.send')
@patch('corehq.messaging.smsbackends.sislog.models.SQLSislogBackend.send')
@patch('corehq.messaging.smsbackends.yo.models.SQLYoBackend.send')
@patch('corehq.messaging.smsbackends.push.models.PushBackend.send')
def test_outbound_sms(
self,
push_send,
yo_send,
sislog_send,
apposit_send,
smsgh_send,
megamobile_send,
twilio_send,
grapevine_send,
test_send,
telerivet_send,
http_send,
tropo_send,
mach_send,
unicel_send):
self._test_outbound_backend(self.unicel_backend, 'unicel test', unicel_send)
self._test_outbound_backend(self.mach_backend, 'mach test', mach_send)
self._test_outbound_backend(self.tropo_backend, 'tropo test', tropo_send)
self._test_outbound_backend(self.http_backend, 'http test', http_send)
self._test_outbound_backend(self.telerivet_backend, 'telerivet test', telerivet_send)
self._test_outbound_backend(self.test_backend, 'test test', test_send)
self._test_outbound_backend(self.grapevine_backend, 'grapevine test', grapevine_send)
self._test_outbound_backend(self.twilio_backend, 'twilio test', twilio_send)
self._test_outbound_backend(self.megamobile_backend, 'megamobile test', megamobile_send)
self._test_outbound_backend(self.smsgh_backend, 'smsgh test', smsgh_send)
self._test_outbound_backend(self.apposit_backend, 'apposit test', apposit_send)
self._test_outbound_backend(self.sislog_backend, 'sislog test', sislog_send)
self._test_outbound_backend(self.yo_backend, 'yo test', yo_send)
self._test_outbound_backend(self.push_backend, 'push test', push_send)
@run_with_all_backends
def test_unicel_inbound_sms(self):
self._simulate_inbound_request('/unicel/in/', phone_param=InboundParams.SENDER,
msg_param=InboundParams.MESSAGE, msg_text='unicel test')
self._verify_inbound_request(self.unicel_backend.get_api_id(), 'unicel test')
@run_with_all_backends
def test_tropo_inbound_sms(self):
tropo_data = {'session': {'from': {'id': self.test_phone_number}, 'initialText': 'tropo test'}}
self._simulate_inbound_request_with_payload('/tropo/sms/',
content_type='text/json', payload=json.dumps(tropo_data))
self._verify_inbound_request(self.tropo_backend.get_api_id(), 'tropo test')
@run_with_all_backends
def test_telerivet_inbound_sms(self):
additional_params = {
'event': 'incoming_message',
'message_type': 'sms',
'secret': self.telerivet_backend.config.webhook_secret
}
self._simulate_inbound_request('/telerivet/in/', phone_param='from_number_e164',
msg_param='content', msg_text='telerivet test', post=True,
additional_params=additional_params)
self._verify_inbound_request(self.telerivet_backend.get_api_id(), 'telerivet test')
@run_with_all_backends
@override_settings(SIMPLE_API_KEYS={'grapevine-test': 'grapevine-api-key'})
def test_grapevine_inbound_sms(self):
xml = """
<gviSms>
<smsDateTime>2015-10-12T12:00:00</smsDateTime>
<cellNumber>99912345</cellNumber>
<content>grapevine test</content>
</gviSms>
"""
payload = urlencode({'XML': xml})
self._simulate_inbound_request_with_payload(
'/gvi/api/sms/?apiuser=grapevine-test&apikey=grapevine-api-key',
content_type='application/x-www-form-urlencoded', payload=payload)
self._verify_inbound_request(self.grapevine_backend.get_api_id(), 'grapevine test')
@run_with_all_backends
def test_twilio_inbound_sms(self):
url = '/twilio/sms/%s' % self.twilio_backend.inbound_api_key
self._simulate_inbound_request(url, phone_param='From',
msg_param='Body', msg_text='twilio test', post=True)
self._verify_inbound_request(self.twilio_backend.get_api_id(), 'twilio test',
backend_couch_id=self.twilio_backend.couch_id)
@run_with_all_backends
def test_twilio_401_response(self):
start_count = SMS.objects.count()
self._simulate_inbound_request('/twilio/sms/xxxxx', phone_param='From',
msg_param='Body', msg_text='twilio test', post=True,
expected_response_code=401)
end_count = SMS.objects.count()
self.assertEqual(start_count, end_count)
@run_with_all_backends
def test_megamobile_inbound_sms(self):
self._simulate_inbound_request('/megamobile/sms/', phone_param='cel',
msg_param='msg', msg_text='megamobile test', is_megamobile=True)
self._verify_inbound_request(self.megamobile_backend.get_api_id(), 'megamobile test')
@run_with_all_backends
def test_sislog_inbound_sms(self):
self._simulate_inbound_request('/sislog/in/', phone_param='sender',
msg_param='msgdata', msg_text='sislog test')
self._verify_inbound_request(self.sislog_backend.get_api_id(), 'sislog test')
@run_with_all_backends
def test_yo_inbound_sms(self):
self._simulate_inbound_request('/yo/sms/', phone_param='sender',
msg_param='message', msg_text='yo test')
self._verify_inbound_request(self.yo_backend.get_api_id(), 'yo test')
@run_with_all_backends
def test_smsgh_inbound_sms(self):
user = ApiUser.create('smsgh-api-key', 'smsgh-api-key', permissions=[PERMISSION_POST_SMS])
user.save()
self._simulate_inbound_request('/smsgh/sms/smsgh-api-key/', phone_param='snr',
msg_param='msg', msg_text='smsgh test')
self._verify_inbound_request('SMSGH', 'smsgh test')
user.delete()
@run_with_all_backends
def test_apposit_inbound_sms(self):
self._simulate_inbound_request_with_payload(
'/apposit/in/%s/' % self.apposit_backend.inbound_api_key,
'application/json',
json.dumps({
'from': self.test_phone_number,
'message': 'apposit test',
})
)
self._verify_inbound_request('APPOSIT', 'apposit test',
backend_couch_id=self.apposit_backend.couch_id)
@run_with_all_backends
def test_push_inbound_sms(self):
xml = """<?xml version="1.0" encoding="UTF-8"?>
<bspostevent>
<field name="MobileNumber" type="string">99912345</field>
<field name="Text" type="string">push test</field>
</bspostevent>
"""
self._simulate_inbound_request_with_payload(
'/push/sms/%s/' % self.push_backend.inbound_api_key,
content_type='application/xml', payload=xml)
self._verify_inbound_request(self.push_backend.get_api_id(), 'push test',
backend_couch_id=self.push_backend.couch_id)
def tearDown(self):
delete_domain_phone_numbers(self.domain_obj.name)
self.domain_obj.delete()
self.unicel_backend.delete()
self.mach_backend.delete()
self.tropo_backend.delete()
self.http_backend.delete()
self.telerivet_backend.delete()
self.test_backend.delete()
self.grapevine_backend.delete()
self.twilio_backend.delete()
self.megamobile_backend.delete()
self.smsgh_backend.delete()
self.apposit_backend.delete()
self.sislog_backend.delete()
self.yo_backend.delete()
self.push_backend.delete()
super(AllBackendTest, self).tearDown()
class OutgoingFrameworkTestCase(BaseSMSTest):
def setUp(self):
super(OutgoingFrameworkTestCase, self).setUp()
self.domain = "test-domain"
self.domain2 = "test-domain2"
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.create_account_and_subscription(self.domain_obj.name)
self.domain_obj = Domain.get(self.domain_obj._id)
self.backend1 = SQLTestSMSBackend.objects.create(
name='BACKEND1',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend2 = SQLTestSMSBackend.objects.create(
name='BACKEND2',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend3 = SQLTestSMSBackend.objects.create(
name='BACKEND3',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend4 = SQLTestSMSBackend.objects.create(
name='BACKEND4',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend5 = SQLTestSMSBackend.objects.create(
name='BACKEND5',
domain=self.domain,
is_global=False,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend6 = SQLTestSMSBackend.objects.create(
name='BACKEND6',
domain=self.domain2,
is_global=False,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend6.set_shared_domains([self.domain])
self.backend7 = SQLTestSMSBackend.objects.create(
name='BACKEND7',
domain=self.domain2,
is_global=False,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend8 = SQLTestSMSBackend.objects.create(
name='BACKEND',
domain=self.domain,
is_global=False,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend9 = SQLTestSMSBackend.objects.create(
name='BACKEND',
domain=self.domain2,
is_global=False,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend9.set_shared_domains([self.domain])
self.backend10 = SQLTestSMSBackend.objects.create(
name='BACKEND',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id()
)
self.backend_mapping1 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='*',
backend=self.backend1
)
self.backend_mapping2 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='1',
backend=self.backend2
)
self.backend_mapping3 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='91',
backend=self.backend3
)
self.backend_mapping4 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='265',
backend=self.backend4
)
self.backend_mapping5 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='256',
backend=self.backend5
)
self.backend_mapping6 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='25670',
backend=self.backend6
)
self.backend_mapping7 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='25675',
backend=self.backend7
)
def tearDown(self):
delete_domain_phone_numbers(self.domain)
delete_domain_phone_numbers(self.domain2)
for obj in (
list(MobileBackendInvitation.objects.all()) +
list(SQLMobileBackendMapping.objects.all())
):
# For now we can't do bulk delete because we need to have the
# delete sync with couch
obj.delete()
self.backend1.delete()
self.backend2.delete()
self.backend3.delete()
self.backend4.delete()
self.backend5.delete()
self.backend6.delete()
self.backend7.delete()
self.backend8.delete()
self.backend9.delete()
self.backend10.delete()
self.domain_obj.delete()
super(OutgoingFrameworkTestCase, self).tearDown()
def test_multiple_country_prefixes(self):
self.assertEqual(
SQLMobileBackend.load_default_by_phone_and_domain(
SQLMobileBackend.SMS,
'256800000000'
).pk,
self.backend5.pk
)
self.assertEqual(
SQLMobileBackend.load_default_by_phone_and_domain(
SQLMobileBackend.SMS,
'256700000000'
).pk,
self.backend6.pk
)
self.assertEqual(
SQLMobileBackend.load_default_by_phone_and_domain(
SQLMobileBackend.SMS,
'256750000000'
).pk,
self.backend7.pk
)
def __test_global_backend_map(self):
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms(self.domain, None, '15551234567', 'Test for BACKEND2'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend2.pk)
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms(self.domain, None, '9100000000', 'Test for BACKEND3'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend3.pk)
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms(self.domain, None, '26500000000', 'Test for BACKEND4'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend4.pk)
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms(self.domain, None, '25800000000', 'Test for BACKEND1'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend1.pk)
def __test_domain_default(self):
# Test overriding with domain-level backend
SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend5)
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms(self.domain, None, '15551234567', 'Test for BACKEND5'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend5.pk)
def __test_shared_backend(self):
# Test use of backend that another domain owns but has granted access
SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend6)
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms(self.domain, None, '25800000000', 'Test for BACKEND6'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend6.pk)
# Test trying to use a backend that another domain owns but has not granted access
SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend7)
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertFalse(send_sms(self.domain, None, '25800000000', 'Test Unauthorized'))
self.assertEqual(mock_send.call_count, 0)
def __test_verified_number_with_map(self, contact):
# Test sending to verified number with backend map
SQLMobileBackendMapping.unset_default_domain_backend(self.domain)
verified_number = contact.get_verified_number()
self.assertTrue(verified_number is not None)
self.assertTrue(verified_number.backend_id is None)
self.assertEqual(verified_number.phone_number, '15551234567')
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for BACKEND2'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend2.pk)
# Test sending to verified number with default domain backend
SQLMobileBackendMapping.set_default_domain_backend(self.domain, self.backend5)
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for BACKEND5'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend5.pk)
def __test_contact_level_backend(self, contact):
# Test sending to verified number with a contact-level backend owned by the domain
update_case(self.domain, contact.case_id, case_properties={'contact_backend_id': 'BACKEND'})
contact = CaseAccessors(self.domain).get_case(contact.case_id)
verified_number = contact.get_verified_number()
self.assertTrue(verified_number is not None)
self.assertEqual(verified_number.backend_id, 'BACKEND')
self.assertEqual(verified_number.phone_number, '15551234567')
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for domain BACKEND'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend8.pk)
# Test sending to verified number with a contact-level backend granted to the domain by another domain
self.backend8.name = 'BACKEND8'
self.backend8.save()
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for shared domain BACKEND'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend9.pk)
# Test sending to verified number with a contact-level global backend
self.backend9.name = 'BACKEND9'
self.backend9.save()
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(send_sms_to_verified_number(verified_number, 'Test for global BACKEND'))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend10.pk)
# Test raising exception if contact-level backend is not found
self.backend10.name = 'BACKEND10'
self.backend10.save()
with self.assertRaises(BadSMSConfigException):
send_sms_to_verified_number(verified_number, 'Test for unknown BACKEND')
def __test_send_sms_with_backend(self):
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(
send_sms_with_backend(self.domain, '+15551234567', 'Test for BACKEND3', self.backend3.couch_id)
)
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend3.pk)
def __test_send_sms_with_backend_name(self):
with patch(
'corehq.messaging.smsbackends.test.models.SQLTestSMSBackend.send',
autospec=True
) as mock_send:
self.assertTrue(
send_sms_with_backend_name(self.domain, '+15551234567', 'Test for BACKEND3', 'BACKEND3')
)
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(mock_send.call_args[0][0].pk, self.backend3.pk)
def test_choosing_appropriate_backend_for_outgoing(self):
with create_test_case(
self.domain,
'participant',
'contact',
case_properties={
'contact_phone_number': '15551234567',
'contact_phone_number_is_verified': '1',
},
drop_signals=False) as contact:
self.__test_global_backend_map()
self.__test_domain_default()
self.__test_shared_backend()
self.__test_verified_number_with_map(contact)
self.__test_contact_level_backend(contact)
self.__test_send_sms_with_backend()
self.__test_send_sms_with_backend_name()
class SQLMobileBackendTestCase(TestCase):
def assertBackendsEqual(self, backend1, backend2):
self.assertEqual(backend1.pk, backend2.pk)
self.assertEqual(backend1.__class__, backend2.__class__)
def test_domain_is_shared(self):
backend = SQLTestSMSBackend.objects.create(
name='BACKEND',
domain='shared-test-1',
is_global=False,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
self.assertFalse(backend.domain_is_shared('shared-test-2'))
backend.set_shared_domains(['shared-test-2'])
self.assertTrue(backend.domain_is_shared('shared-test-2'))
backend.soft_delete()
self.assertFalse(backend.domain_is_shared('shared-test-2'))
backend.delete()
def test_domain_is_authorized(self):
backend1 = SQLTestSMSBackend.objects.create(
name='BACKEND1',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend2 = SQLTestSMSBackend.objects.create(
name='BACKEND2',
domain='auth-test-1',
is_global=False,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
self.assertTrue(backend1.domain_is_authorized('auth-test-1'))
self.assertTrue(backend1.domain_is_authorized('auth-test-2'))
self.assertTrue(backend1.domain_is_authorized('auth-test-3'))
self.assertTrue(backend2.domain_is_authorized('auth-test-1'))
self.assertFalse(backend2.domain_is_authorized('auth-test-2'))
self.assertFalse(backend2.domain_is_authorized('auth-test-3'))
backend2.set_shared_domains(['auth-test-2'])
self.assertTrue(backend2.domain_is_authorized('auth-test-1'))
self.assertTrue(backend2.domain_is_authorized('auth-test-2'))
self.assertFalse(backend2.domain_is_authorized('auth-test-3'))
backend1.delete()
backend2.delete()
def test_load_default_by_phone_and_domain(self):
backend1 = SQLTestSMSBackend.objects.create(
name='BACKEND1',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend2 = SQLTestSMSBackend.objects.create(
name='BACKEND2',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend3 = SQLTestSMSBackend.objects.create(
name='BACKEND3',
is_global=False,
domain='load-default-test',
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend4 = SQLTestSMSBackend.objects.create(
name='BACKEND4',
is_global=False,
domain='load-default-test',
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='*',
backend=backend1
)
SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='27',
backend=backend2
)
SQLMobileBackendMapping.objects.create(
is_global=False,
domain='load-default-test',
backend_type=SQLMobileBackend.SMS,
prefix='*',
backend=backend3
)
SQLMobileBackendMapping.objects.create(
is_global=False,
domain='load-default-test',
backend_type=SQLMobileBackend.SMS,
prefix='27',
backend=backend4
)
# Test global prefix map
self.assertBackendsEqual(
SQLMobileBackend.load_default_by_phone_and_domain(
SQLMobileBackend.SMS,
'2700000000',
domain='load-default-test-2'
),
backend2
)
# Test domain-level prefix map
self.assertBackendsEqual(
SQLMobileBackend.load_default_by_phone_and_domain(
SQLMobileBackend.SMS,
'2700000000',
domain='load-default-test'
),
backend4
)
# Test domain catch-all
backend4.soft_delete()
self.assertBackendsEqual(
SQLMobileBackend.load_default_by_phone_and_domain(
SQLMobileBackend.SMS,
'2700000000',
domain='load-default-test'
),
backend3
)
# Test global prefix map
backend3.soft_delete()
self.assertBackendsEqual(
SQLMobileBackend.load_default_by_phone_and_domain(
SQLMobileBackend.SMS,
'2700000000',
domain='load-default-test'
),
backend2
)
# Test global catch-all
backend2.soft_delete()
self.assertBackendsEqual(
SQLMobileBackend.load_default_by_phone_and_domain(
SQLMobileBackend.SMS,
'2700000000',
domain='load-default-test'
),
backend1
)
# Test raising exception if nothing found
backend1.soft_delete()
with self.assertRaises(BadSMSConfigException):
SQLMobileBackend.load_default_by_phone_and_domain(
SQLMobileBackend.SMS,
'2700000000',
domain='load-default-test'
)
backend1.delete()
backend2.delete()
backend3.delete()
backend4.delete()
def test_get_backend_api_id(self):
backend = SQLTestSMSBackend.objects.create(
name='BACKEND',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
self.assertEquals(
SQLMobileBackend.get_backend_api_id(backend.pk),
SQLTestSMSBackend.get_api_id()
)
self.assertEquals(
SQLMobileBackend.get_backend_api_id(backend.couch_id, is_couch_id=True),
SQLTestSMSBackend.get_api_id()
)
backend.soft_delete()
with self.assertRaises(SQLMobileBackend.DoesNotExist):
SQLMobileBackend.get_backend_api_id(backend.pk)
with self.assertRaises(SQLMobileBackend.DoesNotExist):
SQLMobileBackend.get_backend_api_id(backend.couch_id, is_couch_id=True)
backend.delete()
def test_load(self):
backend = SQLTestSMSBackend.objects.create(
name='BACKEND',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
self.assertBackendsEqual(
SQLMobileBackend.load(backend.pk),
backend
)
self.assertBackendsEqual(
SQLMobileBackend.load(backend.pk, api_id=SQLTestSMSBackend.get_api_id()),
backend
)
self.assertBackendsEqual(
SQLMobileBackend.load(backend.couch_id, is_couch_id=True),
backend
)
self.assertBackendsEqual(
SQLMobileBackend.load(
backend.couch_id,
api_id=SQLTestSMSBackend.get_api_id(),
is_couch_id=True
),
backend
)
backend.soft_delete()
with self.assertRaises(SQLMobileBackend.DoesNotExist):
SQLMobileBackend.load(backend.pk, api_id=SQLTestSMSBackend.get_api_id())
with self.assertRaises(SQLMobileBackend.DoesNotExist):
SQLMobileBackend.load(
backend.couch_id,
api_id=SQLTestSMSBackend.get_api_id(),
is_couch_id=True
)
with self.assertRaises(BadSMSConfigException):
SQLMobileBackend.load(backend.pk, api_id='this-api-id-does-not-exist')
backend.delete()
def test_load_by_name(self):
backend1 = SQLTestSMSBackend.objects.create(
name='BACKEND_BY_NAME_TEST',
is_global=False,
domain='backend-by-name-test-1',
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend2 = SQLTestSMSBackend.objects.create(
name='BACKEND_BY_NAME_TEST',
is_global=False,
domain='backend-by-name-test-2',
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend2.set_shared_domains(['backend-by-name-test-1'])
backend3 = SQLTestSMSBackend.objects.create(
name='BACKEND_BY_NAME_TEST',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
self.assertBackendsEqual(
SQLMobileBackend.load_by_name(
SQLMobileBackend.SMS,
'backend-by-name-test-1',
'BACKEND_BY_NAME_TEST'
),
backend1
)
self.assertBackendsEqual(
SQLMobileBackend.load_by_name(
SQLMobileBackend.SMS,
'backend-by-name-test-3',
'BACKEND_BY_NAME_TEST'
),
backend3
)
backend1.soft_delete()
self.assertBackendsEqual(
SQLMobileBackend.load_by_name(
SQLMobileBackend.SMS,
'backend-by-name-test-1',
'BACKEND_BY_NAME_TEST'
),
backend2
)
backend2.set_shared_domains([])
self.assertBackendsEqual(
SQLMobileBackend.load_by_name(
SQLMobileBackend.SMS,
'backend-by-name-test-1',
'BACKEND_BY_NAME_TEST'
),
backend3
)
self.assertBackendsEqual(
SQLMobileBackend.load_by_name(
SQLMobileBackend.SMS,
'backend-by-name-test-2',
'BACKEND_BY_NAME_TEST'
),
backend2
)
backend2.soft_delete()
self.assertBackendsEqual(
SQLMobileBackend.load_by_name(
SQLMobileBackend.SMS,
'backend-by-name-test-2',
'BACKEND_BY_NAME_TEST'
),
backend3
)
backend3.soft_delete()
with self.assertRaises(BadSMSConfigException):
SQLMobileBackend.load_by_name(
SQLMobileBackend.SMS,
'backend-by-name-test-1',
'BACKEND_BY_NAME_TEST'
)
backend1.delete()
backend2.delete()
backend3.delete()
class LoadBalanceBackend(SQLTestSMSBackend, PhoneLoadBalancingMixin):
class Meta:
proxy = True
@classmethod
def get_api_id(cls):
return 'LOAD_BALANCE'
class RateLimitBackend(SQLTestSMSBackend):
class Meta:
proxy = True
def get_sms_rate_limit(self):
return 10
@classmethod
def get_api_id(cls):
return 'RATE_LIMIT'
class LoadBalanceAndRateLimitBackend(SQLTestSMSBackend, PhoneLoadBalancingMixin):
class Meta:
proxy = True
def get_sms_rate_limit(self):
return 10
@classmethod
def get_api_id(cls):
return 'LOAD_BALANCE_RATE_LIMIT'
def mock_get_backend_classes():
return {
LoadBalanceBackend.get_api_id(): LoadBalanceBackend,
RateLimitBackend.get_api_id(): RateLimitBackend,
LoadBalanceAndRateLimitBackend.get_api_id(): LoadBalanceAndRateLimitBackend,
}
@patch('corehq.apps.sms.util.get_backend_classes', new=mock_get_backend_classes)
class LoadBalancingAndRateLimitingTestCase(BaseSMSTest):
def setUp(self):
super(LoadBalancingAndRateLimitingTestCase, self).setUp()
self.domain = 'load-balance-rate-limit'
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
self.create_account_and_subscription(self.domain)
self.domain_obj = Domain.get(self.domain_obj.get_id)
def tearDown(self):
QueuedSMS.objects.all().delete()
self.domain_obj.delete()
super(LoadBalancingAndRateLimitingTestCase, self).tearDown()
def create_outgoing_sms(self, backend):
sms = QueuedSMS(
domain=self.domain,
date=datetime.utcnow(),
direction='O',
phone_number='9991234567',
text='message',
backend_id=backend.couch_id
)
sms.save()
return sms
def delete_load_balancing_keys(self, backend):
# This should only be necessary when running tests locally, but doesn't
# hurt to run all the time.
client = get_redis_client().client.get_client()
client.delete(backend.get_load_balance_redis_key())
def assertRequeue(self, backend):
requeue_flag = handle_outgoing(self.create_outgoing_sms(backend))
self.assertTrue(requeue_flag)
def assertNotRequeue(self, backend):
requeue_flag = handle_outgoing(self.create_outgoing_sms(backend))
self.assertFalse(requeue_flag)
def test_load_balance(self):
backend = LoadBalanceBackend.objects.create(
name='BACKEND',
is_global=True,
load_balancing_numbers=['9990001', '9990002', '9990003'],
hq_api_id=LoadBalanceBackend.get_api_id()
)
self.delete_load_balancing_keys(backend)
for i in range(5):
with patch('corehq.apps.sms.tests.test_backends.LoadBalanceBackend.send') as mock_send:
self.assertNotRequeue(backend)
self.assertTrue(mock_send.called)
self.assertEqual(mock_send.call_args[1]['orig_phone_number'], '9990001')
self.assertNotRequeue(backend)
self.assertTrue(mock_send.called)
self.assertEqual(mock_send.call_args[1]['orig_phone_number'], '9990002')
self.assertNotRequeue(backend)
self.assertTrue(mock_send.called)
self.assertEqual(mock_send.call_args[1]['orig_phone_number'], '9990003')
backend.delete()
def test_rate_limit(self):
backend = RateLimitBackend.objects.create(
name='BACKEND',
is_global=True,
hq_api_id=RateLimitBackend.get_api_id()
)
# Requeue flag should be False until we hit the limit
for i in range(backend.get_sms_rate_limit()):
with patch('corehq.apps.sms.tests.test_backends.RateLimitBackend.send') as mock_send:
self.assertNotRequeue(backend)
self.assertTrue(mock_send.called)
# Requeue flag should be True after hitting the limit
with patch('corehq.apps.sms.tests.test_backends.RateLimitBackend.send') as mock_send:
self.assertRequeue(backend)
self.assertFalse(mock_send.called)
backend.delete()
def test_load_balance_and_rate_limit(self):
backend = LoadBalanceAndRateLimitBackend.objects.create(
name='BACKEND',
is_global=True,
load_balancing_numbers=['9990001', '9990002', '9990003'],
hq_api_id=LoadBalanceAndRateLimitBackend.get_api_id()
)
self.delete_load_balancing_keys(backend)
for i in range(backend.get_sms_rate_limit()):
with patch('corehq.apps.sms.tests.test_backends.LoadBalanceAndRateLimitBackend.send') as mock_send:
self.assertNotRequeue(backend)
self.assertTrue(mock_send.called)
self.assertEqual(mock_send.call_args[1]['orig_phone_number'], '9990001')
self.assertNotRequeue(backend)
self.assertTrue(mock_send.called)
self.assertEqual(mock_send.call_args[1]['orig_phone_number'], '9990002')
self.assertNotRequeue(backend)
self.assertTrue(mock_send.called)
self.assertEqual(mock_send.call_args[1]['orig_phone_number'], '9990003')
with patch('corehq.apps.sms.tests.test_backends.LoadBalanceAndRateLimitBackend.send') as mock_send:
self.assertRequeue(backend)
self.assertFalse(mock_send.called)
self.assertRequeue(backend)
self.assertFalse(mock_send.called)
self.assertRequeue(backend)
self.assertFalse(mock_send.called)
backend.delete()
class SQLMobileBackendMappingTestCase(TestCase):
def test_backend_map(self):
backend_map = BackendMap(
1, {
'1': 2,
'27': 3,
'256': 4,
'25670': 5,
'25675': 6,
}
)
self.assertEqual(backend_map.get_backend_id_by_prefix('910000000'), 1)
self.assertEqual(backend_map.get_backend_id_by_prefix('100000000'), 2)
self.assertEqual(backend_map.get_backend_id_by_prefix('200000000'), 1)
self.assertEqual(backend_map.get_backend_id_by_prefix('250000000'), 1)
self.assertEqual(backend_map.get_backend_id_by_prefix('270000000'), 3)
self.assertEqual(backend_map.get_backend_id_by_prefix('256000000'), 4)
self.assertEqual(backend_map.get_backend_id_by_prefix('256700000'), 5)
self.assertEqual(backend_map.get_backend_id_by_prefix('256750000'), 6)
def assertNoDomainDefaultBackend(self, domain):
self.assertEqual(
SQLMobileBackendMapping.objects.filter(domain=domain).count(),
0
)
def assertDomainDefaultBackend(self, domain, backend):
mapping = SQLMobileBackendMapping.objects.get(domain=domain)
self.assertFalse(mapping.is_global)
self.assertEqual(mapping.domain, domain)
self.assertEqual(mapping.backend_type, SQLMobileBackend.SMS)
self.assertEqual(mapping.prefix, '*')
self.assertEqual(mapping.backend_id, backend.pk)
def test_set_default_domain_backend(self):
backend1 = SQLTestSMSBackend.objects.create(
name='BACKEND1',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend2 = SQLTestSMSBackend.objects.create(
name='BACKEND2',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
domain = 'domain-default-backend-test'
self.assertNoDomainDefaultBackend(domain)
SQLMobileBackendMapping.set_default_domain_backend(domain, backend1)
self.assertDomainDefaultBackend(domain, backend1)
SQLMobileBackendMapping.set_default_domain_backend(domain, backend2)
self.assertDomainDefaultBackend(domain, backend2)
SQLMobileBackendMapping.unset_default_domain_backend(domain)
self.assertNoDomainDefaultBackend(domain)
backend1.delete()
backend2.delete()
def test_get_prefix_to_backend_map(self):
backend1 = SQLTestSMSBackend.objects.create(
name='BACKEND1',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend2 = SQLTestSMSBackend.objects.create(
name='BACKEND2',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend3 = SQLTestSMSBackend.objects.create(
name='BACKEND3',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend4 = SQLTestSMSBackend.objects.create(
name='BACKEND4',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend5 = SQLTestSMSBackend.objects.create(
name='BACKEND5',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend6 = SQLTestSMSBackend.objects.create(
name='BACKEND6',
is_global=True,
hq_api_id=SQLTestSMSBackend.get_api_id(),
)
backend_mapping1 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='*',
backend=backend1
)
backend_mapping2 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='27',
backend=backend2
)
backend_mapping3 = SQLMobileBackendMapping.objects.create(
is_global=True,
backend_type=SQLMobileBackend.SMS,
prefix='1',
backend=backend3
)
backend_mapping4 = SQLMobileBackendMapping.objects.create(
is_global=False,
domain='prefix-backend-map-test',
backend_type=SQLMobileBackend.SMS,
prefix='*',
backend=backend4
)
backend_mapping5 = SQLMobileBackendMapping.objects.create(
is_global=False,
domain='prefix-backend-map-test',
backend_type=SQLMobileBackend.SMS,
prefix='256',
backend=backend5
)
backend_mapping6 = SQLMobileBackendMapping.objects.create(
is_global=False,
domain='prefix-backend-map-test',
backend_type=SQLMobileBackend.SMS,
prefix='25670',
backend=backend6
)
global_backend_map = SQLMobileBackendMapping.get_prefix_to_backend_map(SQLMobileBackend.SMS)
self.assertEqual(global_backend_map.catchall_backend_id, backend1.pk)
self.assertEqual(global_backend_map.backend_map_dict, {
'27': backend2.pk,
'1': backend3.pk,
})
domain_backend_map = SQLMobileBackendMapping.get_prefix_to_backend_map(
SQLMobileBackend.SMS,
domain='prefix-backend-map-test'
)
self.assertEqual(domain_backend_map.catchall_backend_id, backend4.pk)
self.assertEqual(domain_backend_map.backend_map_dict, {
'256': backend5.pk,
'25670': backend6.pk,
})
backend_mapping1.delete()
backend_mapping2.delete()
backend_mapping3.delete()
backend_mapping4.delete()
backend_mapping5.delete()
backend_mapping6.delete()
backend1.delete()
backend2.delete()
backend3.delete()
backend4.delete()
backend5.delete()
backend6.delete()
| qedsoftware/commcare-hq | corehq/apps/sms/tests/test_backends.py | Python | bsd-3-clause | 52,667 |