text
stringlengths 6
947k
| repo_name
stringlengths 5
100
| path
stringlengths 4
231
| language
stringclasses 1
value | license
stringclasses 15
values | size
int64 6
947k
| score
float64 0
0.34
|
|---|---|---|---|---|---|---|
TIPOS_MENSAJES = {
'entrada': "entrada",
'salida': "salida",
'pago_ticket': "pago de ticket",
}
MENSAJES = {
'entrada': "Se ha reportado en el sistema una entrada ",
'salida': "salida",
'pago_ticket': "pago de ticket",
}
def
|
ac-seguridad/ac-seguridad
|
project/manejador/mensajes.py
|
Python
|
apache-2.0
| 256 | 0.003906 |
# Copyright 2020 Makani Technologies 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.
"""Motor INA219 hardware monitor configuration."""
from makani.avionics.firmware.drivers import ina219_types
from makani.avionics.firmware.serial import motor_serial_params as rev
ina219_default = {
'name': '',
'address': 0x0,
'shunt_resistor': 0.01,
'bus_voltage': ina219_types.kIna219BusVoltage16V,
'range': ina219_types.kIna219Range40mv,
'bus_adc': ina219_types.kIna219Adc128Samples,
'shunt_adc': ina219_types.kIna219Adc128Samples,
'mode': ina219_types.kIna219ModeShuntAndBusContinuous,
'current_max': -1,
'voltage_limits_percent': [95, 105],
}
ina219_16v_40mv = dict(ina219_default, **{
'bus_voltage': ina219_types.kIna219BusVoltage16V,
'range': ina219_types.kIna219Range40mv,
})
ina219_16v_80mv = dict(ina219_default, **{
'bus_voltage': ina219_types.kIna219BusVoltage16V,
'range': ina219_types.kIna219Range80mv,
})
ina219_32v_40mv = dict(ina219_default, **{
'bus_voltage': ina219_types.kIna219BusVoltage32V,
'range': ina219_types.kIna219Range40mv,
})
ina219_32v_160mv = dict(ina219_default, **{
'bus_voltage': ina219_types.kIna219BusVoltage32V,
'range': ina219_types.kIna219Range160mv,
})
gin_a1 = [
dict(ina219_32v_40mv, name='12v', address=0x40, shunt_resistor=0.012),
dict(ina219_16v_40mv, name='1v2', address=0x42, shunt_resistor=0.02),
dict(ina219_16v_40mv, name='3v3', address=0x45, shunt_resistor=0.02),
]
gin_a2 = gin_a1
gin_a3 = [
dict(ina219_32v_160mv, name='12v', address=0x41, shunt_resistor=0.05),
dict(ina219_16v_80mv, name='1v2', address=0x42, shunt_resistor=0.05),
dict(ina219_16v_80mv, name='3v3', address=0x45, shunt_resistor=0.05),
]
ina219_config = (rev.MotorHardware, {
rev.MotorHardware.GIN_A1: gin_a1,
rev.MotorHardware.GIN_A2: gin_a2,
rev.MotorHardware.GIN_A3: gin_a3,
rev.MotorHardware.GIN_A4_CLK16: gin_a3,
rev.MotorHardware.GIN_A4_CLK8: gin_a3,
rev.MotorHardware.OZONE_A1: gin_a3,
})
|
google/makani
|
avionics/motor/monitors/motor_ina219.py
|
Python
|
apache-2.0
| 2,535 | 0 |
import csv
import sys
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)
def parse(file_name):
"Parses the data sets from the csv file we are given to work with"
try:
file = open(file_name)
except IOError:
print "Failed to open the data file"
sys.exit()
rawFile = csv.reader(file) # Reading the csv file into a raw form
rawData = list(rawFile) # Converting the raw data into list from.
file.close()
return rawData
def toXandY(unorderedData):
"This method converts seperates x and y co-ordinates for plotting"
orderedData = []
orderedData.append([]) # Add a new sublist every time
orderedData.append([]) # Add a new sublist every time
listSize = len(unorderedData)
for x in range(0, listSize):
orderedData[0].append(unorderedData[x][0]) # Seperates the x-cords
for y in range(0, listSize):
orderedData[1].append(unorderedData[y][1]) # Seperates the y-cords
return orderedData
def main():
newData = []
f_line_x = []
f_line_y = []
file_name = "data.csv"
data = parse(file_name) # Calling the parse funtion we made
labels = data.pop(0) # Necessary evil
frontier_size = int(data.pop(0)[0])
list_size = len(data)
for i in range(0, list_size): # Converting the string list to float
newData.append([]) # Add a new sublsit every time
for j in range(0, 2): # Append converted data to the new list
newData[i].append(float(data[i][j]))
DataXandY = toXandY(newData) # DataXandY -> [[Xs][Ys]]
i = 0
while i < frontier_size:
i+=1
f_line_x.append(DataXandY[0].pop(0))
f_line_y.append(DataXandY[1].pop(0))
plt.xlabel(labels[0])
plt.ylabel(labels[1])
plt.title("Pareto dominance")
plt.plot(DataXandY[0], DataXandY[1], "o", color="g") # Plot all points
plt.plot(f_line_x, f_line_y, "-o", color="r") # Plot frontier line
plt.gca().set_aspect('equal', adjustable='box')
plt.show()
if __name__ == "__main__":
main()
|
GZakharov1525/SOFE3770
|
Assignment2/plot_lines.py
|
Python
|
gpl-3.0
| 2,119 | 0.003303 |
#!/usr/bin/env python3
"""*.h5 の値の最小・最大などを確認するスクリプト。"""
import argparse
import pathlib
import sys
import h5py
import numpy as np
try:
import pytoolkit as tk
except ImportError:
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent.parent))
import pytoolkit as tk
logger = tk.log.get(__name__)
def main():
tk.utils.better_exceptions()
tk.log.init(None)
parser = argparse.ArgumentParser(description="*.h5 の値の最小・最大などを確認するスクリプト。")
parser.add_argument("model_path", type=pathlib.Path, help="対象ファイルのパス(*.h5)")
args = parser.parse_args()
logger.info(f"{args.model_path} Loading...")
absmax_list = []
with h5py.File(args.model_path, mode="r") as f:
model_weights = f["model_weights"]
layer_names = model_weights.attrs["layer_names"]
for layer_name in layer_names:
g = model_weights[layer_name]
weight_names = g.attrs["weight_names"]
for weight_name in weight_names:
w = np.asarray(g[weight_name])
key = f"/model_weights/{layer_name}/{weight_name}"
if w.size == 1:
logger.info(f"{key}\t value={np.ravel(w)[0]:.2f}")
else:
logger.info(
f"{key}\t min={w.min():.2f} max={w.max():.2f} mean={w.mean():.2f} std={w.std():.2f}"
)
absmax_list.append((key, np.abs(w).max()))
logger.info("abs Top-10:")
for key, absvalue in list(sorted(absmax_list, key=lambda x: -x[1]))[:10]:
logger.info(f"{absvalue:6.1f}: {key}")
if __name__ == "__main__":
main()
|
ak110/pytoolkit
|
pytoolkit/bin/h5ls.py
|
Python
|
mit
| 1,745 | 0.001826 |
#!/usr/bin/python
# Copyright (c) 2012 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.
import json
import mox
import os
import sys
import shutil
import time
import constants
sys.path.insert(0, constants.SOURCE_ROOT)
from chromite.lib import cros_build_lib
from chromite.lib import cros_test_lib
from chromite.lib import git
from chromite.buildbot import remote_try
from chromite.buildbot import repository
from chromite.scripts import cbuildbot
class RemoteTryJobMock(remote_try.RemoteTryJob):
pass
# pylint: disable=W0212,R0904,E1101
class RemoteTryTests(cros_test_lib.MoxTempDirTestCase):
PATCHES = ('5555', '6666')
BOTS = ('x86-generic-paladin', 'arm-generic-paladin')
def setUp(self):
self.parser = cbuildbot._CreateParser()
args = ['-r', '/tmp/test_build1', '-g', '5555', '-g',
'6666', '--remote']
args.extend(self.BOTS)
self.options, args = cbuildbot._ParseCommandLine(self.parser, args)
self.checkout_dir = os.path.join(self.tempdir, 'test_checkout')
self.int_mirror, self.ext_mirror = None, None
def _RunCommandSingleOutput(self, cmd, cwd):
result = cros_build_lib.RunCommandCaptureOutput(cmd, cwd=cwd)
out_lines = result.output.split()
self.assertEqual(len(out_lines), 1)
return out_lines[0]
def _GetNewestFile(self, dirname, basehash):
newhash = git.GetGitRepoRevision(dirname)
self.assertNotEqual(basehash, newhash)
cmd = ['git', 'log', '--format=%H', '%s..' % basehash]
# Make sure we have a single commit.
self._RunCommandSingleOutput(cmd, cwd=dirname)
cmd = ['git', 'diff', '--name-only', 'HEAD^']
# Make sure only one file per commit.
return self._RunCommandSingleOutput(cmd, cwd=dirname)
def _SubmitJob(self, checkout_dir, job, version=None):
"""Returns the path to the tryjob description."""
self.assertTrue(isinstance(job, RemoteTryJobMock))
basehash = git.GetGitRepoRevision(job.ssh_url)
if version is not None:
self._SetMirrorVersion(version)
job.Submit(workdir=checkout_dir, dryrun=True)
# Get the file that was just created.
created_file = self._GetNewestFile(checkout_dir, basehash)
return os.path.join(checkout_dir, created_file)
def _SetupMirrors(self):
mirror = os.path.join(self.tempdir, 'tryjobs_mirror')
os.mkdir(mirror)
url = '%s/%s' % (constants.GIT_HTTP_URL, 'chromiumos/tryjobs')
repository.CloneGitRepo(mirror, url,
bare=True)
self.ext_mirror = mirror
mirror = os.path.join(self.tempdir, 'tryjobs_int_mirror')
os.mkdir(mirror)
repository.CloneGitRepo(mirror, self.ext_mirror, reference=self.ext_mirror,
bare=True)
self.int_mirror = mirror
RemoteTryJobMock.EXT_SSH_URL = self.ext_mirror
RemoteTryJobMock.INT_SSH_URL = self.int_mirror
self._SetMirrorVersion(remote_try.RemoteTryJob.TRYJOB_FORMAT_VERSION, True)
def _SetMirrorVersion(self, version, only_if_missing=False):
for path in (self.ext_mirror, self.int_mirror):
vpath = os.path.join(path, remote_try.RemoteTryJob.TRYJOB_FORMAT_FILE)
if os.path.exists(vpath) and only_if_missing:
continue
# Get ourselves a working dir.
tmp_repo = os.path.join(self.tempdir, 'tmp-repo')
git.RunGit(self.tempdir, ['clone', path, tmp_repo])
vpath = os.path.join(tmp_repo, remote_try.RemoteTryJob.TRYJOB_FORMAT_FILE)
with open(vpath, 'w') as f:
f.write(str(version))
git.RunGit(tmp_repo, ['add', vpath])
git.RunGit(tmp_repo, ['commit', '-m', 'setting version to %s' % version])
git.RunGit(tmp_repo, ['push', path, 'master:master'])
shutil.rmtree(tmp_repo)
def _CreateJob(self, mirror=True):
job_class = remote_try.RemoteTryJob
if mirror:
job_class = RemoteTryJobMock
self._SetupMirrors()
job = job_class(self.options, self.BOTS, [])
return job
def testJobTimestamp(self):
"""Verify jobs have unique names."""
def submit_helper(dirname):
work_dir = os.path.join(self.tempdir, dirname)
return os.path.basename(self._SubmitJob(work_dir, job))
self.mox.StubOutWithMock(repository, 'IsARepoRoot')
repository.IsARepoRoot(mox.IgnoreArg()).AndReturn(False)
self.mox.ReplayAll()
job = self._CreateJob()
file1 = submit_helper('test1')
# Tryjob file names are based on timestamp, so delay one second to avoid two
# jobfiles having the same name.
time.sleep(1)
file2 = submit_helper('test2')
self.assertNotEqual(file1, file2)
def testSimpleTryJob(self, version=None):
"""Test that a tryjob spec file is created and pushed properly."""
self.mox.StubOutWithMock(repository, 'IsARepoRoot')
repository.IsARepoRoot(mox.IgnoreArg()).AndReturn(True)
self.mox.StubOutWithMock(repository, 'IsInternalRepoCheckout')
repository.IsInternalRepoCheckout(mox.IgnoreArg()).AndReturn(False)
self.mox.ReplayAll()
try:
os.environ["GIT_AUTHOR_EMAIL"] = "Elmer Fudd <efudd@google.com>"
os.environ["GIT_COMMITTER_EMAIL"] = "Elmer Fudd <efudd@google.com>"
job = self._CreateJob()
finally:
os.environ.pop("GIT_AUTHOR_EMAIL", None)
os.environ.pop("GIT_COMMITTER_EMAIL", None)
created_file = self._SubmitJob(self.checkout_dir, job, version=version)
with open(created_file, 'rb') as job_desc_file:
values = json.load(job_desc_file)
self.assertTrue('efudd@google.com' in values['email'][0])
for patch in self.PATCHES:
self.assertTrue(patch in values['extra_args'],
msg="expected patch %s in args %s" %
(patch, values['extra_args']))
self.assertTrue(set(self.BOTS).issubset(values['bot']))
remote_url = cros_build_lib.RunCommand(
['git', 'config', 'remote.origin.url'], redirect_stdout=True,
cwd=self.checkout_dir).output.strip()
self.assertEqual(remote_url, self.ext_mirror)
def testClientVersionAwareness(self):
self.assertRaises(
remote_try.ChromiteUpgradeNeeded,
self.testSimpleTryJob,
version=remote_try.RemoteTryJob.TRYJOB_FORMAT_VERSION + 1)
def testInternalTryJob(self):
"""Verify internal tryjobs are pushed properly."""
self.mox.StubOutWithMock(repository, 'IsARepoRoot')
repository.IsARepoRoot(mox.IgnoreArg()).AndReturn(True)
self.mox.StubOutWithMock(repository, 'IsInternalRepoCheckout')
repository.IsInternalRepoCheckout(mox.IgnoreArg()).AndReturn(True)
self.mox.ReplayAll()
job = self._CreateJob()
self._SubmitJob(self.checkout_dir, job)
remote_url = cros_build_lib.RunCommand(
['git', 'config', 'remote.origin.url'], redirect_stdout=True,
cwd=self.checkout_dir).output.strip()
self.assertEqual(remote_url, self.int_mirror)
def testBareTryJob(self):
"""Verify submitting a tryjob from just a chromite checkout works."""
self.mox.StubOutWithMock(repository, 'IsARepoRoot')
repository.IsARepoRoot(mox.IgnoreArg()).AndReturn(False)
self.mox.StubOutWithMock(repository, 'IsInternalRepoCheckout')
self.mox.ReplayAll()
job = self._CreateJob(mirror=False)
self.assertEqual(job.ssh_url, remote_try.RemoteTryJob.EXT_SSH_URL)
if __name__ == '__main__':
cros_test_lib.main()
|
espadrine/opera
|
chromium/src/third_party/chromite/buildbot/remote_try_unittest.py
|
Python
|
bsd-3-clause
| 7,349 | 0.006668 |
'''
base tools
'''
# -*- coding: utf-8 -*-
import re
def is_ipv4(ip) :
pattern = r'^(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[0-9]{1,2})){3}$'
matcher = re.match(pattern, ip)
if matcher is not None :
return True
return False
def is_domain(domain) :
pattern = r'[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+\.?'
matcher = re.match(pattern, domain)
if matcher is not None :
return True
return False
|
allen1989127/WhereRU
|
org/sz/tools.py
|
Python
|
gpl-3.0
| 508 | 0.015748 |
# --------------------------------------------------------
# Fast R-CNN
# Copyright (c) 2015 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by Ross Girshick
# --------------------------------------------------------
"""Set up paths for Fast R-CNN."""
import os.path as osp
import sys
def add_path(path):
if path not in sys.path:
sys.path.insert(0, path)
this_dir = osp.dirname(__file__)
# Add caffe to PYTHONPATH
caffe_path = osp.join(this_dir, '..', 'caffe-fast-rcnn', 'python')
add_path(caffe_path)
# Add lib to PYTHONPATH
lib_path = osp.join(this_dir, '..', 'lib')
add_path(lib_path)
|
yxliang/fast-rcnn
|
tools/_init_paths.py
|
Python
|
mit
| 637 | 0.00314 |
from asyncio import coroutine
import pytest
from aiohttp import HttpBadRequest, HttpMethodNotAllowed
from fluentmock import create_mock
from aiohttp_rest import RestEndpoint
class CustomEndpoint(RestEndpoint):
def get(self):
pass
def patch(self):
pass
@pytest.fixture
def endpoint():
return RestEndpoint()
@pytest.fixture
def custom_endpoint():
return CustomEndpoint()
def test_exiting_methods_are_registered_during_initialisation(custom_endpoint: CustomEndpoint):
assert len(custom_endpoint.methods) == 2
assert ('GET', custom_endpoint.get) in custom_endpoint.methods.items()
assert ('PATCH', custom_endpoint.patch) in custom_endpoint.methods.items()
def test_register_method(endpoint: RestEndpoint):
def sample_method():
pass
endpoint.register_method('verb', sample_method)
assert ('VERB', sample_method) in endpoint.methods.items()
@pytest.mark.asyncio
async def test_dispatch_uses_correct_handler_for_verb(endpoint: RestEndpoint):
endpoint.register_method('VERB1', coroutine(lambda: 5))
endpoint.register_method('VERB2', coroutine(lambda: 17))
assert await endpoint.dispatch(create_mock(method='VERB1', match_info={})) == 5
assert await endpoint.dispatch(create_mock(method='VERB2', match_info={})) == 17
@pytest.mark.asyncio
async def test_dispatch_passes_request_when_required(endpoint: RestEndpoint):
endpoint.register_method('REQUEST', coroutine(lambda request: request))
request = create_mock(method='REQUEST', match_info={})
assert await endpoint.dispatch(request) == request
@pytest.mark.asyncio
async def test_dispatch_passes_match_info_when_required(endpoint: RestEndpoint):
endpoint.register_method('MATCH_INFO', coroutine(lambda prop1, prop2: (prop2, prop1)))
request = create_mock(method='MATCH_INFO', match_info={'prop1': 1, 'prop2': 2})
assert await endpoint.dispatch(request) == (2, 1)
@pytest.mark.asyncio
async def test_dispatch_raises_bad_request_when_match_info_does_not_exist(endpoint: RestEndpoint):
endpoint.register_method('BAD_MATCH_INFO', coroutine(lambda no_match: no_match))
request = create_mock(method='BAD_MATCH_INFO', match_info={})
with pytest.raises(HttpBadRequest):
await endpoint.dispatch(request)
@pytest.mark.asyncio
async def test_dispatch_raises_method_not_allowed_when_verb_not_matched(endpoint: RestEndpoint):
request = create_mock(method='NO_METHOD')
with pytest.raises(HttpMethodNotAllowed):
await endpoint.dispatch(request)
|
atbentley/aiohttp-rest
|
tests/test_endpoint.py
|
Python
|
mit
| 2,542 | 0.003541 |
# coding=utf-8
import logging
import time
from adapter import Adapter
DROIDBOT_APP_PACKAGE = "io.github.ylimit.droidbotapp"
IME_SERVICE = DROIDBOT_APP_PACKAGE + "/.DroidBotIME"
class DroidBotImeException(Exception):
"""
Exception in telnet connection
"""
pass
class DroidBotIme(Adapter):
"""
a connection with droidbot ime app.
"""
def __init__(self, device=None):
"""
initiate a emulator console via telnet
:param device: instance of Device
:return:
"""
self.logger = logging.getLogger(self.__class__.__name__)
if device is None:
from droidbot.device import Device
device = Device()
self.device = device
self.connected = False
def set_up(self):
device = self.device
if DROIDBOT_APP_PACKAGE in device.adb.get_installed_apps():
self.logger.debug("DroidBot app was already installed.")
else:
# install droidbot app
try:
import pkg_resources
droidbot_app_path = pkg_resources.resource_filename("droidbot", "resources/droidbotApp.apk")
install_cmd = "install %s" % droidbot_app_path
self.device.adb.run_cmd(install_cmd)
self.logger.debug("DroidBot app installed.")
except Exception as e:
self.logger.warning(e.message)
self.logger.warning("Failed to install DroidBotApp.")
def tear_down(self):
self.device.uninstall_app(DROIDBOT_APP_PACKAGE)
def connect(self):
r_enable = self.device.adb.shell("ime enable %s" % IME_SERVICE)
if r_enable.endswith("now enabled"):
r_set = self.device.adb.shell("ime set %s" % IME_SERVICE)
if r_set.endswith("selected"):
self.connected = True
return
self.logger.warning("Failed to connect DroidBotIME!")
def check_connectivity(self):
"""
check if droidbot app is connected
:return: True for connected
"""
return self.connected
def disconnect(self):
"""
disconnect telnet
"""
self.connected = False
r_disable = self.device.adb.shell("ime disable %s" % IME_SERVICE)
if r_disable.endswith("now disabled"):
self.connected = False
print "[CONNECTION] %s is disconnected" % self.__class__.__name__
return
self.logger.warning("Failed to disconnect DroidBotIME!")
def input_text(self, text, mode=0):
"""
Input text to target device
:param text: text to input, can be unicode format
:param mode: 0 - set text; 1 - append text.
"""
input_cmd = "am broadcast -a DROIDBOT_INPUT_TEXT --es text \"%s\" --ei mode %d" % (text, mode)
self.device.adb.shell(input_cmd)
if __name__ == "__main__":
droidbot_ime_conn = DroidBotIme()
droidbot_ime_conn.set_up()
droidbot_ime_conn.connect()
droidbot_ime_conn.input_text("hello world!", 0)
droidbot_ime_conn.input_text(u"世界你好!", 1)
time.sleep(2)
droidbot_ime_conn.input_text(u"再见。Bye bye.", 0)
droidbot_ime_conn.disconnect()
droidbot_ime_conn.tear_down()
|
nastya/droidbot
|
droidbot/adapter/droidbot_ime.py
|
Python
|
mit
| 3,282 | 0.000612 |
# postgresql/json.py
# Copyright (C) 2005-2018 the SQLAlchemy authors and contributors
# <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
from __future__ import absolute_import
import json
import collections
from .base import ischema_names, colspecs
from ... import types as sqltypes
from ...sql import operators
from ...sql import elements
from ... import util
__all__ = ('JSON', 'JSONB')
idx_precedence = operators._PRECEDENCE[operators.json_getitem_op]
ASTEXT = operators.custom_op(
"->>", precedence=idx_precedence, natural_self_precedent=True,
eager_grouping=True
)
JSONPATH_ASTEXT = operators.custom_op(
"#>>", precedence=idx_precedence, natural_self_precedent=True,
eager_grouping=True
)
HAS_KEY = operators.custom_op(
"?", precedence=idx_precedence, natural_self_precedent=True,
eager_grouping=True
)
HAS_ALL = operators.custom_op(
"?&", precedence=idx_precedence, natural_self_precedent=True,
eager_grouping=True
)
HAS_ANY = operators.custom_op(
"?|", precedence=idx_precedence, natural_self_precedent=True,
eager_grouping=True
)
CONTAINS = operators.custom_op(
"@>", precedence=idx_precedence, natural_self_precedent=True,
eager_grouping=True
)
CONTAINED_BY = operators.custom_op(
"<@", precedence=idx_precedence, natural_self_precedent=True,
eager_grouping=True
)
class JSONPathType(sqltypes.JSON.JSONPathType):
def bind_processor(self, dialect):
super_proc = self.string_bind_processor(dialect)
def process(value):
assert isinstance(value, collections.Sequence)
tokens = [util.text_type(elem)for elem in value]
value = "{%s}" % (", ".join(tokens))
if super_proc:
value = super_proc(value)
return value
return process
def literal_processor(self, dialect):
super_proc = self.string_literal_processor(dialect)
def process(value):
assert isinstance(value, collections.Sequence)
tokens = [util.text_type(elem)for elem in value]
value = "{%s}" % (", ".join(tokens))
if super_proc:
value = super_proc(value)
return value
return process
colspecs[sqltypes.JSON.JSONPathType] = JSONPathType
class JSON(sqltypes.JSON):
"""Represent the PostgreSQL JSON type.
This type is a specialization of the Core-level :class:`.types.JSON`
type. Be sure to read the documentation for :class:`.types.JSON` for
important tips regarding treatment of NULL values and ORM use.
.. versionchanged:: 1.1 :class:`.postgresql.JSON` is now a PostgreSQL-
specific specialization of the new :class:`.types.JSON` type.
The operators provided by the PostgreSQL version of :class:`.JSON`
include:
* Index operations (the ``->`` operator)::
data_table.c.data['some key']
data_table.c.data[5]
* Index operations returning text (the ``->>`` operator)::
data_table.c.data['some key'].astext == 'some value'
* Index operations with CAST
(equivalent to ``CAST(col ->> ['some key'] AS <type>)``)::
data_table.c.data['some key'].astext.cast(Integer) == 5
* Path index operations (the ``#>`` operator)::
data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')]
* Path index operations returning text (the ``#>>`` operator)::
data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')].astext == \
'some value'
.. versionchanged:: 1.1 The :meth:`.ColumnElement.cast` operator on
JSON objects now requires that the :attr:`.JSON.Comparator.astext`
modifier be called explicitly, if the cast works only from a textual
string.
Index operations return an expression object whose type defaults to
:class:`.JSON` by default, so that further JSON-oriented instructions
may be called upon the result type.
Custom serializers and deserializers are specified at the dialect level,
that is using :func:`.create_engine`. The reason for this is that when
using psycopg2, the DBAPI only allows serializers at the per-cursor
or per-connection level. E.g.::
engine = create_engine("postgresql://scott:tiger@localhost/test",
json_serializer=my_serialize_fn,
json_deserializer=my_deserialize_fn
)
When using the psycopg2 dialect, the json_deserializer is registered
against the database using ``psycopg2.extras.register_default_json``.
.. seealso::
:class:`.types.JSON` - Core level JSON type
:class:`.JSONB`
"""
astext_type = sqltypes.Text()
def __init__(self, none_as_null=False, astext_type=None):
"""Construct a :class:`.JSON` type.
:param none_as_null: if True, persist the value ``None`` as a
SQL NULL value, not the JSON encoding of ``null``. Note that
when this flag is False, the :func:`.null` construct can still
be used to persist a NULL value::
from sqlalchemy import null
conn.execute(table.insert(), data=null())
.. versionchanged:: 0.9.8 - Added ``none_as_null``, and :func:`.null`
is now supported in order to persist a NULL value.
.. seealso::
:attr:`.JSON.NULL`
:param astext_type: the type to use for the
:attr:`.JSON.Comparator.astext`
accessor on indexed attributes. Defaults to :class:`.types.Text`.
.. versionadded:: 1.1
"""
super(JSON, self).__init__(none_as_null=none_as_null)
if astext_type is not None:
self.astext_type = astext_type
class Comparator(sqltypes.JSON.Comparator):
"""Define comparison operations for :class:`.JSON`."""
@property
def astext(self):
"""On an indexed expression, use the "astext" (e.g. "->>")
conversion when rendered in SQL.
E.g.::
select([data_table.c.data['some key'].astext])
.. seealso::
:meth:`.ColumnElement.cast`
"""
if isinstance(self.expr.right.type, sqltypes.JSON.JSONPathType):
return self.expr.left.operate(
JSONPATH_ASTEXT,
self.expr.right, result_type=self.type.astext_type)
else:
return self.expr.left.operate(
ASTEXT, self.expr.right, result_type=self.type.astext_type)
comparator_factory = Comparator
colspecs[sqltypes.JSON] = JSON
ischema_names['json'] = JSON
class JSONB(JSON):
"""Represent the PostgreSQL JSONB type.
The :class:`.JSONB` type stores arbitrary JSONB format data, e.g.::
data_table = Table('data_table', metadata,
Column('id', Integer, primary_key=True),
Column('data', JSONB)
)
with engine.connect() as conn:
conn.execute(
data_table.insert(),
data = {"key1": "value1", "key2": "value2"}
)
The :class:`.JSONB` type includes all operations provided by
:class:`.JSON`, including the same behaviors for indexing operations.
It also adds additional operators specific to JSONB, including
:meth:`.JSONB.Comparator.has_key`, :meth:`.JSONB.Comparator.has_all`,
:meth:`.JSONB.Comparator.has_any`, :meth:`.JSONB.Comparator.contains`,
and :meth:`.JSONB.Comparator.contained_by`.
Like the :class:`.JSON` type, the :class:`.JSONB` type does not detect
in-place changes when used with the ORM, unless the
:mod:`sqlalchemy.ext.mutable` extension is used.
Custom serializers and deserializers
are shared with the :class:`.JSON` class, using the ``json_serializer``
and ``json_deserializer`` keyword arguments. These must be specified
at the dialect level using :func:`.create_engine`. When using
psycopg2, the serializers are associated with the jsonb type using
``psycopg2.extras.register_default_jsonb`` on a per-connection basis,
in the same way that ``psycopg2.extras.register_default_json`` is used
to register these handlers with the json type.
.. versionadded:: 0.9.7
.. seealso::
:class:`.JSON`
"""
__visit_name__ = 'JSONB'
class Comparator(JSON.Comparator):
"""Define comparison operations for :class:`.JSON`."""
def has_key(self, other):
"""Boolean expression. Test for presence of a key. Note that the
key may be a SQLA expression.
"""
return self.operate(HAS_KEY, other, result_type=sqltypes.Boolean)
def has_all(self, other):
"""Boolean expression. Test for presence of all keys in jsonb
"""
return self.operate(HAS_ALL, other, result_type=sqltypes.Boolean)
def has_any(self, other):
"""Boolean expression. Test for presence of any key in jsonb
"""
return self.operate(HAS_ANY, other, result_type=sqltypes.Boolean)
def contains(self, other, **kwargs):
"""Boolean expression. Test if keys (or array) are a superset
of/contained the keys of the argument jsonb expression.
"""
return self.operate(CONTAINS, other, result_type=sqltypes.Boolean)
def contained_by(self, other):
"""Boolean expression. Test if keys are a proper subset of the
keys of the argument jsonb expression.
"""
return self.operate(
CONTAINED_BY, other, result_type=sqltypes.Boolean)
comparator_factory = Comparator
ischema_names['jsonb'] = JSONB
|
fernandog/Medusa
|
ext/sqlalchemy/dialects/postgresql/json.py
|
Python
|
gpl-3.0
| 9,821 | 0.000204 |
# This file is part of Radicale - CalDAV and CardDAV server
# Copyright © 2008 Nicolas Kandel
# Copyright © 2008 Pascal Halter
# Copyright © 2008-2017 Guillaume Ayoub
# Copyright © 2017-2018 Unrud <unrud@outlook.com>
#
# This library 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 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Radicale. If not, see <http://www.gnu.org/licenses/>.
from http import client
from radicale import httputils, types
from radicale.app.base import ApplicationBase
class ApplicationPartOptions(ApplicationBase):
def do_OPTIONS(self, environ: types.WSGIEnviron, base_prefix: str,
path: str, user: str) -> types.WSGIResponse:
"""Manage OPTIONS request."""
headers = {
"Allow": ", ".join(
name[3:] for name in dir(self) if name.startswith("do_")),
"DAV": httputils.DAV_HEADERS}
return client.OK, headers, None
|
Kozea/Radicale
|
radicale/app/options.py
|
Python
|
gpl-3.0
| 1,395 | 0 |
try:
import unittest2 as unittest # Python2.6
except ImportError:
import unittest
from tests.functional import test_base
@unittest.skipIf(test_base.get_test_server_api() == 1,
"The tag API didn't work at v1 - see frontend issue #927")
class TestTags(test_base.TestBase):
testcase_name = "tag API"
def test_create_delete(self, tag_id="create_tag"):
"""
Create a tag then delete it.
This test is a little contrived, since the tag create/delete
endpoints are only intended for internal use.
"""
# Create a tag
self.assertTrue(self.client.tag.create(tag_id))
# Check that the tag doesn't exist (It has no photos, so it's invisible)
self.assertNotIn(tag_id, [t.id for t in self.client.tags.list()])
# Create a tag on one of the photos
self.photos[0].update(tagsAdd=tag_id)
# Check that the tag now exists
self.assertIn(tag_id, [t.id for t in self.client.tags.list()])
# Delete the tag
self.assertTrue(self.client.tag.delete(tag_id))
# Check that the tag is now gone
self.assertNotIn(tag_id, [t.id for t in self.client.tags.list()])
# Also remove the tag from the photo
self.photos[0].update(tagsRemove=tag_id)
# Create the tag again
self.photos[0].update(tagsAdd=tag_id)
self.assertIn(tag_id, [t.id for t in self.client.tags.list()])
# Delete using the tag object directly
tag = [t for t in self.client.tags.list() if t.id == tag_id][0]
self.assertTrue(tag.delete())
# Check that the tag is now gone
self.assertNotIn(tag_id, [t.id for t in self.client.tags.list()])
# Also remove the tag from the photo
self.photos[0].update(tagsRemove=tag_id)
# TODO: Un-skip and update this tests once there are tag fields
# that can be updated (the owner field cannot be updated).
@unittest.skip("Can't test the tag.update endpoint, "
"since there are no fields that can be updated")
def test_update(self):
""" Test that a tag can be updated """
# Update the tag using the Trovebox class, passing in the tag object
owner = "test1@trovebox.com"
ret_val = self.client.tag.update(self.tags[0], owner=owner)
# Check that the tag is updated
self.tags = self.client.tags.list()
self.assertEqual(self.tags[0].owner, owner)
self.assertEqual(ret_val.owner, owner)
# Update the tag using the Trovebox class, passing in the tag id
owner = "test2@trovebox.com"
ret_val = self.client.tag.update(self.TEST_TAG, owner=owner)
# Check that the tag is updated
self.tags = self.client.tags.list()
self.assertEqual(self.tags[0].owner, owner)
self.assertEqual(ret_val.owner, owner)
# Update the tag using the Tag object directly
owner = "test3@trovebox.com"
ret_val = self.tags[0].update(owner=owner)
# Check that the tag is updated
self.tags = self.client.tags.list()
self.assertEqual(self.tags[0].owner, owner)
self.assertEqual(ret_val.owner, owner)
def test_tag_with_spaces(self):
""" Run test_create_delete using a tag containing spaces """
self.test_create_delete("tag with spaces")
def test_tag_with_slashes(self):
""" Run test_create_delete using a tag containing slashes """
self.test_create_delete("tag/with/slashes")
# TODO: Un-skip this test once issue #919 is resolved -
# tags with double-slashes cannot be deleted
@unittest.skip("Tags with double-slashed cannot be deleted")
def test_tag_with_double_slashes(self):
""" Run test_create_delete using a tag containing double-slashes """
self.test_create_delete("tag//with//double//slashes")
|
photo/openphoto-python
|
tests/functional/test_tags.py
|
Python
|
apache-2.0
| 3,889 | 0.000771 |
from Tkinter import *
import tkMessageBox
from functools import partial
import os
import sys
import hashlib
import gzip
class niUpdater:
def __init__(self, parent):
self.myParent = parent
self.topContainer = Frame(parent)
self.topContainer.pack(side=TOP, expand=1, fill=X, anchor=NW)
self.btmContainer = Frame(parent)
self.btmContainer.pack(side=BOTTOM, expand=1, fill=X, anchor=NW)
path = StringVar()
ver = StringVar()
path.set(myloc + "\\NordInvasion")
ver.set("0.4.9")
entry1 = Entry(self.topContainer, textvariable=path)
entry1.pack(side=LEFT, expand=1, fill=X)
entry2 = Entry(self.topContainer, textvariable=ver, width =7)
entry2.pack(side=LEFT, expand=0)
#------------------ BUTTON #1 ------------------------------------
button_name = "OK"
# command binding
var = StringVar()
self.button1 = Button(self.topContainer, command=lambda: self.buttonPress(entry1.get(),var,entry2.get()))
# event binding -- passing the event as an argument
self.button1.bind("<Return>",
lambda
event :
self.buttonHandler_a(entry1.get(),var)
)
self.button1.configure(text=button_name, width=5)
self.button1.pack(side=LEFT)
self.button1.focus_force() # Put keyboard focus on button1
self.label = Label(self.btmContainer,textvariable=var, width=55, anchor=W, justify=LEFT)
self.label.pack(side=LEFT, expand=1, fill=X)
var.set("Press OK to start")
def writeOut(self,dir,hashfile,toplevel,var,folder):
""" walks a directory, and executes a callback on each file """
dir = os.path.abspath(dir)
for file in [file for file in os.listdir(dir) if not file in [".",".."]]:
nfile = os.path.join(dir,file)
if os.path.isdir(nfile): # is a directory
hashfile.write("F::"+nfile.replace(toplevel,"") + "\n")
hashfile.write("X::\n")
var.set("Generating... " + "F::"+nfile.replace(toplevel,""))
root.update()
if not os.path.exists(folder + '\\' + nfile.replace(toplevel,"")):
os.mkdir(folder + '\\' + nfile.replace(toplevel,""))
self.writeOut(nfile,hashfile,toplevel,var,folder)
else: # is a file
# Generate the hash and add to hash file
h=(hashlib.sha1(open(nfile, 'rb').read()).hexdigest())
hashfile.write(nfile.replace(toplevel,"") + "\n")
var.set("Generating... " + nfile.replace(toplevel,""))
root.update()
hashfile.write(h + "\n")
# Generate a smaller, gzipped version of the file
with open(nfile, 'rb') as f_in:
with gzip.open(folder + '\\' + nfile.replace(toplevel,"") + '.gz', 'wb') as f_out:
f_out.writelines(f_in)
def buttonPress(self, path, var, versionNumber):
self.button1.configure(state=DISABLED)
import time
timestamp = int(time.time())
folderName = (myloc + '\\ni-mod-' + str(timestamp))
if not os.path.exists(folderName):
os.mkdir(folderName)
file = open(myloc + '\\hash.txt','wt')
file.write("V::1\n")
file.write("W::http://nordinvasion.com/mod/" + str(versionNumber) + "/\n")
self.writeOut(path,file,path+'\\',var,folderName)
file.close()
var.set("File Generated")
tkMessageBox.showinfo("NI Hash Gen", "Hash file generated successfully.")
self.button1.configure(state=NORMAL)
def buttonHandler_a(self, path, var):
self.buttonPress(path, var)
pathname = os.path.dirname(sys.argv[0])
myloc = os.path.abspath(pathname)
root = Tk()
niup = niUpdater(root)
root.wm_title("Nord Invasion Hash Generator")
root.mainloop()
|
Naozumi/hashgen
|
ni_hashGen.py
|
Python
|
mit
| 3,412 | 0.036928 |
import copy
import resource
import sys
import traceback
import unittest
import mock
import numpy as np
import sklearn.datasets
import sklearn.decomposition
import sklearn.ensemble
import sklearn.svm
from sklearn.utils.testing import assert_array_almost_equal
from HPOlibConfigSpace.configuration_space import ConfigurationSpace
from HPOlibConfigSpace.hyperparameters import CategoricalHyperparameter
from autosklearn.pipeline.regression import SimpleRegressionPipeline
from autosklearn.pipeline.components.base import \
AutoSklearnPreprocessingAlgorithm, AutoSklearnRegressionAlgorithm
import autosklearn.pipeline.components.regression as regression_components
import autosklearn.pipeline.components.feature_preprocessing as preprocessing_components
from autosklearn.pipeline.util import get_dataset
from autosklearn.pipeline.constants import *
class SimpleRegressionPipelineTest(unittest.TestCase):
_multiprocess_can_split_ = True
def test_io_dict(self):
regressors = regression_components._regressors
for r in regressors:
if regressors[r] == regression_components.RegressorChoice:
continue
props = regressors[r].get_properties()
self.assertIn('input', props)
self.assertIn('output', props)
inp = props['input']
output = props['output']
self.assertIsInstance(inp, tuple)
self.assertIsInstance(output, tuple)
for i in inp:
self.assertIn(i, (SPARSE, DENSE, SIGNED_DATA, UNSIGNED_DATA))
self.assertEqual(output, (PREDICTIONS,))
self.assertIn('handles_regression', props)
self.assertTrue(props['handles_regression'])
self.assertIn('handles_classification', props)
self.assertIn('handles_multiclass', props)
self.assertIn('handles_multilabel', props)
self.assertFalse(props['handles_classification'])
self.assertFalse(props['handles_multiclass'])
self.assertFalse(props['handles_multilabel'])
def test_find_regressors(self):
regressors = regression_components._regressors
self.assertGreaterEqual(len(regressors), 1)
for key in regressors:
if hasattr(regressors[key], 'get_components'):
continue
self.assertIn(AutoSklearnRegressionAlgorithm,
regressors[key].__bases__)
def test_find_preprocessors(self):
preprocessors = preprocessing_components._preprocessors
self.assertGreaterEqual(len(preprocessors), 1)
for key in preprocessors:
if hasattr(preprocessors[key], 'get_components'):
continue
self.assertIn(AutoSklearnPreprocessingAlgorithm,
preprocessors[key].__bases__)
def test_configurations(self):
# Use a limit of ~4GiB
limit = 4000 * 1024 * 1024
resource.setrlimit(resource.RLIMIT_AS, (limit, limit))
cs = SimpleRegressionPipeline.get_hyperparameter_search_space()
print(cs)
cs.seed(1)
for i in range(10):
config = cs.sample_configuration()
config._populate_values()
if config['regressor:sgd:n_iter'] is not None:
config._values['regressor:sgd:n_iter'] = 5
X_train, Y_train, X_test, Y_test = get_dataset(dataset='boston')
cls = SimpleRegressionPipeline(config, random_state=1)
print(config)
try:
cls.fit(X_train, Y_train)
X_test_ = X_test.copy()
predictions = cls.predict(X_test)
self.assertIsInstance(predictions, np.ndarray)
predicted_probabiliets = cls.predict(X_test_)
self.assertIsInstance(predicted_probabiliets, np.ndarray)
except ValueError as e:
if "Floating-point under-/overflow occurred at epoch" in \
e.args[0]:
continue
elif "all features are discarded" in e.args[0]:
continue
elif "removed all features" in e.args[0]:
continue
elif "Bug in scikit-learn:" in e.args[0]:
continue
else:
print(config)
print(traceback.format_exc())
raise e
except RuntimeWarning as e:
if "invalid value encountered in sqrt" in e.args[0]:
continue
elif "divide by zero encountered in" in e.args[0]:
continue
elif "invalid value encountered in divide" in e.args[0]:
continue
elif "invalid value encountered in true_divide" in e.args[0]:
continue
else:
print(config)
print(traceback.format_exc())
raise e
except UserWarning as e:
if "FastICA did not converge" in e.args[0]:
continue
else:
print(config)
print(traceback.format_exc())
raise e
except MemoryError as e:
continue
def test_configurations_signed_data(self):
# Use a limit of ~4GiB
limit = 4000 * 1024 * 1024
resource.setrlimit(resource.RLIMIT_AS, (limit, limit))
cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
dataset_properties={'signed': True})
print(cs)
for i in range(10):
config = cs.sample_configuration()
config._populate_values()
if 'classifier:passive_aggressive:n_iter' in config and \
config[
'classifier:passive_aggressive:n_iter'] is not None:
config._values['classifier:passive_aggressive:n_iter'] = 5
if 'classifier:sgd:n_iter' in config and \
config['classifier:sgd:n_iter'] is not None:
config._values['classifier:sgd:n_iter'] = 5
X_train, Y_train, X_test, Y_test = get_dataset(dataset='boston')
cls = SimpleRegressionPipeline(config, random_state=1)
print(config)
try:
cls.fit(X_train, Y_train)
X_test_ = X_test.copy()
predictions = cls.predict(X_test)
self.assertIsInstance(predictions, np.ndarray)
predicted_probabiliets = cls.predict(X_test_)
self.assertIsInstance(predicted_probabiliets, np.ndarray)
except ValueError as e:
if "Floating-point under-/overflow occurred at epoch" in \
e.args[0] or \
"removed all features" in e.args[0] or \
"all features are discarded" in e.args[0] or \
"Bug in scikit-learn" in e.args[0]:
continue
else:
print(config)
print(traceback.format_exc())
raise e
except RuntimeWarning as e:
if "invalid value encountered in sqrt" in e.args[0]:
continue
elif "divide by zero encountered in" in e.args[0]:
continue
elif "invalid value encountered in divide" in e.args[0]:
continue
elif "invalid value encountered in true_divide" in e.args[0]:
continue
else:
print(config)
print(traceback.format_exc())
raise e
except UserWarning as e:
if "FastICA did not converge" in e.args[0]:
continue
else:
print(config)
print(traceback.format_exc())
raise e
except MemoryError as e:
continue
def test_configurations_sparse(self):
# Use a limit of ~4GiB
limit = 4000 * 1024 * 1024
resource.setrlimit(resource.RLIMIT_AS, (limit, limit))
cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
dataset_properties={'sparse': True})
print(cs)
for i in range(10):
config = cs.sample_configuration()
config._populate_values()
if 'classifier:passive_aggressive:n_iter' in config and \
config[
'classifier:passive_aggressive:n_iter'] is not None:
config._values['classifier:passive_aggressive:n_iter'] = 5
if 'classifier:sgd:n_iter' in config and \
config['classifier:sgd:n_iter'] is not None:
config._values['classifier:sgd:n_iter'] = 5
print(config)
X_train, Y_train, X_test, Y_test = get_dataset(dataset='boston',
make_sparse=True)
cls = SimpleRegressionPipeline(config, random_state=1)
try:
cls.fit(X_train, Y_train)
predictions = cls.predict(X_test)
except ValueError as e:
if "Floating-point under-/overflow occurred at epoch" in \
e.args[0] or \
"removed all features" in e.args[0] or \
"all features are discarded" in e.args[0]:
continue
else:
print(config)
traceback.print_tb(sys.exc_info()[2])
raise e
except RuntimeWarning as e:
if "invalid value encountered in sqrt" in e.args[0]:
continue
elif "divide by zero encountered in" in e.args[0]:
continue
elif "invalid value encountered in divide" in e.args[0]:
continue
elif "invalid value encountered in true_divide" in e.args[0]:
continue
else:
print(config)
raise e
except UserWarning as e:
if "FastICA did not converge" in e.args[0]:
continue
else:
print(config)
raise e
def test_default_configuration(self):
for i in range(2):
cs = SimpleRegressionPipeline.get_hyperparameter_search_space()
default = cs.get_default_configuration()
X_train, Y_train, X_test, Y_test = get_dataset(dataset='diabetes')
auto = SimpleRegressionPipeline(default)
auto = auto.fit(X_train, Y_train)
predictions = auto.predict(copy.deepcopy(X_test))
# The lower the worse
r2_score = sklearn.metrics.r2_score(Y_test, predictions)
self.assertAlmostEqual(0.41626416529791199, r2_score)
model_score = auto.score(copy.deepcopy(X_test), Y_test)
self.assertEqual(model_score, r2_score)
def test_repr(self):
cs = SimpleRegressionPipeline.get_hyperparameter_search_space()
default = cs.get_default_configuration()
representation = repr(SimpleRegressionPipeline(default))
cls = eval(representation)
self.assertIsInstance(cls, SimpleRegressionPipeline)
def test_get_hyperparameter_search_space(self):
cs = SimpleRegressionPipeline.get_hyperparameter_search_space()
self.assertIsInstance(cs, ConfigurationSpace)
conditions = cs.get_conditions()
hyperparameters = cs.get_hyperparameters()
self.assertEqual(130, len(hyperparameters))
self.assertEqual(len(hyperparameters) - 5, len(conditions))
def test_get_hyperparameter_search_space_include_exclude_models(self):
cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
include={'regressor': ['random_forest']})
self.assertEqual(cs.get_hyperparameter('regressor:__choice__'),
CategoricalHyperparameter('regressor:__choice__', ['random_forest']))
# TODO add this test when more than one regressor is present
cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
exclude={'regressor': ['random_forest']})
self.assertNotIn('random_forest', str(cs))
cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
include={'preprocessor': ['pca']})
self.assertEqual(cs.get_hyperparameter('preprocessor:__choice__'),
CategoricalHyperparameter('preprocessor:__choice__', ['pca']))
cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
exclude={'preprocessor': ['no_preprocessing']})
self.assertNotIn('no_preprocessing', str(cs))
def test_get_hyperparameter_search_space_preprocessor_contradicts_default_classifier(
self):
cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
include={'preprocessor': ['densifier']},
dataset_properties={'sparse': True})
self.assertEqual(cs.get_hyperparameter('regressor:__choice__').default,
'gradient_boosting')
cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
include={'preprocessor': ['nystroem_sampler']})
self.assertEqual(cs.get_hyperparameter('regressor:__choice__').default,
'sgd')
def test_get_hyperparameter_search_space_only_forbidden_combinations(self):
self.assertRaisesRegexp(ValueError, "Cannot find a legal default "
"configuration.",
SimpleRegressionPipeline.get_hyperparameter_search_space,
include={'regressor': ['random_forest'],
'preprocessor': ['kitchen_sinks']})
# It must also be catched that no classifiers which can handle sparse
# data are located behind the densifier
self.assertRaisesRegexp(ValueError, "Cannot find a legal default "
"configuration",
SimpleRegressionPipeline.get_hyperparameter_search_space,
include={'regressor': ['ridge_regression'],
'preprocessor': ['densifier']},
dataset_properties={'sparse': True})
@unittest.skip("test_get_hyperparameter_search_space_dataset_properties" +
" Not yet Implemented")
def test_get_hyperparameter_search_space_dataset_properties(self):
# TODO: We do not have any dataset properties for regression, so this
# test is somewhat stupid
pass
"""
full_cs = SimpleRegressionPipeline.get_hyperparameter_search_space()
cs_mc = SimpleRegressionPipeline.get_hyperparameter_search_space()
self.assertEqual(full_cs, cs_mc)
cs_ml = SimpleRegressionPipeline.get_hyperparameter_search_space()
self.assertNotIn('k_nearest_neighbors', str(cs_ml))
self.assertNotIn('liblinear', str(cs_ml))
self.assertNotIn('libsvm_svc', str(cs_ml))
self.assertNotIn('sgd', str(cs_ml))
cs_sp = SimpleRegressionPipeline.get_hyperparameter_search_space(
sparse=True)
self.assertNotIn('extra_trees', str(cs_sp))
self.assertNotIn('gradient_boosting', str(cs_sp))
self.assertNotIn('random_forest', str(cs_sp))
cs_mc_ml = SimpleRegressionPipeline.get_hyperparameter_search_space()
self.assertEqual(cs_ml, cs_mc_ml)
self.assertRaisesRegexp(ValueError,
"No regressor to build a configuration space "
"for...", SimpleRegressionPipeline.
get_hyperparameter_search_space,
multiclass=True, multilabel=True, sparse=True)
"""
def test_predict_batched(self):
cs = SimpleRegressionPipeline.get_hyperparameter_search_space()
default = cs.get_default_configuration()
cls = SimpleRegressionPipeline(default)
X_train, Y_train, X_test, Y_test = get_dataset(dataset='boston')
cls.fit(X_train, Y_train)
X_test_ = X_test.copy()
prediction_ = cls.predict(X_test_)
cls_predict = mock.Mock(wraps=cls.pipeline_)
cls.pipeline_ = cls_predict
prediction = cls.predict(X_test, batch_size=20)
self.assertEqual((356,), prediction.shape)
self.assertEqual(18, cls_predict.predict.call_count)
assert_array_almost_equal(prediction_, prediction)
def test_predict_batched_sparse(self):
cs = SimpleRegressionPipeline.get_hyperparameter_search_space(
dataset_properties={'sparse': True})
default = cs.get_default_configuration()
cls = SimpleRegressionPipeline(default)
X_train, Y_train, X_test, Y_test = get_dataset(dataset='boston',
make_sparse=True)
cls.fit(X_train, Y_train)
X_test_ = X_test.copy()
prediction_ = cls.predict(X_test_)
cls_predict = mock.Mock(wraps=cls.pipeline_)
cls.pipeline_ = cls_predict
prediction = cls.predict(X_test, batch_size=20)
self.assertEqual((356,), prediction.shape)
self.assertEqual(18, cls_predict.predict.call_count)
assert_array_almost_equal(prediction_, prediction)
@unittest.skip("test_check_random_state Not yet Implemented")
def test_check_random_state(self):
raise NotImplementedError()
@unittest.skip("test_validate_input_X Not yet Implemented")
def test_validate_input_X(self):
raise NotImplementedError()
@unittest.skip("test_validate_input_Y Not yet Implemented")
def test_validate_input_Y(self):
raise NotImplementedError()
def test_set_params(self):
pass
def test_get_params(self):
pass
|
hmendozap/auto-sklearn
|
test/test_pipeline/test_regression.py
|
Python
|
bsd-3-clause
| 18,360 | 0.000926 |
import os
import ycm_core
flags = [
'-Wall',
'-Wextra',
'-Werror',
'-pedantic',
'-std=c++1y',
#'-stdlib=libc++',
'-x',
'c++',
'-Iinclude',
'-Itest/include',
'-Ilib/jest/include',
'-isystem',
'../BoostParts',
'-isystem',
'/System/Library/Frameworks/Python.framework/Headers',
'-isystem',
'../llvm/include',
'-isystem',
'../llvm/tools/clang/include',
'-I',
'.',
'-I',
'./ClangCompleter',
'-isystem',
'./tests/gmock/gtest',
'-isystem',
'./tests/gmock/gtest/include',
'-isystem',
'./tests/gmock',
'-isystem',
'./tests/gmock/include',
'-isystem',
'/usr/include',
'-isystem',
'/usr/local/include',
'-isystem',
'/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/c++/v1',
'-isystem',
'/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include',
]
compilation_database_folder = ''
if os.path.exists( compilation_database_folder ):
database = ycm_core.CompilationDatabase( compilation_database_folder )
else:
database = None
SOURCE_EXTENSIONS = [ '.cpp', '.cxx', '.cc', '.c', '.m', '.mm' ]
def DirectoryOfThisScript():
return os.path.dirname( os.path.abspath( __file__ ) )
def MakeRelativePathsInFlagsAbsolute( flags, working_directory ):
if not working_directory:
return list( flags )
new_flags = []
make_next_absolute = False
path_flags = [ '-isystem', '-I', '-iquote', '--sysroot=' ]
for flag in flags:
new_flag = flag
if make_next_absolute:
make_next_absolute = False
if not flag.startswith( '/' ):
new_flag = os.path.join( working_directory, flag )
for path_flag in path_flags:
if flag == path_flag:
make_next_absolute = True
break
if flag.startswith( path_flag ):
path = flag[ len( path_flag ): ]
new_flag = path_flag + os.path.join( working_directory, path )
break
if new_flag:
new_flags.append( new_flag )
return new_flags
def IsHeaderFile( filename ):
extension = os.path.splitext( filename )[ 1 ]
return extension in [ '.h', '.hxx', '.hpp', '.hh' ]
def GetCompilationInfoForFile( filename ):
if IsHeaderFile( filename ):
basename = os.path.splitext( filename )[ 0 ]
for extension in SOURCE_EXTENSIONS:
replacement_file = basename + extension
if os.path.exists( replacement_file ):
compilation_info = database.GetCompilationInfoForFile(
replacement_file )
if compilation_info.compiler_flags_:
return compilation_info
return None
return database.GetCompilationInfoForFile( filename )
def FlagsForFile( filename, **kwargs ):
if database:
compilation_info = GetCompilationInfoForFile( filename )
if not compilation_info:
return None
final_flags = MakeRelativePathsInFlagsAbsolute(
compilation_info.compiler_flags_,
compilation_info.compiler_working_dir_ )
else:
relative_to = DirectoryOfThisScript()
final_flags = MakeRelativePathsInFlagsAbsolute( flags, relative_to )
return {
'flags': final_flags,
'do_cache': True
}
|
jeaye/jeayeson
|
.ycm_extra_conf.py
|
Python
|
bsd-3-clause
| 3,051 | 0.041298 |
from __future__ import absolute_import
import numpy as np
import conf
from time import sleep
from functools import reduce
from hardware.robot.modules.motor_math import get_triangular_direction_vector
from hardware.robot.modules.com import send_encoder_steps_and_speed
##
## This is the code that instructs how to get from A to B
## using continual approximation and gradient descent
##
## Motors that have requested to move to the next step
## Only executes when all are true
## Motors have been assigned IDs which will then be
## Used to index motors_requested
## instructions has the following format per line:
## [CAN_NUMBER, X, Y]
instructions = np.genfromtxt('hardware/robot/image.tsv', delimiter='\t')
motors_requested = [True, True]
last_instruction_index = -1
current_instruction_index = 1
last_instruction = [1, 0, 0]
current_instruction = [1, 0, 0]
def check_all_requested():
## Returns true if all motors_requested values are true
return reduce(lambda x, y: x and y, motors_requested)
## TODO: Integrate sensor data to complete this function
def position_is_close_enough_to_goal():
return True
def gen_next_instruction():
global current_instruction_index
global current_instruction
global last_instruction_index
global last_instruction
last_instruction, last_instruction_index = current_instruction, current_instruction_index
current_instruction_index = current_instruction_index + 1
current_instruction = instructions[current_instruction_index]
while current_instruction[1] == -1:
current_instruction_index = current_instruction_index + 1
current_instruction = instructions[current_instruction_index]
return current_instruction, current_instruction_index, last_instruction, last_instruction_index
##TODO: CHECK FOR LABEL CHANGES
def request_step(motor_id):
global current_instruction_index
global current_instruction
global last_instruction_index
global last_instruction
if motor_id < len(motors_requested):
motors_requested[motor_id] = True
if check_all_requested() and position_is_close_enough_to_goal():
# print("pass" + str(current_instruction_index))
gen_next_instruction()
print("INSTRUCTION NUMBER: " + str(current_instruction_index))
from_x, from_y = last_instruction[1], last_instruction[2]
goal_x, goal_y = current_instruction[1], current_instruction[2]
turn_steps = get_triangular_direction_vector(
from_x,
from_y,
goal_x,
goal_y,
)
print("MOVEMENT VECTORS")
print((from_x, from_y), (goal_x, goal_y))
print("STEPS TO TURN (LEFT, RIGHT) MOTORS")
print(turn_steps)
left_steps = turn_steps[0]
right_steps = turn_steps[1]
max_steps = max(abs(left_steps), abs(right_steps))
##TODO: Turn into an async send_turn_ratio if problems arise
if conf.LMOTOR_IP != '0.0.0.0':
send_encoder_steps_and_speed(conf.LMOTOR_IP, left_steps, left_steps/max_steps)
if conf.RMOTOR_IP != '0.0.0.0':
send_encoder_steps_and_speed(conf.RMOTOR_IP, right_steps, right_steps/max_steps)
|
ut-ras/robotticelli
|
src/hardware/robot/run-real.py
|
Python
|
lgpl-3.0
| 3,189 | 0.007839 |
# -*- coding: utf-8 -*-
from module.plugins.internal.DeadHoster import DeadHoster
class CyberlockerCh(DeadHoster):
__name__ = "CyberlockerCh"
__type__ = "hoster"
__version__ = "0.06"
__status__ = "stable"
__pattern__ = r'http://(?:www\.)?cyberlocker\.ch/\w+'
__config__ = [] #@TODO: Remove in 0.4.10
__description__ = """Cyberlocker.ch hoster plugin"""
__license__ = "GPLv3"
__authors__ = [("stickell", "l.stickell@yahoo.it")]
|
manuelm/pyload
|
module/plugins/hoster/CyberlockerCh.py
|
Python
|
gpl-3.0
| 485 | 0.014433 |
'''
A secret file with data that we can use in unit tests without needing to
clutter up that file with a bunch of raw data structures.
'''
from datetime import datetime
SEARCH_TEST_DATA = [
{
"created" : datetime(2015, 10, 1),
"published": datetime(2015, 10, 1),
"edited": datetime(2015, 10, 1),
"rendered": None,
"author": "bgporter",
"public": True,
"status": "published",
"title": "First Post",
"slug": "",
"text": "a bunch of words #foo #bar",
"tags": [],
"type": "Post"
},
{
"created" : datetime(2015, 10, 2),
"published": datetime(2015, 10, 2),
"edited": datetime(2015, 10, 1),
"rendered": None,
"author": "bgporter",
"public": False,
"title": "Second Post",
"status": "published",
"slug": "",
"text": "a bunch more words #foo #baz",
"tags": [],
"type": "Post"
},
{
"created" : datetime(2015, 10, 3),
"published": datetime(2015, 10, 3),
"edited": datetime(2015, 10, 1),
"rendered": None,
"author": "tslothrop",
"public": True,
"title": "Third Post",
"status": "published",
"slug": "",
"text": "a bunch #baz more #bar words",
"tags": [],
"type": "Post"
}
]
|
bgporter/wastebook
|
testData/postTestData.py
|
Python
|
mit
| 1,496 | 0.004679 |
# Projection 1D2D
# Project triangles from one meshed face to another mesh on the same box
import salome
salome.salome_init()
import GEOM
from salome.geom import geomBuilder
geompy = geomBuilder.New(salome.myStudy)
import SMESH, SALOMEDS
from salome.smesh import smeshBuilder
smesh = smeshBuilder.New(salome.myStudy)
# Prepare geometry
# Create a box
box = geompy.MakeBoxDXDYDZ(100, 100, 100)
# Get geom faces to mesh with triangles in the 1ts and 2nd meshes
faces = geompy.SubShapeAll(box, geompy.ShapeType["FACE"])
# 2 adjacent faces of the box
Face_1 = faces[2]
Face_2 = faces[0]
geompy.addToStudy( box, 'box' )
geompy.addToStudyInFather( box, Face_1, 'Face_1' )
geompy.addToStudyInFather( box, Face_2, 'Face_2' )
# Make the source mesh with Netgem2D
src_mesh = smesh.Mesh(Face_1, "Source mesh")
src_mesh.Segment().NumberOfSegments(15)
src_mesh.Triangle()
src_mesh.Compute()
# Mesh the target mesh using the algoritm Projection1D2D
tgt_mesh = smesh.Mesh(Face_2, "Target mesh")
tgt_mesh.Projection1D2D().SourceFace(Face_1,src_mesh)
tgt_mesh.Compute()
|
FedoraScientific/salome-smesh
|
doc/salome/examples/defining_hypotheses_ex11.py
|
Python
|
lgpl-2.1
| 1,063 | 0.01223 |
# From CPython 2.5.1
import sys
import os
import unittest
from array import array
from weakref import proxy
from test.test_support import TESTFN, findfile, is_jython, run_unittest
from UserList import UserList
class AutoFileTests(unittest.TestCase):
# file tests for which a test file is automatically set up
def setUp(self):
self.f = open(TESTFN, 'wb')
def tearDown(self):
if self.f:
self.f.close()
os.remove(TESTFN)
def testWeakRefs(self):
# verify weak references
p = proxy(self.f)
p.write('teststring')
self.assertEquals(self.f.tell(), p.tell())
self.f.close()
self.f = None
if is_jython:
from test_weakref import extra_collect
extra_collect()
self.assertRaises(ReferenceError, getattr, p, 'tell')
def testAttributes(self):
# verify expected attributes exist
f = self.f
softspace = f.softspace
f.name # merely shouldn't blow up
f.mode # ditto
f.closed # ditto
# verify softspace is writable
f.softspace = softspace # merely shouldn't blow up
# verify the others aren't
for attr in 'name', 'mode', 'closed':
self.assertRaises((AttributeError, TypeError), setattr, f, attr, 'oops')
def testReadinto(self):
# verify readinto
self.f.write('12')
self.f.close()
a = array('c', 'x'*10)
self.f = open(TESTFN, 'rb')
n = self.f.readinto(a)
self.assertEquals('12', a.tostring()[:n])
def testWritelinesUserList(self):
# verify writelines with instance sequence
l = UserList(['1', '2'])
self.f.writelines(l)
self.f.close()
self.f = open(TESTFN, 'rb')
buf = self.f.read()
self.assertEquals(buf, '12')
def testWritelinesIntegers(self):
# verify writelines with integers
self.assertRaises(TypeError, self.f.writelines, [1, 2, 3])
def testWritelinesIntegersUserList(self):
# verify writelines with integers in UserList
l = UserList([1,2,3])
self.assertRaises(TypeError, self.f.writelines, l)
def testWritelinesNonString(self):
# verify writelines with non-string object
class NonString:
pass
self.assertRaises(TypeError, self.f.writelines,
[NonString(), NonString()])
def testRepr(self):
# verify repr works
self.assert_(repr(self.f).startswith("<open file '" + TESTFN))
def testErrors(self):
f = self.f
self.assertEquals(f.name, TESTFN)
# XXX: Jython doesn't support isatty
#self.assert_(not f.isatty())
self.assert_(not f.closed)
self.assertRaises(TypeError, f.readinto, "")
f.close()
self.assert_(f.closed)
def testMethods(self):
# XXX: Jython file methods require valid arguments: closed file
# checks are done before parsing the arguments in CPython
#methods = ['next', 'read', 'readinto',
# 'readline', 'readlines', 'seek', 'tell', 'truncate',
# 'write', 'xreadlines', '__iter__']
noarg = object()
# XXX: Jython doesn't support isatty
#methods = dict(fileno=noarg, flush=noarg, isatty=noarg, next=noarg,
methods = dict(fileno=noarg, flush=noarg, next=noarg,
read=-1, readinto=array('c', 'x'), readline=-1,
readlines=noarg, seek=0, tell=noarg, truncate=0,
write='x', xreadlines=noarg, __iter__=noarg)
if sys.platform.startswith('atheos'):
methods.remove('truncate')
# __exit__ should close the file
self.f.__exit__(None, None, None)
self.assert_(self.f.closed)
for methodname, arg in methods.iteritems():
method = getattr(self.f, methodname)
# should raise on closed file
if arg is noarg:
self.assertRaises(ValueError, method)
else:
self.assertRaises(ValueError, method, arg)
self.assertRaises(ValueError, self.f.writelines, [])
# file is closed, __exit__ shouldn't do anything
self.assertEquals(self.f.__exit__(None, None, None), None)
# it must also return None if an exception was given
try:
1/0
except:
self.assertEquals(self.f.__exit__(*sys.exc_info()), None)
class OtherFileTests(unittest.TestCase):
def testModeStrings(self):
# check invalid mode strings
for mode in ("", "aU", "wU+"):
try:
f = open(TESTFN, mode)
except ValueError:
pass
else:
f.close()
self.fail('%r is an invalid file mode' % mode)
def testStdin(self):
# This causes the interpreter to exit on OSF1 v5.1.
if sys.platform != 'osf1V5':
self.assertRaises(IOError, sys.stdin.seek, -1)
else:
print >>sys.__stdout__, (
' Skipping sys.stdin.seek(-1), it may crash the interpreter.'
' Test manually.')
self.assertRaises(IOError, sys.stdin.truncate)
def testUnicodeOpen(self):
# verify repr works for unicode too
f = open(unicode(TESTFN), "w")
self.assert_(repr(f).startswith("<open file u'" + TESTFN))
f.close()
os.unlink(TESTFN)
def testBadModeArgument(self):
# verify that we get a sensible error message for bad mode argument
bad_mode = "qwerty"
try:
f = open(TESTFN, bad_mode)
except ValueError, msg:
if msg[0] != 0:
s = str(msg)
if s.find(TESTFN) != -1 or s.find(bad_mode) == -1:
self.fail("bad error message for invalid mode: %s" % s)
# if msg[0] == 0, we're probably on Windows where there may be
# no obvious way to discover why open() failed.
else:
f.close()
self.fail("no error for invalid mode: %s" % bad_mode)
def testSetBufferSize(self):
# make sure that explicitly setting the buffer size doesn't cause
# misbehaviour especially with repeated close() calls
for s in (-1, 0, 1, 512):
try:
f = open(TESTFN, 'w', s)
f.write(str(s))
f.close()
f.close()
f = open(TESTFN, 'r', s)
d = int(f.read())
f.close()
f.close()
except IOError, msg:
self.fail('error setting buffer size %d: %s' % (s, str(msg)))
self.assertEquals(d, s)
def testTruncateOnWindows(self):
os.unlink(TESTFN)
def bug801631():
# SF bug <http://www.python.org/sf/801631>
# "file.truncate fault on windows"
f = open(TESTFN, 'wb')
f.write('12345678901') # 11 bytes
f.close()
f = open(TESTFN,'rb+')
data = f.read(5)
if data != '12345':
self.fail("Read on file opened for update failed %r" % data)
if f.tell() != 5:
self.fail("File pos after read wrong %d" % f.tell())
f.truncate()
if f.tell() != 5:
self.fail("File pos after ftruncate wrong %d" % f.tell())
f.close()
size = os.path.getsize(TESTFN)
if size != 5:
self.fail("File size after ftruncate wrong %d" % size)
try:
bug801631()
finally:
os.unlink(TESTFN)
def testIteration(self):
# Test the complex interaction when mixing file-iteration and the
# various read* methods. Ostensibly, the mixture could just be tested
# to work when it should work according to the Python language,
# instead of fail when it should fail according to the current CPython
# implementation. People don't always program Python the way they
# should, though, and the implemenation might change in subtle ways,
# so we explicitly test for errors, too; the test will just have to
# be updated when the implementation changes.
dataoffset = 16384
filler = "ham\n"
assert not dataoffset % len(filler), \
"dataoffset must be multiple of len(filler)"
nchunks = dataoffset // len(filler)
testlines = [
"spam, spam and eggs\n",
"eggs, spam, ham and spam\n",
"saussages, spam, spam and eggs\n",
"spam, ham, spam and eggs\n",
"spam, spam, spam, spam, spam, ham, spam\n",
"wonderful spaaaaaam.\n"
]
methods = [("readline", ()), ("read", ()), ("readlines", ()),
("readinto", (array("c", " "*100),))]
try:
# Prepare the testfile
bag = open(TESTFN, "w")
bag.write(filler * nchunks)
bag.writelines(testlines)
bag.close()
# Test for appropriate errors mixing read* and iteration
for methodname, args in methods:
f = open(TESTFN)
if f.next() != filler:
self.fail, "Broken testfile"
meth = getattr(f, methodname)
try:
meth(*args)
except ValueError:
pass
else:
self.fail("%s%r after next() didn't raise ValueError" %
(methodname, args))
f.close()
# Test to see if harmless (by accident) mixing of read* and
# iteration still works. This depends on the size of the internal
# iteration buffer (currently 8192,) but we can test it in a
# flexible manner. Each line in the bag o' ham is 4 bytes
# ("h", "a", "m", "\n"), so 4096 lines of that should get us
# exactly on the buffer boundary for any power-of-2 buffersize
# between 4 and 16384 (inclusive).
f = open(TESTFN)
for i in range(nchunks):
f.next()
testline = testlines.pop(0)
try:
line = f.readline()
except ValueError:
self.fail("readline() after next() with supposedly empty "
"iteration-buffer failed anyway")
if line != testline:
self.fail("readline() after next() with empty buffer "
"failed. Got %r, expected %r" % (line, testline))
testline = testlines.pop(0)
buf = array("c", "\x00" * len(testline))
try:
f.readinto(buf)
except ValueError:
self.fail("readinto() after next() with supposedly empty "
"iteration-buffer failed anyway")
line = buf.tostring()
if line != testline:
self.fail("readinto() after next() with empty buffer "
"failed. Got %r, expected %r" % (line, testline))
testline = testlines.pop(0)
try:
line = f.read(len(testline))
except ValueError:
self.fail("read() after next() with supposedly empty "
"iteration-buffer failed anyway")
if line != testline:
self.fail("read() after next() with empty buffer "
"failed. Got %r, expected %r" % (line, testline))
try:
lines = f.readlines()
except ValueError:
self.fail("readlines() after next() with supposedly empty "
"iteration-buffer failed anyway")
if lines != testlines:
self.fail("readlines() after next() with empty buffer "
"failed. Got %r, expected %r" % (line, testline))
# Reading after iteration hit EOF shouldn't hurt either
f = open(TESTFN)
try:
for line in f:
pass
try:
f.readline()
f.readinto(buf)
f.read()
f.readlines()
except ValueError:
self.fail("read* failed after next() consumed file")
finally:
f.close()
finally:
os.unlink(TESTFN)
def test_main():
if is_jython:
# Jython's stdin can't seek, it's not backed by a
# RandomAccessFile
del OtherFileTests.testStdin
# Jython allows mixing reads with iteration
del OtherFileTests.testIteration
# Historically, these tests have been sloppy about removing TESTFN.
# So get rid of it no matter what.
try:
run_unittest(AutoFileTests, OtherFileTests)
finally:
if os.path.exists(TESTFN):
os.unlink(TESTFN)
if __name__ == '__main__':
test_main()
|
babble/babble
|
include/jython/Lib/test/test_file.py
|
Python
|
apache-2.0
| 13,201 | 0.000985 |
import os
import logging
from pdb import pm
from elfesteem import pe
from miasm2.analysis.sandbox import Sandbox_Win_x86_32
from miasm2.core import asmbloc
filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
execfile(filename)
# User defined methods
def kernel32_GetProcAddress(jitter):
ret_ad, args = jitter.func_args_stdcall(["libbase", "fname"])
dst_ad = jitter.cpu.EBX
logging.info('EBX ' + hex(dst_ad))
fname = (args.fname if args.fname < 0x10000
else jitter.get_str_ansi(args.fname))
logging.info(fname)
ad = sb.libs.lib_get_add_func(args.libbase, fname, dst_ad)
jitter.func_ret_stdcall(ret_ad, ad)
parser = Sandbox_Win_x86_32.parser(description="Generic UPX unpacker")
parser.add_argument("filename", help="PE Filename")
parser.add_argument('-v', "--verbose",
help="verbose mode", action="store_true")
parser.add_argument("--graph",
help="Export the CFG graph in graph.txt",
action="store_true")
options = parser.parse_args()
sb = Sandbox_Win_x86_32(options.filename, options, globals())
if options.verbose is True:
logging.basicConfig(level=logging.INFO)
else:
logging.basicConfig(level=logging.WARNING)
if options.verbose is True:
print sb.jitter.vm
ep = sb.entry_point
# Ensure there is one and only one leave (for OEP discovering)
mdis = sb.machine.dis_engine(sb.jitter.bs)
mdis.dont_dis_nulstart_bloc = True
ab = mdis.dis_multibloc(ep)
bb = asmbloc.basicblocs(ab)
leaves = bb.get_bad_dst()
assert(len(leaves) == 1)
l = leaves.pop()
logging.info(l)
end_label = l.label.offset
logging.info('final label')
logging.info(end_label)
# Export CFG graph (dot format)
if options.graph is True:
g = asmbloc.bloc2graph(ab)
open("graph.txt", "w").write(g)
if options.verbose is True:
print sb.jitter.vm
def update_binary(jitter):
sb.pe.Opthdr.AddressOfEntryPoint = sb.pe.virt2rva(jitter.pc)
logging.info('updating binary')
for s in sb.pe.SHList:
sdata = sb.jitter.vm.get_mem(sb.pe.rva2virt(s.addr), s.rawsize)
sb.pe.virt[sb.pe.rva2virt(s.addr)] = sdata
# Set callbacks
sb.jitter.add_breakpoint(end_label, update_binary)
# Run
sb.run()
# Rebuild PE
new_dll = []
sb.pe.SHList.align_sections(0x1000, 0x1000)
logging.info(repr(sb.pe.SHList))
sb.pe.DirRes = pe.DirRes(sb.pe)
sb.pe.DirImport.impdesc = None
logging.info(repr(sb.pe.DirImport.impdesc))
new_dll = sb.libs.gen_new_lib(sb.pe)
logging.info(new_dll)
sb.pe.DirImport.impdesc = []
sb.pe.DirImport.add_dlldesc(new_dll)
s_myimp = sb.pe.SHList.add_section(name="myimp", rawsize=len(sb.pe.DirImport))
logging.info(repr(sb.pe.SHList))
sb.pe.DirImport.set_rva(s_myimp.addr)
# XXXX TODO
sb.pe.NThdr.optentries[pe.DIRECTORY_ENTRY_DELAY_IMPORT].rva = 0
sb.pe.Opthdr.AddressOfEntryPoint = sb.pe.virt2rva(end_label)
bname, fname = os.path.split(options.filename)
fname = os.path.join(bname, fname.replace('.', '_'))
open(fname + '_unupx.bin', 'w').write(str(sb.pe))
|
amohanta/miasm
|
example/jitter/unpack_upx.py
|
Python
|
gpl-2.0
| 3,028 | 0.000661 |
"""
Extensible permission system for pybbm
"""
from django.db.models import Q
from pybb import defaults
from pybb.models import Topic, PollAnswerUser
from pybb.permissions import DefaultPermissionHandler
class CustomPermissionHandler(DefaultPermissionHandler):
"""
Custom Permission handler for PyBB.
Inherits from DefaultPermissionHandler.
Methods starting with `may` are expected to return `True` or `False`,
whereas methods starting with `filter_*` should filter the queryset they
receive, and return a new queryset containing only the objects the user is
allowed to see.
Activated by setting `settings.PYBB_PERMISSION_HANDLER`.
"""
#
# permission checks on categories
#
def filter_categories(self, user, qs):
""" return a queryset with categories `user` is allowed to see """
if not user.is_authenticated:
return qs.exclude()
return qs.filter(hidden=False) if not user.is_staff else qs
def may_view_category(self, user, category):
""" return True if `user` may view this category, False if not """
return user.is_staff or (user.is_authenticated and not category.hidden)
#
# permission checks on forums
#
def filter_forums(self, user, qs):
""" return a queryset with forums `user` is allowed to see """
return qs.filter(Q(hidden=False) & Q(category__hidden=False))\
if not user.is_staff else qs
def may_view_forum(self, user, forum):
""" return True if user may view this forum, False if not """
return (user.is_staff or
(user.is_authenticated and forum.hidden is False and
forum.category.hidden is False))
def may_create_topic(self, user, forum):
""" return True if `user` is allowed to create a new topic in `forum`
"""
return user.is_authenticated and user.has_perm('pybb.add_post')
#
# permission checks on topics
#
def filter_topics(self, user, qs):
""" return a queryset with topics `user` is allowed to see """
if not user.is_staff:
qs = qs.filter(
Q(forum__hidden=False) & Q(forum__category__hidden=False))
if not user.is_superuser:
if user.is_authenticated:
qs = qs.filter(
Q(forum__moderators=user) | Q(user=user) |
Q(on_moderation=False)
).distinct()
else:
qs = qs.filter(on_moderation=False)
return qs
def may_view_topic(self, user, topic):
""" return True if user may view this topic, False otherwise """
if not user.is_authenticated:
return False
if user.is_superuser:
return True
if not user.is_staff and (
topic.forum.hidden or topic.forum.category.hidden):
return False # only staff may see hidden forum / category
if topic.on_moderation:
return user.is_authenticated and (
user == topic.user or user in topic.forum.moderators)
return True
def may_vote_in_topic(self, user, topic):
""" return True if `user` may vote in `topic` """
return (
user.is_authenticated and
topic.poll_type != Topic.POLL_TYPE_NONE and
not topic.closed and
not PollAnswerUser.objects.filter(
poll_answer__topic=topic, user=user).exists()
)
def may_create_post(self, user, topic):
"""Return True if `user` is allowed to create a new post in `topic`"""
if topic.forum.hidden and (not user.is_staff):
# if topic is hidden, only staff may post
return False
if topic.closed and (not user.is_superuser):
# if topic is closed, only staff may post
return False
# only user which have 'pybb.add_post' permission may post
return (defaults.PYBB_ENABLE_ANONYMOUS_POST or
(user.is_authenticated and user.has_perm('pybb.add_post')))
def may_post_as_admin(self, user):
""" return True if `user` may post as admin """
return user.is_superuser
#
# permission checks on posts
#
def filter_posts(self, user, qs):
""" return a queryset with posts `user` is allowed to see """
# first filter by topic availability
if not user.is_superuser:
qs = qs.filter(
Q(topic__forum__hidden=False) &
Q(topic__forum__category__hidden=False))
if not defaults.PYBB_PREMODERATION or user.is_superuser:
# superuser may see all posts, also if premoderation is turned off
# moderation flag is ignored
return qs
elif user.is_authenticated:
# post is visible if user is author, post is not on moderation, or
# user is moderator for this forum
qs = qs.filter(
Q(user=user) | Q(on_moderation=False) |
Q(topic__forum__moderators=user))
else:
# anonymous user may not see posts which are on moderation
qs = qs.filter(on_moderation=False)
return qs
def may_view_post(self, user, post):
""" return True if `user` may view `post`, False otherwise """
if not user.is_authenticated:
return False
if user.is_superuser:
return True
if post.on_moderation:
return post.user == user or\
user in post.topic.forum.moderators.all()
return True
def may_edit_post(self, user, post):
""" return True if `user` may edit `post` """
return user.is_superuser or\
post.user == user or self.may_moderate_topic(user, post.topic)
def may_delete_post(self, user, post):
""" return True if `user` may delete `post` """
return self.may_moderate_topic(user, post.topic)
#
# permission checks on users
#
def may_block_user(self, user, user_to_block):
""" return True if `user` may block `user_to_block` """
return user.has_perm('pybb.block_users')
def may_attach_files(self, user):
"""
return True if `user` may attach files to posts, False otherwise.
By default controlled by PYBB_ATTACHMENT_ENABLE setting
"""
return defaults.PYBB_ATTACHMENT_ENABLE and user.is_authenticated
def may_create_poll(self, user):
"""
return True if `user` may attach files to posts, False otherwise.
By default always True
"""
return user.is_authenticated
|
ugoertz/django-familio
|
accounts/permissions.py
|
Python
|
bsd-3-clause
| 6,670 | 0 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# feeluown documentation build configuration file, created by
# sphinx-quickstart on Fri Oct 2 20:55:54 2015.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
import shlex
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('../../src'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.viewcode',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'feeluown'
copyright = '2015, cosven'
author = 'cosven'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '1.0'
# The full version, including alpha/beta/rc tags.
release = '4.0'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = 'cn'
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = []
# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'alabaster'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr'
#html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# Now only 'ja' uses this config value
#html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'feeluowndoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
# Latex figure (float) alignment
#'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'feeluown.tex', 'feeluown Documentation',
'cosven', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'feeluown', 'feeluown Documentation',
[author], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'feeluown', 'feeluown Documentation',
author, 'feeluown', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False
|
JanlizWorldlet/FeelUOwn
|
sphinx_doc/source/conf.py
|
Python
|
mit
| 9,220 | 0.005965 |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.2 on 2017-04-11 10:09
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('hkm', '0018_auto_20170411_1301'),
]
operations = [
migrations.AddField(
model_name='productorder',
name='total_price_with_postage',
field=models.DecimalField(blank=True, decimal_places=2, max_digits=10, null=True, verbose_name='Total price with postage'),
),
]
|
andersinno/kuvaselaamo
|
hkm/migrations/0019_productorder_total_price_with_postage.py
|
Python
|
mit
| 554 | 0.001805 |
# -*- coding: utf-8 -*-
"""
flaskbb.forum.forms
~~~~~~~~~~~~~~~~~~~
It provides the forms that are needed for the forum views.
:copyright: (c) 2014 by the FlaskBB Team.
:license: BSD, see LICENSE for more details.
"""
from flask_wtf import Form
from wtforms import (TextAreaField, StringField, SelectMultipleField,
BooleanField, SubmitField)
from wtforms.validators import DataRequired, Optional, Length
from flask_babelplus import lazy_gettext as _
from flaskbb.forum.models import Topic, Post, Report, Forum
from flaskbb.user.models import User
class QuickreplyForm(Form):
content = TextAreaField(_("Quick reply"), validators=[
DataRequired(message=_("You cannot post a reply without content."))])
submit = SubmitField(_("Reply"))
def save(self, user, topic):
post = Post(content=self.content.data)
return post.save(user=user, topic=topic)
class ReplyForm(Form):
content = TextAreaField(_("Content"), validators=[
DataRequired(message=_("You cannot post a reply without content."))])
track_topic = BooleanField(_("Track this topic"), default=False,
validators=[Optional()])
submit = SubmitField(_("Reply"))
preview = SubmitField(_("Preview"))
def save(self, user, topic):
post = Post(content=self.content.data)
if self.track_topic.data:
user.track_topic(topic)
return post.save(user=user, topic=topic)
class NewTopicForm(ReplyForm):
title = StringField(_("Topic title"), validators=[
DataRequired(message=_("Please choose a title for your topic."))])
content = TextAreaField(_("Content"), validators=[
DataRequired(message=_("You cannot post a reply without content."))])
track_topic = BooleanField(_("Track this topic"), default=False,
validators=[Optional()])
submit = SubmitField(_("Post Topic"))
preview = SubmitField(_("Preview"))
def save(self, user, forum):
topic = Topic(title=self.title.data)
post = Post(content=self.content.data)
if self.track_topic.data:
user.track_topic(topic)
return topic.save(user=user, forum=forum, post=post)
class ReportForm(Form):
reason = TextAreaField(_("Reason"), validators=[
DataRequired(message=_("What is the reason for reporting this post?"))
])
submit = SubmitField(_("Report post"))
def save(self, user, post):
report = Report(reason=self.reason.data)
return report.save(post=post, user=user)
class UserSearchForm(Form):
search_query = StringField(_("Search"), validators=[
Optional(), Length(min=3, max=50)
])
submit = SubmitField(_("Search"))
def get_results(self):
query = self.search_query.data
return User.query.whooshee_search(query)
class SearchPageForm(Form):
search_query = StringField(_("Criteria"), validators=[
DataRequired(), Length(min=3, max=50)])
search_types = SelectMultipleField(_("Content"), validators=[
DataRequired()], choices=[('post', _('Post')), ('topic', _('Topic')),
('forum', _('Forum')), ('user', _('Users'))])
submit = SubmitField(_("Search"))
def get_results(self):
# Because the DB is not yet initialized when this form is loaded,
# the query objects cannot be instantiated in the class itself
search_actions = {
'post': Post.query.whooshee_search,
'topic': Topic.query.whooshee_search,
'forum': Forum.query.whooshee_search,
'user': User.query.whooshee_search
}
query = self.search_query.data
types = self.search_types.data
results = {}
for search_type in search_actions.keys():
if search_type in types:
results[search_type] = search_actions[search_type](query)
return results
|
realityone/flaskbb
|
flaskbb/forum/forms.py
|
Python
|
bsd-3-clause
| 3,976 | 0 |
from django.utils.translation import ugettext as _
from django.shortcuts import get_object_or_404
from django.views.generic import ListView, DetailView, DayArchiveView, CreateView,\
TemplateView
from datetime import date
from antxetamedia.agenda.forms import HappeningForm
from antxetamedia.agenda.models import Town, Happening
class BaseHappeningList(ListView):
allow_empty=True
def get_context_data(self, **kwargs):
c = super(BaseHappeningList, self).get_context_data(**kwargs)
c['towns'] = Town.objects.all()
return c
class FutureHappeningList(BaseHappeningList):
def get_queryset(self):
return Happening.objects.future()
class TownHappeningList(BaseHappeningList):
def get_queryset(self):
self.town = get_object_or_404(Town, slug=self.kwargs['slug'])
return Happening.objects.filter(town=self.town)
def get_context_data(self, **kwargs):
c = super(TownHappeningList, self).get_context_data(**kwargs)
c['reason'] = self.town
return c
class OtherTownHappeningList(TownHappeningList):
def get_queryset(self):
self.town = _('Other')
return Happening.objects.filter(town__isnull=True,
other_town__isnull=False)
class DayHappeningList(DayArchiveView):
model = Happening
date_field = 'date'
template_name = 'agenda/happening_list.html'
allow_future = True
month_format = '%m'
def get_context_data(self, **kwargs):
c = super(DayHappeningList, self).get_context_data(**kwargs)
c['towns'] = Town.objects.all()
return c
class HappeningDetail(DetailView):
model = Happening
slug_field = 'slug'
def get_context_data(self, **kwargs):
c = super(HappeningDetail, self).get_context_data(**kwargs)
c['towns'] = Town.objects.all()
return c
class CreateHappening(CreateView):
model = Happening
form_class = HappeningForm
def get_context_data(self, **kwargs):
c = super(CreateHappening, self).get_context_data(**kwargs)
c['towns'] = Town.objects.all()
return c
class SuccessfulCreate(TemplateView):
template_name = 'agenda/successful.html'
|
GISAElkartea/antxetamedia
|
antxetamedia/agenda/views.py
|
Python
|
agpl-3.0
| 2,216 | 0.002256 |
import pygame, sys
from pygame.locals import *
# --- Functions ---
def distance(speed, time):
distance = time * speed
return distance
# --- Classes ---
class Character(object):
def __init__(self, position, direction, sprite):
self.position = position
self.direction = direction
self.sprite = sprite
self.nextPosition = self.position
def move(self, direction):
if self.direction == 0:
self.nextPosition[1] = self.nextPosition[1] - 64
elif self.direction == 1:
self.nextPosition[0] = self.nextPosition[0] - 64
elif self.direction == 2:
self.nextPosition[1] = self.nextPosition[1] + 64
elif self.direction == 3:
self.nextPosition[0] = self.nextPosition[0] + 64
def updateAnimation(self):
# --- Set up ---
pygame.init()
windowSurface = pygame.display.set_mode((1216, 768), 0, 32) #always 0 and 32
pygame.display.set_caption('Lanceloet van Denemerken')
basicFont = pygame.font.SysFont(None, 23)
mainClock = pygame.time.Clock()
# --- Other variables ---
showDebug = True
loopTrack = 0
playerPos = [0, 0]
nextPlayerPos = [0, 0]
lastPress = 0
# --- Constants ---
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)
# --- Objects ---
# --- Image & music Loading ---
directionList = [pygame.image.load('up.png'),
pygame.image.load('left.png'),
pygame.image.load('down.png'),
pygame.image.load('right.png'),
pygame.image.load('upl.png'),
pygame.image.load('leftl.png'),
pygame.image.load('downl.png'),
pygame.image.load('rightl.png'),
pygame.image.load('upr.png'),
pygame.image.load('leftr.png'),
pygame.image.load('downr.png'),
pygame.image.load('rightr.png')]
picScaleTrack = 0
for picture in directionList:
directionList[picScaleTrack] = pygame.transform.scale(picture, (64, 64))
picScaleTrack += 1
player = directionList[5]
tile = pygame.image.load('tile.png')
# --- Main loop ---
while True:
# --- Variables outside gamestate ---
frameTime = mainClock.tick(1000)
FPS = mainClock.get_fps()
currentTime = pygame.time.get_ticks()
mousePosition = pygame.mouse.get_pos()
loopTrack = loopTrack + 1
# --- first blit/fill ---
windowSurface.fill(WHITE)
windowSurface.blit(player, (playerPos[0], playerPos[1]))
# --- Movement ---
if pygame.key.get_pressed()[119] and pygame.time.get_ticks() - lastPress >= 100:
player = directionList[0]
nextPlayerPos[1] -= 64
elif pygame.key.get_pressed()[97] and pygame.time.get_ticks() - lastPress >= 100:
player = directionList[1]
nextPlayerPos[0] -= 64
elif pygame.key.get_pressed()[115] and pygame.time.get_ticks() - lastPress >= 100:
player = directionList[2]
nextPlayerPos[1] += 64
elif pygame.key.get_pressed()[100] and pygame.time.get_ticks() - lastPress >= 100:
player = directionList[3]
nextPlayerPos[0] += 64
if (pygame.key.get_pressed()[119] or pygame.key.get_pressed()[97] or pygame.key.get_pressed()[115] or pygame.key.get_pressed()[100]) and pygame.time.get_ticks() - lastPress >= 100:
lastPress = pygame.time.get_ticks()
# --- Animation ---
if playerPos[0] != nextPlayerPos[0]:
if playerPos[0] < nextPlayerPos[0]:
playerPos[0] += distance(1, frameTime)
elif playerPos[0] > nextPlayerPos[0]:
playerPos[0] -= distance(1, frameTime)
if playerPos[1] != nextPlayerPos[1]:
if playerPos[1] < nextPlayerPos[1]:
playerPos[1] += distance(1, frameTime)
elif playerPos[1] > nextPlayerPos[1]:
playerPos[1] -= distance(1, frameTime)
# --- Tile visualisation ---
for y in range(-1, 12):
for x in range(-1, 19):
windowSurface.blit(tile, (x * 64, y * 64))
# --- Debug ---
if showDebug == True:
debug = nextPlayerPos
debugText = basicFont.render(str(debug), True, RED) #text | antialiasing | color
windowSurface.blit(debugText, (1, 1))
# --- Events ---
pygame.display.update()
for event in pygame.event.get():
if event.type == KEYUP:
if event.key == 284:
showDebug = not showDebug
if event.type == QUIT:
pygame.quit()
sys.exit()
|
Pietdagamer/Lanseloet
|
Old/2.py
|
Python
|
mit
| 4,586 | 0.006542 |
# -*- coding: utf-8 -*-
#
# PyOmicron documentation build configuration file, created by
# sphinx-quickstart on Tue Apr 26 09:12:21 2016.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.doctest',
'sphinx.ext.intersphinx',
'sphinx.ext.viewcode',
'sphinx.ext.autosummary',
'numpydoc',
'sphinxcontrib.programoutput',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'PyOmicron'
copyright = u'2016, Duncan Macleod'
author = u'Duncan Macleod'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = u'0.1'
# The full version, including alpha/beta/rc tags.
release = u'0.1'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# The reST default role (used for this markup: `text`) to use for all
# documents.
default_role = 'obj'
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'sphinx_rtd_theme'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents.
# "<project> v<release> documentation" by default.
#html_title = u'PyOmicron v0.1'
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (relative to this directory) to use as a favicon of
# the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []
# If not None, a 'Last updated on:' timestamp is inserted at every page
# bottom, using the given strftime format.
# The empty string is equivalent to '%b %d, %Y'.
#html_last_updated_fmt = None
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
#html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# 'ja' uses this config value.
# 'zh' user can custom change `jieba` dictionary path.
#html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'PyOmicrondoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
# Latex figure (float) alignment
#'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'PyOmicron.tex', u'PyOmicron Documentation',
u'Duncan Macleod', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'pyomicron', u'PyOmicron Documentation',
[author], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'PyOmicron', u'PyOmicron Documentation',
author, 'PyOmicron', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False
# Example configuration for intersphinx: refer to the Python standard library.
intersphinx_mapping = {
'python': ('http://docs.python.org/', None),
'numpy': ('http://docs.scipy.org/doc/numpy/', None),
'scipy': ('http://docs.scipy.org/doc/scipy/reference/', None),
'matplotlib': ('http://matplotlib.sourceforge.net/', None),
'gwpy': ('http://gwpy.github.io/docs/latest/', None),
}
|
ligovirgo/pyomicron
|
docs/conf.py
|
Python
|
gpl-3.0
| 9,982 | 0.00561 |
# Copyright (C) 2014 Andrey Antukh <niwi@niwi.be>
# Copyright (C) 2014 Jesús Espino <jespinog@gmail.com>
# Copyright (C) 2014 David Barragán <bameda@dbarragan.com>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from .development import *
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': '{{ taiga_database_username }}',
'USER': '{{ taiga_database_username }}',
'PASSWORD': '{{ taiga_database_password }}',
'HOST': '{{ taiga_database_host }}',
'PORT': '{{ taiga_database_port }}',
}
}
HOST="http://{{ taiga_hostname }}:{{ taiga_port }}"
#MEDIA_ROOT = '/home/taiga/media'
#STATIC_ROOT = '/home/taiga/static'
EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
EMAIL_USE_TLS = True
EMAIL_HOST = "{{ taiga_email_host }}"
EMAIL_HOST_USER = "{{ taiga_aws_access_key_id }}"
EMAIL_HOST_PASSWORD = "{{ taiga_aws_secret_access_key }}"
EMAIL_PORT = "{{ taiga_email_port }}"
DEFAULT_FROM_EMAIL = "{{ taiga_from_email_address }}"
# THROTTLING
#REST_FRAMEWORK["DEFAULT_THROTTLE_RATES"] = {
# "anon": "20/min",
# "user": "200/min",
# "import-mode": "20/sec"
#}
# GITHUB SETTINGS
#GITHUB_URL = "https://github.com/"
#GITHUB_API_URL = "https://api.github.com/"
#GITHUB_API_CLIENT_ID = "yourgithubclientid"
#GITHUB_API_CLIENT_SECRET = "yourgithubclientsecret"
|
JScott/ansible-taiga
|
templates/opt/taiga/back/settings/local.py
|
Python
|
mit
| 1,982 | 0.005561 |
#!/usr/bin/env python
# -*- coding: <utf-8> -*-
"""
This file is part of Spartacus project
Copyright (C) 2016 CSE
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.
"""
from CapuaEnvironment.Instruction.OperationDescription import operationDescription
__author__ = "CSE"
__copyright__ = "Copyright 2015, CSE"
__credits__ = ["CSE"]
__license__ = "GPL"
__version__ = "2.0"
__maintainer__ = "CSE"
__status__ = "Dev"
class Instruction:
"""
This class is only used for instruction encapsulation after they are fetched from memory.
An instance of this class is built by the InstructionFetchUnit and is passed to the
ExecutionUnit for execution. This class is simply there to help lower the number of
binary parsing required in the execution of a given instruction. It is also used
by the Assembler in order to help build the binary code associated with a specific
instruction.
"""
instructionCode = None
sourceRegister = None
destinationRegister = None
sourceImmediate = None
destinationImmediate = None
width = None
flags = None
operationMnemonic = None
instructionLength = None
def __init__(self, binaryInstruction=0b000000, form=None, skipValidation=False):
"""
This allow for initialisation of the instruction by parsing the binary instruction code
:param binaryInstruction: A big number representing the instruction
:param form: The form representing the instruction as shown in FormDescription.py
:return: An instruction! Warning, this instruction could be invalid!
"""
if not skipValidation:
self.instructionLength = form["length"]
# Parse the description so we can initiate the instruction
for descriptionElement in form["description"]:
mask = form["description"][descriptionElement]
extractedBinary = self._extractValueFromBinaryField(mask, binaryInstruction)
# There is no validation here for performance reason
# WE RELY ON THE FACT that the form description is correct
# and does not contain any typo!!!
setattr(self, descriptionElement, extractedBinary)
# This will simply get the instruction mnemonic from a list of possible mnemonics
for instructionMnemonic in operationDescription:
if self.instructionCode in operationDescription[instructionMnemonic]:
self.operationMnemonic = instructionMnemonic
break
if self.operationMnemonic is None:
raise ValueError("Invalid instruction detected")
return
def _extractValueFromBinaryField(self, mask, field):
"""
This method takes a value and a binary mask. It will extract the part of the value that
is covered by the mask and return it to the user.
Example:
value = 0b11111111
mask = 0b00110000
result = 0b00110000
returned value = 0b11
:param mask: Binary mask showing what need to be extracted
:param field: The field from which we want to do the extract
:return: int, the extracted value
"""
# First, we get the mask at the right. Looking for mask % 2 will, when = 1
# tell us that the mask is now fully aligned at the right
if mask > 0:
while (mask % 2) != 1:
mask >>= 1
field >>= 1
field &= mask # The result is the "parsed" value
return field
|
CommunicationsSecurityEstablishment/spartacus
|
CapuaEnvironment/Instruction/Instruction.py
|
Python
|
gpl-2.0
| 4,253 | 0.003292 |
#!/usr/local/bin/python3
# coding: utf-8
try:
import json, requests, urllib
from geopy.geocoders import Nominatim
from geopy.distance import vincenty
except:
print("Error importing modules, exiting.")
exit()
api_url = "http://opendata.iprpraha.cz/CUR/FSV/FSV_VerejnaWC_b/WGS_84/FSV_VerejnaWC_b.json"
def find(address):
# convert address to latlong
me = locate(address+", Prague")
if me == None:
return None
toilets = getToilets(api_url)
# Get closest toilet
wcID = getClosestID(me, toilets)
wc = toilets[wcID-1]
data = []
try:
address = wc['properties']['ADRESA']
except:
address = "Address not available."
try:
typ = wc['properties']['TYP']
except:
typ = ""
r = "Closest public toilet is {} meters away.\n{}".format(getDist(me, wc), address)
return [r , getCoords(wc)]
def getClosestID(me, toilets):
a = {}
for toilet in toilets:
ID = toilet['properties']['OBJECTID']
a[ID] = getDist(me, toilet)
closest = min(a,key=a.get) # list offset
print("ID {} is {} meters away.".format(closest,a[closest]))
return closest
def getDist( coords, toilet):
loc = toilet['geometry']['coordinates']
loc = (loc[1],loc[0]) # Switch coords position
dist = round(vincenty(coords, loc).meters)
return dist
def getCoords(toilet):
loc = toilet['geometry']['coordinates']
return (loc[1],loc[0])
def locate(address):
geolocator = Nominatim()
location = geolocator.geocode(address)
if location:
coords = (location.latitude, location.longitude)
return coords
return None
def getToilets(url):
# outputs list of dicts
response = requests.get(url)
content = response.content.decode('utf-8')
js = json.loads(content)
return js['features']
# x = find()
# print(x)
|
vkotek/kotek_bot
|
features/toilet_finder.py
|
Python
|
unlicense
| 1,885 | 0.009549 |
#!/usr/bin/env python
import sys
import os
from treestore import Treestore
try: taxonomy = sys.argv[1]
except: taxonomy = None
t = Treestore()
treebase_uri = 'http://purl.org/phylo/treebase/phylows/tree/%s'
tree_files = [x for x in os.listdir('trees') if x.endswith('.nex')]
base_uri = 'http://www.phylocommons.org/trees/%s'
tree_list = set(t.list_trees())
for tree_uri in tree_list:
if not 'TB2_' in tree_uri: continue
tree_id = t.id_from_uri(tree_uri)
tb_uri = treebase_uri % (tree_id.replace('_', ':'))
print tree_id, tb_uri
t.annotate(tree_uri, annotations='?tree bibo:cites <%s> .' % tb_uri)
|
NESCent/phylocommons
|
tools/treebase_scraper/annotate_trees.py
|
Python
|
mit
| 622 | 0.008039 |
# This file is part of Fail2Ban.
#
# Fail2Ban 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.
#
# Fail2Ban 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 Fail2Ban; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Author: Cyril Jaquier
#
# $Revision$
__author__ = "Cyril Jaquier"
__version__ = "$Revision$"
__date__ = "$Date$"
__copyright__ = "Copyright (c) 2004 Cyril Jaquier"
__license__ = "GPL"
import unittest
from server.datedetector import DateDetector
from server.datetemplate import DateTemplate
class DateDetectorTest(unittest.TestCase):
def setUp(self):
"""Call before every test case."""
self.__datedetector = DateDetector()
self.__datedetector.addDefaultTemplate()
def tearDown(self):
"""Call after every test case."""
def testGetEpochTime(self):
log = "1138049999 [sshd] error: PAM: Authentication failure"
date = [2006, 1, 23, 21, 59, 59, 0, 23, 0]
dateUnix = 1138049999.0
self.assertEqual(self.__datedetector.getTime(log), date)
self.assertEqual(self.__datedetector.getUnixTime(log), dateUnix)
def testGetTime(self):
log = "Jan 23 21:59:59 [sshd] error: PAM: Authentication failure"
date = [2005, 1, 23, 21, 59, 59, 1, 23, -1]
dateUnix = 1106513999.0
self.assertEqual(self.__datedetector.getTime(log), date)
self.assertEqual(self.__datedetector.getUnixTime(log), dateUnix)
# def testDefaultTempate(self):
# self.__datedetector.setDefaultRegex("^\S{3}\s{1,2}\d{1,2} \d{2}:\d{2}:\d{2}")
# self.__datedetector.setDefaultPattern("%b %d %H:%M:%S")
#
# log = "Jan 23 21:59:59 [sshd] error: PAM: Authentication failure"
# date = [2005, 1, 23, 21, 59, 59, 1, 23, -1]
# dateUnix = 1106513999.0
#
# self.assertEqual(self.__datedetector.getTime(log), date)
# self.assertEqual(self.__datedetector.getUnixTime(log), dateUnix)
|
yarikoptic/Fail2Ban-Old-SVNGIT
|
testcases/datedetectortestcase.py
|
Python
|
gpl-2.0
| 2,300 | 0.01913 |
# Unix SMB/CIFS implementation.
# Copyright (C) Sean Dague <sdague@linux.vnet.ibm.com> 2011
#
# 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/>.
# This provides a wrapper around the cmd interface so that tests can
# easily be built on top of it and have minimal code to run basic tests
# of the commands. A list of the environmental variables can be found in
# ~/selftest/selftest.pl
#
# These can all be accesses via os.environ["VARIBLENAME"] when needed
import random
import string
from samba.auth import system_session
from samba.samdb import SamDB
from cStringIO import StringIO
from samba.netcmd.main import cmd_sambatool
import samba.tests
class SambaToolCmdTest(samba.tests.TestCaseInTempDir):
def getSamDB(self, *argv):
"""a convenience function to get a samdb instance so that we can query it"""
# We build a fake command to get the options created the same
# way the command classes do it. It would be better if the command
# classes had a way to more cleanly do this, but this lets us write
# tests for now
cmd = cmd_sambatool.subcommands["user"].subcommands["setexpiry"]
parser, optiongroups = cmd._create_parser("user")
opts, args = parser.parse_args(list(argv))
# Filter out options from option groups
args = args[1:]
kwargs = dict(opts.__dict__)
for option_group in parser.option_groups:
for option in option_group.option_list:
if option.dest is not None:
del kwargs[option.dest]
kwargs.update(optiongroups)
H = kwargs.get("H", None)
sambaopts = kwargs.get("sambaopts", None)
credopts = kwargs.get("credopts", None)
lp = sambaopts.get_loadparm()
creds = credopts.get_credentials(lp, fallback_machine=True)
samdb = SamDB(url=H, session_info=system_session(),
credentials=creds, lp=lp)
return samdb
def runcmd(self, name, *args):
"""run a single level command"""
cmd = cmd_sambatool.subcommands[name]
cmd.outf = StringIO()
cmd.errf = StringIO()
result = cmd._run(name, *args)
return (result, cmd.outf.getvalue(), cmd.errf.getvalue())
def runsubcmd(self, name, sub, *args):
"""run a command with sub commands"""
# The reason we need this function separate from runcmd is
# that the .outf StringIO assignment is overriden if we use
# runcmd, so we can't capture stdout and stderr
cmd = cmd_sambatool.subcommands[name].subcommands[sub]
cmd.outf = StringIO()
cmd.errf = StringIO()
result = cmd._run(name, *args)
return (result, cmd.outf.getvalue(), cmd.errf.getvalue())
def assertCmdSuccess(self, val, msg=""):
self.assertIsNone(val, msg)
def assertCmdFail(self, val, msg=""):
self.assertIsNotNone(val, msg)
def assertMatch(self, base, string, msg=""):
self.assertTrue(string in base, msg)
def randomName(self, count=8):
"""Create a random name, cap letters and numbers, and always starting with a letter"""
name = random.choice(string.ascii_uppercase)
name += ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase+ string.digits) for x in range(count - 1))
return name
def randomPass(self, count=16):
name = random.choice(string.ascii_uppercase)
name += random.choice(string.digits)
name += random.choice(string.ascii_lowercase)
name += ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase+ string.digits) for x in range(count - 3))
return name
def randomXid(self):
# pick some hopefully unused, high UID/GID range to avoid interference
# from the system the test runs on
xid = random.randint(4711000, 4799000)
return xid
def assertWithin(self, val1, val2, delta, msg=""):
"""Assert that val1 is within delta of val2, useful for time computations"""
self.assertTrue(((val1 + delta) > val2) and ((val1 - delta) < val2), msg)
|
yasoob/PythonRSSReader
|
venv/lib/python2.7/dist-packages/samba/tests/samba_tool/base.py
|
Python
|
mit
| 4,702 | 0.002127 |
from pywin.mfc import dialog
import win32api
import win32con
import win32ui
import copy
import string
from . import scintillacon
# Used to indicate that style should use default color
from win32con import CLR_INVALID
######################################################
# Property Page for syntax formatting options
# The standard 16 color VGA palette should always be possible
paletteVGA = (
("Black", win32api.RGB(0,0,0)),
("Navy", win32api.RGB(0,0,128)),
("Green", win32api.RGB(0,128,0)),
("Cyan", win32api.RGB(0,128,128)),
("Maroon", win32api.RGB(128,0,0)),
("Purple", win32api.RGB(128,0,128)),
("Olive", win32api.RGB(128,128,0)),
("Gray", win32api.RGB(128,128,128)),
("Silver", win32api.RGB(192,192,192)),
("Blue", win32api.RGB(0,0,255)),
("Lime", win32api.RGB(0,255,0)),
("Aqua", win32api.RGB(0,255,255)),
("Red", win32api.RGB(255,0,0)),
("Fuchsia", win32api.RGB(255,0,255)),
("Yellow", win32api.RGB(255,255,0)),
("White", win32api.RGB(255,255,255)),
# and a few others will generally be possible.
("DarkGrey", win32api.RGB(64,64,64)),
("PurpleBlue", win32api.RGB(64,64,192)),
("DarkGreen", win32api.RGB(0,96,0)),
("DarkOlive", win32api.RGB(128,128,64)),
("MediumBlue", win32api.RGB(0,0,192)),
("DarkNavy", win32api.RGB(0,0,96)),
("Magenta", win32api.RGB(96,0,96)),
("OffWhite", win32api.RGB(255,255,220)),
("LightPurple", win32api.RGB(220,220,255)),
("<Default>", win32con.CLR_INVALID)
)
class ScintillaFormatPropertyPage(dialog.PropertyPage):
def __init__(self, scintillaClass = None, caption = 0):
self.scintillaClass = scintillaClass
dialog.PropertyPage.__init__(self, win32ui.IDD_PP_FORMAT, caption=caption)
def OnInitDialog(self):
try:
if self.scintillaClass is None:
from . import control
sc = control.CScintillaEdit
else:
sc = self.scintillaClass
self.scintilla = sc()
style = win32con.WS_CHILD | win32con.WS_VISIBLE | win32con.ES_MULTILINE
# Convert the rect size
rect = self.MapDialogRect( (5, 5, 120, 75))
self.scintilla.CreateWindow(style, rect, self, 111)
self.HookNotify(self.OnBraceMatch, scintillacon.SCN_CHECKBRACE)
self.scintilla.HookKeyStroke(self.OnEsc, 27)
self.scintilla.SCISetViewWS(1)
self.pos_bstart = self.pos_bend = self.pos_bbad = 0
colorizer = self.scintilla._GetColorizer()
text = colorizer.GetSampleText()
items = text.split('|', 2)
pos = len(items[0])
self.scintilla.SCIAddText(''.join(items))
self.scintilla.SetSel(pos, pos)
self.scintilla.ApplyFormattingStyles()
self.styles = self.scintilla._GetColorizer().styles
self.cbo = self.GetDlgItem(win32ui.IDC_COMBO1)
for c in paletteVGA:
self.cbo.AddString(c[0])
self.cboBoldItalic = self.GetDlgItem(win32ui.IDC_COMBO2)
for item in ["Bold Italic", "Bold", "Italic", "Regular"]:
self.cboBoldItalic.InsertString(0, item)
self.butIsDefault = self.GetDlgItem(win32ui.IDC_CHECK1)
self.butIsDefaultBackground = self.GetDlgItem(win32ui.IDC_CHECK2)
self.listbox = self.GetDlgItem(win32ui.IDC_LIST1)
self.HookCommand(self.OnListCommand, win32ui.IDC_LIST1)
names = list(self.styles.keys())
names.sort()
for name in names:
if self.styles[name].aliased is None:
self.listbox.AddString(name)
self.listbox.SetCurSel(0)
idc = win32ui.IDC_RADIO1
if not self.scintilla._GetColorizer().bUseFixed: idc = win32ui.IDC_RADIO2
self.GetDlgItem(idc).SetCheck(1)
self.UpdateUIForStyle(self.styles[names[0]])
self.scintilla.HookFormatter(self)
self.HookCommand(self.OnButDefaultFixedFont, win32ui.IDC_BUTTON1)
self.HookCommand(self.OnButDefaultPropFont, win32ui.IDC_BUTTON2)
self.HookCommand(self.OnButThisFont, win32ui.IDC_BUTTON3)
self.HookCommand(self.OnButUseDefaultFont, win32ui.IDC_CHECK1)
self.HookCommand(self.OnButThisBackground, win32ui.IDC_BUTTON4)
self.HookCommand(self.OnButUseDefaultBackground, win32ui.IDC_CHECK2)
self.HookCommand(self.OnStyleUIChanged, win32ui.IDC_COMBO1)
self.HookCommand(self.OnStyleUIChanged, win32ui.IDC_COMBO2)
self.HookCommand(self.OnButFixedOrDefault, win32ui.IDC_RADIO1)
self.HookCommand(self.OnButFixedOrDefault, win32ui.IDC_RADIO2)
except:
import traceback
traceback.print_exc()
def OnEsc(self, ch):
self.GetParent().EndDialog(win32con.IDCANCEL)
def OnBraceMatch(self, std, extra):
import pywin.scintilla.view
pywin.scintilla.view.DoBraceMatch(self.scintilla)
def GetSelectedStyle(self):
return self.styles[self.listbox.GetText(self.listbox.GetCurSel())]
def _DoButDefaultFont(self, extra_flags, attr):
baseFormat = getattr(self.scintilla._GetColorizer(), attr)
flags = extra_flags | win32con.CF_SCREENFONTS | win32con.CF_EFFECTS | win32con.CF_FORCEFONTEXIST
d=win32ui.CreateFontDialog(baseFormat, flags, None, self)
if d.DoModal()==win32con.IDOK:
setattr(self.scintilla._GetColorizer(), attr, d.GetCharFormat())
self.OnStyleUIChanged(0, win32con.BN_CLICKED)
def OnButDefaultFixedFont(self, id, code):
if code==win32con.BN_CLICKED:
self._DoButDefaultFont(win32con.CF_FIXEDPITCHONLY, "baseFormatFixed")
return 1
def OnButDefaultPropFont(self, id, code):
if code==win32con.BN_CLICKED:
self._DoButDefaultFont(win32con.CF_SCALABLEONLY, "baseFormatProp")
return 1
def OnButFixedOrDefault(self, id, code):
if code==win32con.BN_CLICKED:
bUseFixed = id == win32ui.IDC_RADIO1
self.GetDlgItem(win32ui.IDC_RADIO1).GetCheck() != 0
self.scintilla._GetColorizer().bUseFixed = bUseFixed
self.scintilla.ApplyFormattingStyles(0)
return 1
def OnButThisFont(self, id, code):
if code==win32con.BN_CLICKED:
flags = win32con.CF_SCREENFONTS | win32con.CF_EFFECTS | win32con.CF_FORCEFONTEXIST
style = self.GetSelectedStyle()
# If the selected style is based on the default, we need to apply
# the default to it.
def_format = self.scintilla._GetColorizer().GetDefaultFormat()
format = style.GetCompleteFormat(def_format)
d=win32ui.CreateFontDialog(format, flags, None, self)
if d.DoModal()==win32con.IDOK:
style.format = d.GetCharFormat()
self.scintilla.ApplyFormattingStyles(0)
return 1
def OnButUseDefaultFont(self, id, code):
if code == win32con.BN_CLICKED:
isDef = self.butIsDefault.GetCheck()
self.GetDlgItem(win32ui.IDC_BUTTON3).EnableWindow(not isDef)
if isDef: # Being reset to the default font.
style = self.GetSelectedStyle()
style.ForceAgainstDefault()
self.UpdateUIForStyle(style)
self.scintilla.ApplyFormattingStyles(0)
else:
# User wants to override default -
# do nothing!
pass
def OnButThisBackground(self, id, code):
if code==win32con.BN_CLICKED:
style = self.GetSelectedStyle()
bg = win32api.RGB(0xff, 0xff, 0xff)
if style.background != CLR_INVALID:
bg = style.background
d=win32ui.CreateColorDialog(bg, 0, self)
if d.DoModal()==win32con.IDOK:
style.background = d.GetColor()
self.scintilla.ApplyFormattingStyles(0)
return 1
def OnButUseDefaultBackground(self, id, code):
if code == win32con.BN_CLICKED:
isDef = self.butIsDefaultBackground.GetCheck()
self.GetDlgItem(win32ui.IDC_BUTTON4).EnableWindow(not isDef)
if isDef: # Being reset to the default color
style = self.GetSelectedStyle()
style.background = style.default_background
self.UpdateUIForStyle(style)
self.scintilla.ApplyFormattingStyles(0)
else:
# User wants to override default -
# do nothing!
pass
def OnListCommand(self, id, code):
if code==win32con.LBN_SELCHANGE:
style = self.GetSelectedStyle()
self.UpdateUIForStyle(style)
return 1
def UpdateUIForStyle(self, style ):
format = style.format
sel = 0
for c in paletteVGA:
if format[4] == c[1]:
# print "Style", style.name, "is", c[0]
break
sel = sel + 1
else:
sel = -1
self.cbo.SetCurSel(sel)
self.butIsDefault.SetCheck(style.IsBasedOnDefault())
self.GetDlgItem(win32ui.IDC_BUTTON3).EnableWindow(not style.IsBasedOnDefault())
self.butIsDefaultBackground.SetCheck(style.background == style.default_background)
self.GetDlgItem(win32ui.IDC_BUTTON4).EnableWindow(style.background != style.default_background)
bold = format[1] & win32con.CFE_BOLD != 0; italic = format[1] & win32con.CFE_ITALIC != 0
self.cboBoldItalic.SetCurSel( bold*2 + italic )
def OnStyleUIChanged(self, id, code):
if code in [win32con.BN_CLICKED, win32con.CBN_SELCHANGE]:
style = self.GetSelectedStyle()
self.ApplyUIFormatToStyle(style)
self.scintilla.ApplyFormattingStyles(0)
return 0
return 1
def ApplyUIFormatToStyle(self, style):
format = style.format
color = paletteVGA[self.cbo.GetCurSel()]
effect = 0
sel = self.cboBoldItalic.GetCurSel()
if sel==0:
effect = 0
elif sel==1:
effect = win32con.CFE_ITALIC
elif sel==2:
effect = win32con.CFE_BOLD
else:
effect = win32con.CFE_BOLD | win32con.CFE_ITALIC
maskFlags=format[0]|win32con.CFM_COLOR|win32con.CFM_BOLD|win32con.CFM_ITALIC
style.format = (maskFlags, effect, style.format[2], style.format[3], color[1]) + style.format[5:]
def OnOK(self):
self.scintilla._GetColorizer().SavePreferences()
return 1
def test():
page = ColorEditorPropertyPage()
sheet = pywin.mfc.dialog.PropertySheet("Test")
sheet.AddPage(page)
sheet.CreateWindow()
|
sserrot/champion_relationships
|
venv/Lib/site-packages/pythonwin/pywin/scintilla/configui.py
|
Python
|
mit
| 9,244 | 0.034401 |
from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm
class RegisterForm(UserCreationForm):
invitation = forms.CharField(max_length=8)
class Meta:
model = User
fields = ('username', 'password1', 'password2', 'invitation')
class SettingsForm(forms.Form):
username = forms.CharField(min_length=1)
ppic = forms.ImageField(required=False)
class Meta:
model = User
fields = ('username', 'first_name','last_name','ppic',)
|
AtenrevCode/scChat
|
users/forms.py
|
Python
|
mit
| 542 | 0.00738 |
#!/usr/bin/python3 -B
exec(open("../index.py").read())
from waitress import serve
serve(application, host='0.0.0.0', port=8080, threads=1, channel_timeout=1)
|
shark555/websnake_demo
|
scripts/serve.py
|
Python
|
mit
| 161 | 0.018634 |
"""
.. math.py
Simple math movers.
"""
## Inheritance
import base
# import library.movers.pushqueue as pq
## Inifinity definition
inf = float("inf")
#########################################
## ----- Special data containers ----- ##
#########################################
class MovingMax(base.Mover):
""" Counts the current maximum of a moving data window of length *n*
(which is infinite by default).
Example:
>>> mmax = MovingMax(3)
>>> data = [6, 9, 7, 6, 6, 3, 4, 4, 6, 2]
>>> [mmax(x) for x in data]
[6, 9, 9, 9, 7, 6, 6, 4, 6, 6]
"""
def __init__(self, n=inf, **kwargs):
self.n = n
kwargs.update(patient=False)
super(MovingMax, self).__init__(**kwargs)
def _eat(self, value):
self._queue.push(value)
return self._queue.max
def _zero(self):
self._queue = pq.MaxQueue(maxlen=self.n)
@property
def max(self):
try:
return self._queue.max
except KeyError:
return None
class MovingMin(base.Mover):
""" Counts the current minimum of a moving data window of length *n*
(which is infinite by default).
Example:
>>> mmax = MovingMin(3)
>>> data = [6, 9, 7, 6, 6, 3, 4, 4, 6, 2]
>>> [mmin(x) for x in data]
[6, 6, 6, 6, 6, 3, 3, 3, 4, 2]
"""
def __init__(self, n=inf, **kwargs):
self.n = n
kwargs.update(patient=False)
super(MovingMin, self).__init__(**kwargs)
def _eat(self, value):
self._queue.push(value)
return self._queue.min
def _zero(self):
self._queue = pq.MinQueue(maxlen=self.n)
@property
def min(self):
try:
return self._queue.min
except KeyError:
return None
class MovingRatio(base.Mover):
""" A mover which return the ratio between the current value and the
last value. """
def __init__(self, n=1, **kwargs):
""" *n* is the delay factor. """
self.n = n
super(MovingRatio, self).__init__(**kwargs)
def _eat(self, value):
out = self._deque.push(value)
try:
ratio = value / out
except TypeError:
ratio = 1.0
return ratio
def _zero(self):
self._deque = self._get_deque(self.n)
class MovingSum(base.Mover):
""" Counts the accumulating sum of a moving data window of length *n*
(which is infinite by default).
Examples:
>>> msum = MovingSum()
>>> [msum(x) for x in xrange(10)]
[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]
>>> msum = MovingSum(3)
>>> [msum(x) for x in xrange(10)]
[0, 1, 3, 6, 9, 12, 15, 18, 21, 24]
"""
def __init__(self, n=inf):
self.n = n
super(MovingSum, self).__init__()
def _eat(self, value):
## Push eaten value and catch fallen value
out = self._deque.push(value)
## Increase-decrease sum
try:
self._sum += value - out
## Fallen value was None, so increase-only is made
except TypeError:
self._sum += value
## Return sum
return self._sum
def _zero(self):
self._deque = base.Deque((), maxlen=self.n)
self._sum = 0
def sgn(x):
""" Return the sign of *x*. """
return 1 if x.real > 0 else -1 if x.real < 0 else 0
class SignTracker(base.Mover):
""" Counts length of successing similar-signed values, where a 0 value
does not change trend, and ``None`` zeros the trend. By default, the
sign of a value is determined by :func:`sgn`, but the a different
sign function may be assigned to the *sgn* parameter, assuming it's a
function whose image is partial to the set ``{-1, 0, 1}``.
Basic example:
>>> tracker = SignTracker()
>>> data = [2, 3, -3, None, -1, 0, -1, 2]
>>> [tracker(value) for value in data]
[1, 2, -1, 0, -1, -2, -3, 1]
More complex example:
>>> my_sgn = lambda x: 1 if x >= 1.0 else -1 if x <= -1 else 0
>>> tracker = SignTracker(sgn=my_sgn)
>>> data = [2, 3, -0.5, None, -1, 0, -1, 1]
>>> [tracker(value) for value in data]
[1, 2, 3, 0, -1, -2, -3, 1]
"""
def __init__(self, sgn=sgn):
self.sgn = sgn
super(SignTracker, self).__init__()
def _eat(self, value):
## Get current+new signs
cur_sgn = sgn(self._count)
new_sgn = self.sgn(value)
## With trend
if cur_sgn * new_sgn >= 0:
self._count += sgn(cur_sgn + new_sgn)
return self._count
## Against trend
self._count = new_sgn
return self._count
def _zero(self):
self._count = 0
return 0
def _dffsgn(old, new):
return sgn(new-old)
class ToneTracker(base.Mover):
""" Tracks current "tone", which is defined (by default) to be the
sign of the substracting result of the value *gap* values earlier from
the current value. This may be overridden by a different *toner*,
assuming it's a function taking "old" and "new" as parameters.
Basic example:
>>> tracker = ToneTracker(gap=4)
>>> data = range(6) + range(5)[::-1]
>>> [tracker(value) for value in data]
[None, None, None, None, 1, 1, 1, 0, -1, -1, -1]
More complex example:
>>> my_toner = lambda old, new: sgn(len(new)-len(old))
>>> tracker = ToneTracker(toner=my_toner)
>>> data = [[1, 2], (3,), {4: 5, 6: 7}, range(8)]
>>> [tracker(value) for value in data]
[None, -1, 1, 1]
"""
def __init__(self, gap=1, toner=_dffsgn):
self.gap = gap
self.toner = toner
super(ToneTracker, self).__init__()
def _eat(self, value):
## Get old value
out = self._deque.push(value)
## Return relevant tone
if out is not self._deque.none:
return self.toner(out, value)
def _zero(self):
## Reset a deque
self._deque = base.Deque((), maxlen=self.gap)
class LocalExtrema(base.Mover):
""" Tracks local extremas, where "extrema" in this sense is a value which is
higher (lower) than its pre-defined neighbourhood. The neighbourhood is
defined by the parameters *left* and *right* (how many values to the left,
how many values to the right), whether this is max (1) or min (-1) is
determined by the *direction* parameter, and finally the *strict* boolean
parameter decides whether the comparison should be strict or not, when
comparing to the left.
Examples:
>>> data = [5, 6, 9, 6, 6, 8, 8, 8, 9]
>>> lmax11 = LocalExtrema(1, 1, 1, False)
>>> [lmax11(x) for x in data] ## We don't expect more than one max
[False, False, False, True, False, False, False, False, False]
>>> lmax11s = LocalExtrema(1, 1, 1, True)
>>> [lmax11s(x) for x in data]
[False, False, False, True, False, False, True, False, False]
>>> lmin11s = LocalExtrema(-1, 1, 1, True)
>>> [lmin11s(x) for x in data]
[False, False, False, False, True, False, False, False, False]
>>> lmin21 = LocalExtrema(-1, 2, 1, False)
>>> [lmin21(x) for x in data]
[False, False, False, False, False, True, False, False, True]
"""
def __init__(self, direction=1, left=1, right=1, strict=True):
self.direction = direction
self._ext = max if self.direction == 1 else min
self.left = left
self.right = right
self.strict = strict
super(LocalExtrema, self).__init__()
def _cmp(self, a, b):
return sgn(a - b) * self.direction >= int(self.strict)
def _eat(self, value):
## There is no candidate
if self._c is None:
## The left deque is full
if self._ld.isfull():
## The new value is a candidate
if self._cmp(value, self._ext(self._ld)):
self._c = value
## Push and return
self._ld.append(value)
return False
## Push
self._ld.append(value)
## We replace current candidate
if self._cmp(value, self._c):
self._empty_rd()
self._c = value
return False
## We continue with the current candidate
self._rd.append(value)
## Candidate has not yet won
if not self._rd.isfull():
return False
## Candidate has won
self._empty_rd()
self._del_c()
return True
def _empty_ld(self):
self._ld = base.Deque((), maxlen=self.left)
def _empty_rd(self):
self._rd = base.Deque((), maxlen=self.right)
def _del_c(self):
self._c = None
def _zero(self):
## Reset the deques and the candidate
self._empty_ld()
self._empty_rd()
self._del_c()
## Naive version, until I'll find a better one
class SignModCounter(base.Mover):
def __init__(self, n=inf, **kwargs):
self.n = n
kwargs.update(patient=False)
super(SignModCounter, self).__init__(**kwargs)
def _eat(self, value):
self._deque.push(value)
state = 0
mods = 0
for e in self._deque:
if state * e == -1:
mods += 1
if e:
state = e
return mods
def _zero(self):
self._deque = base.Deque(maxlen=self.n)
return 0
|
pelegm/movers
|
math.py
|
Python
|
unlicense
| 9,322 | 0.002789 |
"""
taskmaster.controller
~~~~~~~~~~~~~~~~~~~~~
:copyright: (c) 2010 DISQUS.
:license: Apache License 2.0, see LICENSE for more details.
"""
import cPickle as pickle
import gevent
import sys
from gevent_zeromq import zmq
from gevent.queue import Queue, Empty
from os import path, unlink, rename
from taskmaster.util import import_target
class Server(object):
def __init__(self, address, size=None):
self.daemon = True
self.started = False
self.size = size
self.queue = Queue(maxsize=size)
self.address = address
self.context = zmq.Context(1)
self.server = None
def send(self, cmd, data=''):
self.server.send_multipart([cmd, data])
def recv(self):
reply = self.server.recv_multipart()
assert len(reply) == 2
return reply
def bind(self):
if self.server:
self.server.close()
print "Taskmaster binding to %r" % self.address
self.server = self.context.socket(zmq.REP)
self.server.bind(self.address)
def start(self):
self.started = True
self.bind()
while self.started:
gevent.sleep(0)
cmd, data = self.recv()
if cmd == 'GET':
if not self.has_work():
self.send('QUIT')
continue
try:
job = self.queue.get_nowait()
except Empty:
self.send('WAIT')
continue
self.send('OK', pickle.dumps(job))
elif cmd == 'DONE':
self.queue.task_done()
if self.has_work():
self.send('OK')
else:
self.send('QUIT')
else:
self.send('ERROR', 'Unrecognized command')
self.shutdown()
def put_job(self, job):
return self.queue.put(job)
def first_job(self):
return self.queue.queue[0]
def get_current_size(self):
return self.queue.qsize()
def get_max_size(self):
return self.size
def has_work(self):
return not self.queue.empty()
def is_alive(self):
return self.started
def shutdown(self):
if not self.started:
return
self.server.close()
self.context.term()
self.started = False
class Controller(object):
def __init__(self, server, target, state_file=None, progressbar=True):
if isinstance(target, basestring):
target = import_target(target, 'get_jobs')
if not state_file:
target_file = sys.modules[target.__module__].__file__
state_file = path.join(path.dirname(target_file),
'%s.state' % (path.basename(target_file),))
self.server = server
self.target = target
self.state_file = state_file
if progressbar:
self.pbar = self.get_progressbar()
else:
self.pbar = None
def get_progressbar(self):
from taskmaster.progressbar import Counter, Speed, Timer, ProgressBar, UnknownLength, Value
sizelen = len(str(self.server.size))
format = 'In-Queue: %%-%ds / %%-%ds' % (sizelen, sizelen)
queue_size = Value(callback=lambda x: format % (self.server.get_current_size(), self.server.get_max_size()))
widgets = ['Completed Tasks: ', Counter(), ' | ', queue_size, ' | ', Speed(), ' | ', Timer()]
pbar = ProgressBar(widgets=widgets, maxval=UnknownLength)
return pbar
def read_state(self):
if path.exists(self.state_file):
print "Reading previous state from %r" % self.state_file
with open(self.state_file, 'r') as fp:
try:
return pickle.load(fp)
except EOFError:
pass
except Exception, e:
print "There was an error reading from state file. Ignoring and continuing without."
import traceback
traceback.print_exc()
print e
return {}
def update_state(self, job_id, job, fp=None):
last_job_id = getattr(self, '_last_job_id', None)
if self.pbar:
self.pbar.update(job_id)
if job_id == last_job_id:
return
if not job:
return
last_job_id = job_id
data = {
'job': job,
'job_id': job_id,
}
with open(self.state_file + '.tmp', 'w') as fp:
pickle.dump(data, fp)
rename(self.state_file + '.tmp', self.state_file)
def state_writer(self):
while self.server.is_alive():
gevent.sleep(0)
try:
job_id, job = self.server.first_job()
except IndexError:
self.update_state(None, None)
continue
self.update_state(job_id, job)
def reset(self):
if path.exists(self.state_file):
unlink(self.state_file)
def start(self):
kwargs = {}
last_job = self.read_state()
if last_job:
kwargs['last'] = last_job['job']
start_id = last_job['job_id']
else:
start_id = 0
gevent.spawn(self.server.start)
gevent.sleep(0)
if self.pbar:
self.pbar.start()
self.pbar.update(start_id)
state_writer = gevent.spawn(self.state_writer)
job_id, job = (None, None)
for job_id, job in enumerate(self.target(**kwargs), start_id):
self.server.put_job((job_id, job))
gevent.sleep(0)
while self.server.has_work():
gevent.sleep(0)
# Give clients a few seconds to receive a DONE message
gevent.sleep(3)
self.server.shutdown()
state_writer.join(1)
self.update_state(job_id, job)
if self.pbar:
self.pbar.finish()
|
alex/taskmaster
|
src/taskmaster/server.py
|
Python
|
apache-2.0
| 6,026 | 0.00083 |
#!/usr/bin/env python
import os.path
import re
from setuptools import Command, find_packages, setup
class PyTest(Command):
user_options = []
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
import sys,subprocess
errno = subprocess.call([sys.executable, "runtests.py"])
raise SystemExit(errno)
def get_version():
"""build_version is replaced with the current build number
as part of the jenkins build job"""
build_version = 1
return build_version
def parse_requirements(file_name):
"""Taken from http://cburgmer.posterous.com/pip-requirementstxt-and-setuppy"""
requirements = []
for line in open(os.path.join(os.path.dirname(__file__), "config", file_name), "r"):
line = line.strip()
# comments and blank lines
if re.match(r"(^#)|(^$)", line):
continue
requirements.append(line)
return requirements
setup(
name="pettingzoo",
version="0.3.0" % get_version(),
url = "https://wiki.knewton.net/index.php/Tech",
author="Devon Jones",
author_email="devon@knewton.com",
license = "Apache",
packages=find_packages(),
scripts = ["bin/zncreate", "bin/zndelete"],
cmdclass = {"test": PyTest},
package_data = {"config": ["requirements*.txt"]},
install_requires=parse_requirements("requirements.txt"),
tests_require=parse_requirements("requirements.testing.txt"),
description = "Python edition of the PettingZoo framework.",
long_description = "\n" + open("README").read(),
)
|
Knewton/pettingzoo-python
|
setup.py
|
Python
|
apache-2.0
| 1,447 | 0.041465 |
import matplotlib.colors
import matplotlib.pyplot as plt
import numpy as np
from pcl_helper import *
def rgb_to_hsv(rgb_list):
rgb_normalized = [1.0*rgb_list[0]/255, 1.0*rgb_list[1]/255, 1.0*rgb_list[2]/255]
hsv_normalized = matplotlib.colors.rgb_to_hsv([[rgb_normalized]])[0][0]
return hsv_normalized
def compute_color_histograms(cloud, using_hsv=False):
# Compute histograms for the clusters
point_colors_list = []
# Step through each point in the point cloud
for point in pc2.read_points(cloud, skip_nans=True):
rgb_list = float_to_rgb(point[3])
if using_hsv:
point_colors_list.append(rgb_to_hsv(rgb_list) * 255)
else:
point_colors_list.append(rgb_list)
# Populate lists with color values
channel_1_vals = []
channel_2_vals = []
channel_3_vals = []
for color in point_colors_list:
channel_1_vals.append(color[0])
channel_2_vals.append(color[1])
channel_3_vals.append(color[2])
# Compute histograms
# Take histograms in R, G, and B or similar channels (HSV etc.)
r_hist = np.histogram(channel_1_vals, bins=32, range=(0, 256))
g_hist = np.histogram(channel_2_vals, bins=32, range=(0, 256))
b_hist = np.histogram(channel_3_vals, bins=32, range=(0, 256))
# Concatenate and normalize the histograms
hist_features = np.concatenate((r_hist[0], g_hist[0], b_hist[0])).astype(np.float64)
normed_features = hist_features / np.sum(hist_features)
return normed_features
def compute_normal_histograms(normal_cloud):
norm_x_vals = []
norm_y_vals = []
norm_z_vals = []
for norm_component in pc2.read_points(normal_cloud,
field_names = ('normal_x', 'normal_y', 'normal_z'),
skip_nans=True):
norm_x_vals.append(norm_component[0])
norm_y_vals.append(norm_component[1])
norm_z_vals.append(norm_component[2])
# Compute histograms of normal values (just like with color)
x_hist = np.histogram(norm_x_vals, bins=32, range=(0, 256))
y_hist = np.histogram(norm_y_vals, bins=32, range=(0, 256))
z_hist = np.histogram(norm_z_vals, bins=32, range=(0, 256))
# Concatenate and normalize the histograms
hist_features = np.concatenate((x_hist[0], y_hist[0], z_hist[0])).astype(np.float64)
normed_features = hist_features / np.sum(hist_features)
return normed_features
|
squared9/Robotics
|
Robotic_PR2_3D_Perception_Pick_And_Place/sensor_stick/src/sensor_stick/features.py
|
Python
|
mit
| 2,473 | 0.002831 |
axes = az.plot_forest(non_centered_data,
kind='ridgeplot',
var_names=['theta'],
combined=True,
ridgeplot_overlap=3,
colors='white',
figsize=(9, 7))
axes[0].set_title('Estimated theta for 8 schools model')
|
mcmcplotlib/mcmcplotlib
|
api/generated/arviz-plot_forest-3.py
|
Python
|
apache-2.0
| 367 | 0.016349 |
# -*- coding: utf-8 -*-
import numpy as np
import pytest
from pandas import Index, MultiIndex
@pytest.fixture
def idx():
# a MultiIndex used to test the general functionality of the
# general functionality of this object
major_axis = Index(['foo', 'bar', 'baz', 'qux'])
minor_axis = Index(['one', 'two'])
major_labels = np.array([0, 0, 1, 2, 3, 3])
minor_labels = np.array([0, 1, 0, 1, 0, 1])
index_names = ['first', 'second']
mi = MultiIndex(levels=[major_axis, minor_axis],
labels=[major_labels, minor_labels],
names=index_names, verify_integrity=False)
return mi
@pytest.fixture
def idx_dup():
# compare tests/indexes/multi/conftest.py
major_axis = Index(['foo', 'bar', 'baz', 'qux'])
minor_axis = Index(['one', 'two'])
major_labels = np.array([0, 0, 1, 0, 1, 1])
minor_labels = np.array([0, 1, 0, 1, 0, 1])
index_names = ['first', 'second']
mi = MultiIndex(levels=[major_axis, minor_axis],
labels=[major_labels, minor_labels],
names=index_names, verify_integrity=False)
return mi
@pytest.fixture
def index_names():
# names that match those in the idx fixture for testing equality of
# names assigned to the idx
return ['first', 'second']
@pytest.fixture
def holder():
# the MultiIndex constructor used to base compatibility with pickle
return MultiIndex
@pytest.fixture
def compat_props():
# a MultiIndex must have these properties associated with it
return ['shape', 'ndim', 'size']
|
cython-testbed/pandas
|
pandas/tests/indexes/multi/conftest.py
|
Python
|
bsd-3-clause
| 1,577 | 0 |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2016 Martine Lenders <mail@martine-lenders.eu>
#
# Distributed under terms of the MIT license.
from __future__ import print_function
import argparse
import os, sys
import random
import pexpect
import subprocess
import time
import types
DEFAULT_TIMEOUT = 5
class Strategy(object):
def __init__(self, func=None):
if func != None:
if sys.version_info < (3,):
self.__class__.execute = types.MethodType(func, self, self.__class__)
else:
self.__class__.execute = types.MethodType(func, self)
def execute(self, *args, **kwargs):
raise NotImplementedError()
class ApplicationStrategy(Strategy):
def __init__(self, app_dir=os.getcwd(), func=None):
super(ApplicationStrategy, self).__init__(func)
self.app_dir = app_dir
class BoardStrategy(Strategy):
def __init__(self, board, func=None):
super(BoardStrategy, self).__init__(func)
self.board = board
def __run_make(self, application, make_targets, env=None):
env = os.environ.copy()
if env != None:
env.update(env)
env.update(self.board.to_env())
cmd = ("make", "-C", application) + make_targets
print(' '.join(cmd))
print(subprocess.check_output(cmd, env=env))
def execute(self, application):
super(BoardStrategy, self).execute(application)
class CleanStrategy(BoardStrategy):
def execute(self, application, env=None):
super(CleanStrategy, self).__run_make(application, ("-B", "clean"), env)
class BuildStrategy(BoardStrategy):
def execute(self, application, env=None):
super(BuildStrategy, self).__run_make(application, ("all",), env)
class FlashStrategy(BoardStrategy):
def execute(self, application, env=None):
super(FlashStrategy, self).__run_make(application, ("all",), env)
class ResetStrategy(BoardStrategy):
def execute(self, application, env=None):
super(ResetStrategy, self).__run_make(application, ("reset",), env)
class Board(object):
def __init__(self, name, port=None, serial=None, clean=None,
build=None, flash=None,
reset=None, term=None):
def _reset_native_execute(obj, application, env=None, *args, **kwargs):
pass
if (name == "native") and (reset == None):
reset = _reset_native_execute
self.name = name
self.port = port
self.serial = serial
self.clean_strategy = CleanStrategy(self, clean)
self.build_strategy = BuildStrategy(self, build)
self.flash_strategy = FlashStrategy(self, flash)
self.reset_strategy = ResetStrategy(self, reset)
def __len__(self):
return 1
def __iter__(self):
return self
def next(self):
raise StopIteration()
def __repr__(self):
return ("<Board %s,port=%s,serial=%s>" %
(repr(self.name), repr(self.port), repr(self.serial)))
def to_env(self):
env = {}
if self.name:
env['BOARD'] = self.name
if self.port:
env['PORT'] = self.port
if self.serial:
env['SERIAL'] = self.serial
return env
def clean(self, application=os.getcwd(), env=None):
self.build_strategy.execute(application, env)
def build(self, application=os.getcwd(), env=None):
self.build_strategy.execute(application, env)
def flash(self, application=os.getcwd(), env=None):
self.flash_strategy.execute(application, env)
def reset(self, application=os.getcwd(), env=None):
self.reset_strategy.execute(application, env)
class BoardGroup(object):
def __init__(self, boards):
self.boards = boards
def __len__(self):
return len(self.boards)
def __iter__(self):
return iter(self.boards)
def __repr__(self):
return str(self.boards)
def clean(self, application=os.getcwd(), env=None):
for board in self.boards:
board.clean(application, env)
def build(self, application=os.getcwd(), env=None):
for board in self.boards:
board.build(application, env)
def flash(self, application=os.getcwd(), env=None):
for board in self.boards:
board.flash(application, env)
def reset(self, application=os.getcwd(), env=None):
for board in self.boards:
board.reset(application, env)
def default_test_case(board_group, application, env=None):
for board in board_group:
env = os.environ.copy()
if env != None:
env.update(env)
env.update(board.to_env())
with pexpect.spawn("make", ["-C", application, "term"], env=env,
timeout=DEFAULT_TIMEOUT,
logfile=sys.stdout) as spawn:
spawn.expect("TEST: SUCCESS")
class TestStrategy(ApplicationStrategy):
def execute(self, board_groups, test_cases=[default_test_case],
timeout=DEFAULT_TIMEOUT, env=None):
for board_group in board_groups:
print("Testing for %s: " % board_group)
for test_case in test_cases:
board_group.reset()
test_case(board_group, self.app_dir, env=None)
sys.stdout.write('.')
sys.stdout.flush()
print()
def get_ipv6_address(spawn):
spawn.sendline(u"ifconfig")
spawn.expect(u"[A-Za-z0-9]{2}[0-9]+: inet6 (fe80::[0-9a-f:]+)")
return spawn.match.group(1)
def test_ipv6_send(board_group, application, env=None):
env_sender = os.environ.copy()
if env != None:
env_sender.update(env)
env_sender.update(board_group.boards[0].to_env())
env_receiver = os.environ.copy()
if env != None:
env_receiver.update(env)
env_receiver.update(board_group.boards[1].to_env())
with pexpect.spawn("make", ["-C", application, "term"], env=env_sender,
timeout=DEFAULT_TIMEOUT) as sender, \
pexpect.spawn("make", ["-C", application, "term"], env=env_receiver,
timeout=DEFAULT_TIMEOUT) as receiver:
ipprot = random.randint(0x00, 0xff)
receiver_ip = get_ipv6_address(receiver)
receiver.sendline(u"ip server start %d" % ipprot)
# wait for neighbor discovery to be done
time.sleep(5)
sender.sendline(u"ip send %s %d 01:23:45:67:89:ab:cd:ef" % (receiver_ip, ipprot))
sender.expect_exact(u"Success: send 8 byte to %s (next header: %d)" %
(receiver_ip, ipprot))
receiver.expect(u"000000 60 00 00 00 00 08 %s ff fe 80 00 00 00 00 00 00" % hex(ipprot)[2:])
receiver.expect(u"000010( [0-9a-f]{2}){8} fe 80 00 00 00 00 00 00")
receiver.expect(u"000020( [0-9a-f]{2}){8} 01 23 45 67 89 ab cd ef")
def test_udpv6_send(board_group, application, env=None):
env_sender = os.environ.copy()
if env != None:
env_sender.update(env)
env_sender.update(board_group.boards[0].to_env())
env_receiver = os.environ.copy()
if env != None:
env_receiver.update(env)
env_receiver.update(board_group.boards[1].to_env())
with pexpect.spawn("make", ["-C", application, "term"], env=env_sender,
timeout=DEFAULT_TIMEOUT) as sender, \
pexpect.spawn("make", ["-C", application, "term"], env=env_receiver,
timeout=DEFAULT_TIMEOUT) as receiver:
port = random.randint(0x0000, 0xffff)
receiver_ip = get_ipv6_address(receiver)
receiver.sendline(u"udp server start %d" % port)
# wait for neighbor discovery to be done
time.sleep(5)
sender.sendline(u"udp send %s %d ab:cd:ef" % (receiver_ip, port))
sender.expect_exact(u"Success: send 3 byte to [%s]:%d" %
(receiver_ip, port))
receiver.expect(u"000000 ab cd ef")
def test_dual_send(board_group, application, env=None):
env_sender = os.environ.copy()
if env != None:
env_sender.update(env)
env_sender.update(board_group.boards[0].to_env())
env_receiver = os.environ.copy()
if env != None:
env_receiver.update(env)
env_receiver.update(board_group.boards[1].to_env())
with pexpect.spawn("make", ["-C", application, "term"], env=env_sender,
timeout=DEFAULT_TIMEOUT) as sender, \
pexpect.spawn("make", ["-C", application, "term"], env=env_receiver,
timeout=DEFAULT_TIMEOUT) as receiver:
port = random.randint(0x0000, 0xffff)
ipprot = random.randint(0x00, 0xff)
receiver_ip = get_ipv6_address(receiver)
receiver.sendline(u"ip server start %d" % ipprot)
receiver.sendline(u"udp server start %d" % port)
# wait for neighbor discovery to be done
time.sleep(5)
sender.sendline(u"udp send %s %d 01:23" % (receiver_ip, port))
sender.expect_exact(u"Success: send 2 byte to [%s]:%d" %
(receiver_ip, port))
receiver.expect(u"000000 01 23")
sender.sendline(u"ip send %s %d 01:02:03:04" % (receiver_ip, ipprot))
sender.expect_exact(u"Success: send 4 byte to %s (next header: %d)" %
(receiver_ip, ipprot))
receiver.expect(u"000000 60 00 00 00 00 04 %s ff fe 80 00 00 00 00 00 00" % hex(ipprot)[2:])
receiver.expect(u"000010( [0-9a-f]{2}){8} fe 80 00 00 00 00 00 00")
receiver.expect(u"000020( [0-9a-f]{2}){8} 01 02 03 04")
if __name__ == "__main__":
del os.environ['TERMFLAGS']
TestStrategy().execute([BoardGroup((Board("native", "tap0"), \
Board("native", "tap1")))], \
[test_ipv6_send, test_udpv6_send, test_dual_send])
|
alignan/RIOT
|
tests/lwip/tests/01-run.py
|
Python
|
lgpl-2.1
| 9,890 | 0.003539 |
from ij import IJ
from ij.gui import NonBlockingGenericDialog
from ij import WindowManager
from ij.gui import WaitForUserDialog
from ij import ImageStack
from ij import ImagePlus
theImage = IJ.getImage()
sourceImages = []
if theImage.getNChannels() == 1:
IJ.run("8-bit")
sourceImages.append(theImage)
else:
sourceImages = ChannelSplitter.split(theImage)
sourceNames = []
for im in sourceImages:
im.show()
sourceNames.append(im.getTitle())
gd0 = NonBlockingGenericDialog("Select source image...")
gd0.addChoice("Source image",sourceNames,sourceNames[0])
gd0.showDialog()
if (gd0.wasOKed()):
chosenImage = gd0.getNextChoice()
theImage = WindowManager.getImage(chosenImage)
IJ.selectWindow(chosenImage)
else:
theImage = sourceImages[0]
IJ.selectWindow(sourceNames[0])
gd = NonBlockingGenericDialog("Set slice params...")
gd.addNumericField("Slice start:",1,0)
gd.addNumericField("Slice end:",theImage.getNSlices(),0)
gd.showDialog()
if (gd.wasOKed()):
## Selecting the ROI over the stack
startSlice = int(gd.getNextNumber())
endSlice = gd.getNextNumber()
width = theImage.getWidth()
height = theImage.getHeight()
roiArray = []
for i in range(startSlice,endSlice+1):
theImage.setSlice(i)
bp = theImage.getProcessor().duplicate()
bp.setColor(0)
doStaySlice = True
while doStaySlice:
waiter = WaitForUserDialog("Draw ROI","Draw ROI, then hit OK")
waiter.show()
roi = theImage.getRoi()
if roi is None:
doStaySlice = True
else:
doStaySlice = False
roiArray.append(roi)
## Applying the ROI to each channel
newStacks = []
castImages = []
for procImage in sourceImages:
newStacks.append(ImageStack(width,height))
ns = newStacks[-1]
for i in range(startSlice,endSlice+1):
procImage.setSliceWithoutUpdate(i)
bp = procImage.getProcessor().duplicate()
bp.fillOutside(roiArray[i-startSlice])
ns.addSlice(bp)
castImages.append(ImagePlus(procImage.getShortTitle()+"_cast",ns))
## Displays the output
for castImage in castImages:
castImage.show()
## Cleans up the windows
for sourceImage in sourceImages:
sourceImage.close()
|
stalepig/deep-mucosal-imaging
|
dmi_0.3/Isolate_stack_ROI2.py
|
Python
|
gpl-2.0
| 2,120 | 0.034906 |
"""The tests for the Script component."""
# pylint: disable=too-many-public-methods,protected-access
from datetime import timedelta
from unittest import mock
import unittest
# Otherwise can't test just this file (import order issue)
import homeassistant.components # noqa
import homeassistant.util.dt as dt_util
from homeassistant.helpers import script, config_validation as cv
from tests.common import fire_time_changed, get_test_home_assistant
ENTITY_ID = 'script.test'
class TestScriptHelper(unittest.TestCase):
"""Test the Script component."""
def setUp(self): # pylint: disable=invalid-name
"""Setup things to be run when tests are started."""
self.hass = get_test_home_assistant()
def tearDown(self): # pylint: disable=invalid-name
"""Stop down everything that was started."""
self.hass.stop()
def test_firing_event(self):
"""Test the firing of events."""
event = 'test_event'
calls = []
def record_event(event):
"""Add recorded event to set."""
calls.append(event)
self.hass.bus.listen(event, record_event)
script_obj = script.Script(self.hass, cv.SCRIPT_SCHEMA({
'event': event,
'event_data': {
'hello': 'world'
}
}))
script_obj.run()
self.hass.block_till_done()
assert len(calls) == 1
assert calls[0].data.get('hello') == 'world'
assert not script_obj.can_cancel
def test_calling_service(self):
"""Test the calling of a service."""
calls = []
def record_call(service):
"""Add recorded event to set."""
calls.append(service)
self.hass.services.register('test', 'script', record_call)
script.call_from_config(self.hass, {
'service': 'test.script',
'data': {
'hello': 'world'
}
})
self.hass.block_till_done()
assert len(calls) == 1
assert calls[0].data.get('hello') == 'world'
def test_calling_service_template(self):
"""Test the calling of a service."""
calls = []
def record_call(service):
"""Add recorded event to set."""
calls.append(service)
self.hass.services.register('test', 'script', record_call)
script.call_from_config(self.hass, {
'service_template': """
{% if True %}
test.script
{% else %}
test.not_script
{% endif %}""",
'data_template': {
'hello': """
{% if True %}
world
{% else %}
Not world
{% endif %}
"""
}
})
self.hass.block_till_done()
assert len(calls) == 1
assert calls[0].data.get('hello') == 'world'
def test_delay(self):
"""Test the delay."""
event = 'test_event'
events = []
def record_event(event):
"""Add recorded event to set."""
events.append(event)
self.hass.bus.listen(event, record_event)
script_obj = script.Script(self.hass, cv.SCRIPT_SCHEMA([
{'event': event},
{'delay': {'seconds': 5}},
{'event': event}]))
script_obj.run()
self.hass.block_till_done()
assert script_obj.is_running
assert script_obj.can_cancel
assert script_obj.last_action == event
assert len(events) == 1
future = dt_util.utcnow() + timedelta(seconds=5)
fire_time_changed(self.hass, future)
self.hass.block_till_done()
assert not script_obj.is_running
assert len(events) == 2
def test_delay_template(self):
"""Test the delay as a template."""
event = 'test_evnt'
events = []
def record_event(event):
"""Add recorded event to set."""
events.append(event)
self.hass.bus.listen(event, record_event)
script_obj = script.Script(self.hass, cv.SCRIPT_SCHEMA([
{'event': event},
{'delay': '00:00:{{ 5 }}'},
{'event': event}]))
script_obj.run()
self.hass.block_till_done()
assert script_obj.is_running
assert script_obj.can_cancel
assert script_obj.last_action == event
assert len(events) == 1
future = dt_util.utcnow() + timedelta(seconds=5)
fire_time_changed(self.hass, future)
self.hass.block_till_done()
assert not script_obj.is_running
assert len(events) == 2
def test_cancel_while_delay(self):
"""Test the cancelling while the delay is present."""
event = 'test_event'
events = []
def record_event(event):
"""Add recorded event to set."""
events.append(event)
self.hass.bus.listen(event, record_event)
script_obj = script.Script(self.hass, cv.SCRIPT_SCHEMA([
{'delay': {'seconds': 5}},
{'event': event}]))
script_obj.run()
self.hass.block_till_done()
assert script_obj.is_running
assert len(events) == 0
script_obj.stop()
assert not script_obj.is_running
# Make sure the script is really stopped.
future = dt_util.utcnow() + timedelta(seconds=5)
fire_time_changed(self.hass, future)
self.hass.block_till_done()
assert not script_obj.is_running
assert len(events) == 0
def test_passing_variables_to_script(self):
"""Test if we can pass variables to script."""
calls = []
def record_call(service):
"""Add recorded event to set."""
calls.append(service)
self.hass.services.register('test', 'script', record_call)
script_obj = script.Script(self.hass, cv.SCRIPT_SCHEMA([
{
'service': 'test.script',
'data_template': {
'hello': '{{ greeting }}',
},
},
{'delay': {'seconds': 5}},
{
'service': 'test.script',
'data_template': {
'hello': '{{ greeting2 }}',
},
}]))
script_obj.run({
'greeting': 'world',
'greeting2': 'universe',
})
self.hass.block_till_done()
assert script_obj.is_running
assert len(calls) == 1
assert calls[-1].data['hello'] == 'world'
future = dt_util.utcnow() + timedelta(seconds=5)
fire_time_changed(self.hass, future)
self.hass.block_till_done()
assert not script_obj.is_running
assert len(calls) == 2
assert calls[-1].data['hello'] == 'universe'
def test_condition(self):
"""Test if we can use conditions in a script."""
event = 'test_event'
events = []
def record_event(event):
"""Add recorded event to set."""
events.append(event)
self.hass.bus.listen(event, record_event)
self.hass.states.set('test.entity', 'hello')
script_obj = script.Script(self.hass, cv.SCRIPT_SCHEMA([
{'event': event},
{
'condition': 'template',
'value_template': '{{ states.test.entity.state == "hello" }}',
},
{'event': event},
]))
script_obj.run()
self.hass.block_till_done()
assert len(events) == 2
self.hass.states.set('test.entity', 'goodbye')
script_obj.run()
self.hass.block_till_done()
assert len(events) == 3
@mock.patch('homeassistant.helpers.script.condition.async_from_config')
def test_condition_created_once(self, async_from_config):
"""Test that the conditions do not get created multiple times."""
event = 'test_event'
events = []
def record_event(event):
"""Add recorded event to set."""
events.append(event)
self.hass.bus.listen(event, record_event)
self.hass.states.set('test.entity', 'hello')
script_obj = script.Script(self.hass, cv.SCRIPT_SCHEMA([
{'event': event},
{
'condition': 'template',
'value_template': '{{ states.test.entity.state == "hello" }}',
},
{'event': event},
]))
script_obj.run()
script_obj.run()
self.hass.block_till_done()
assert async_from_config.call_count == 1
assert len(script_obj._config_cache) == 1
def test_all_conditions_cached(self):
"""Test that multiple conditions get cached."""
event = 'test_event'
events = []
def record_event(event):
"""Add recorded event to set."""
events.append(event)
self.hass.bus.listen(event, record_event)
self.hass.states.set('test.entity', 'hello')
script_obj = script.Script(self.hass, cv.SCRIPT_SCHEMA([
{'event': event},
{
'condition': 'template',
'value_template': '{{ states.test.entity.state == "hello" }}',
},
{
'condition': 'template',
'value_template': '{{ states.test.entity.state != "hello" }}',
},
{'event': event},
]))
script_obj.run()
self.hass.block_till_done()
assert len(script_obj._config_cache) == 2
|
Smart-Torvy/torvy-home-assistant
|
tests/helpers/test_script.py
|
Python
|
mit
| 9,704 | 0 |
# This file is part of Booktype.
# Copyright (c) 2012 Aleksandar Erkalovic <aleksandar.erkalovic@sourcefabric.org>
#
# Booktype 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.
#
# Booktype 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 Booktype. If not, see <http://www.gnu.org/licenses/>.
from django.db import transaction
from booki.editor import models
from booki.utils import security
def remote_get_status_messages(request, message, groupid):
from booki.statusnet.models import searchMessages
group = models.BookiGroup.objects.get(url_name=groupid)
mess = searchMessages('%%23%s' % group.url_name)
# remove this hard code
messages = ['<a href="http://status.flossmanuals.net/notice/%s">%s: %s</a>' % (m['id'], m['from_user'], m['text']) for m in mess['results']]
return {"list": messages}
def remote_init_group(request, message, groupid):
import sputnik
## get online users
try:
_onlineUsers = sputnik.smembers("sputnik:channel:%s:users" % message["channel"])
except:
_onlineUsers = []
if request.user.username not in _onlineUsers:
try:
sputnik.sadd("sputnik:channel:%s:users" % message["channel"], request.user.username)
except:
pass
return {}
def remote_leave_group(request, message, groupid):
group = models.BookiGroup.objects.get(url_name=groupid)
group.members.remove(request.user)
transaction.commit()
return {"result": True}
def remote_join_group(request, message, groupid):
group = models.BookiGroup.objects.get(url_name=groupid)
group.members.add(request.user)
transaction.commit()
return {"result": True}
|
aerkalov/Booktype
|
lib/booki/channels/group.py
|
Python
|
agpl-3.0
| 2,141 | 0.004671 |
#!/usr/bin/env python
import subprocess
import re
import os
import errno
import collections
import sys
class Platform(object):
pass
sdk_re = re.compile(r'.*-sdk ([a-zA-Z0-9.]*)')
def sdkinfo(sdkname):
ret = {}
for line in subprocess.Popen(['xcodebuild', '-sdk', sdkname, '-version'], stdout=subprocess.PIPE).stdout:
kv = line.strip().split(': ', 1)
if len(kv) == 2:
k,v = kv
ret[k] = v
return ret
sim_sdk_info = sdkinfo('iphonesimulator')
device_sdk_info = sdkinfo('iphoneos')
def latest_sdks():
latest_sim = None
latest_device = None
for line in subprocess.Popen(['xcodebuild', '-showsdks'], stdout=subprocess.PIPE).stdout:
match = sdk_re.match(line)
if match:
if 'Simulator' in line:
latest_sim = match.group(1)
elif 'iOS' in line:
latest_device = match.group(1)
return latest_sim, latest_device
sim_sdk, device_sdk = latest_sdks()
class simulator_platform(Platform):
sdk='iphonesimulator'
arch = 'i386'
name = 'simulator'
triple = 'i386-apple-darwin10'
sdkroot = sim_sdk_info['Path']
prefix = "#if !defined(__arm__) && defined(__i386__)\n\n"
suffix = "\n\n#endif"
class device_platform(Platform):
sdk='iphoneos'
name = 'ios'
arch = 'armv7'
triple = 'arm-apple-darwin10'
sdkroot = device_sdk_info['Path']
prefix = "#ifdef __arm__\n\n"
suffix = "\n\n#endif"
def move_file(src_dir, dst_dir, filename, file_suffix=None, prefix='', suffix=''):
if not os.path.exists(dst_dir):
os.makedirs(dst_dir)
out_filename = filename
if file_suffix:
split_name = os.path.splitext(filename)
out_filename = "%s_%s%s" % (split_name[0], file_suffix, split_name[1])
with open(os.path.join(src_dir, filename)) as in_file:
with open(os.path.join(dst_dir, out_filename), 'w') as out_file:
if prefix:
out_file.write(prefix)
out_file.write(in_file.read())
if suffix:
out_file.write(suffix)
headers_seen = collections.defaultdict(set)
def move_source_tree(src_dir, dest_dir, dest_include_dir, arch=None, prefix=None, suffix=None):
for root, dirs, files in os.walk(src_dir, followlinks=True):
relroot = os.path.relpath(root,src_dir)
def move_dir(arch, prefix='', suffix='', files=[]):
for file in files:
file_suffix = None
if file.endswith('.h'):
if dest_include_dir:
file_suffix = arch
if arch:
headers_seen[file].add(arch)
move_file(root, dest_include_dir, file, arch, prefix=prefix, suffix=suffix)
elif dest_dir:
outroot = os.path.join(dest_dir, relroot)
move_file(root, outroot, file, prefix=prefix, suffix=suffix)
if relroot == '.':
move_dir(arch=arch,
files=files,
prefix=prefix,
suffix=suffix)
elif relroot == 'arm':
move_dir(arch='arm',
prefix="#ifdef __arm__\n\n",
suffix="\n\n#endif",
files=files)
elif relroot == 'x86':
move_dir(arch='i386',
prefix="#if !defined(__arm__) && defined(__i386__)\n\n",
suffix="\n\n#endif",
files=files)
def build_target(platform):
def xcrun_cmd(cmd):
return subprocess.check_output(['xcrun', '-sdk', platform.sdkroot, '-find', cmd]).strip()
build_dir = 'build_' + platform.name
if not os.path.exists(build_dir):
os.makedirs(build_dir)
env = dict(CC=xcrun_cmd('clang'),
LD=xcrun_cmd('ld'),
CFLAGS='-arch %s -isysroot %s -miphoneos-version-min=4.0' % (platform.arch, platform.sdkroot))
working_dir=os.getcwd()
try:
os.chdir(build_dir)
subprocess.check_call(['../configure', '-host', platform.triple], env=env)
move_source_tree('.', None, '../ios/include',
arch=platform.arch,
prefix=platform.prefix,
suffix=platform.suffix)
move_source_tree('./include', None, '../ios/include',
arch=platform.arch,
prefix=platform.prefix,
suffix=platform.suffix)
finally:
os.chdir(working_dir)
for header_name, archs in headers_seen.iteritems():
basename, suffix = os.path.splitext(header_name)
def main():
move_source_tree('src', 'ios/src', 'ios/include')
move_source_tree('include', None, 'ios/include')
build_target(simulator_platform)
build_target(device_platform)
for header_name, archs in headers_seen.iteritems():
basename, suffix = os.path.splitext(header_name)
with open(os.path.join('ios/include', header_name), 'w') as header:
for arch in archs:
header.write('#include <%s_%s%s>\n' % (basename, arch, suffix))
if __name__ == '__main__':
main()
|
teeple/pns_server
|
work/install/Python-2.7.4/Modules/_ctypes/libffi/generate-ios-source-and-headers.py
|
Python
|
gpl-2.0
| 5,303 | 0.005846 |
from itertools import product, repeat, chain, ifilter, imap
from multiprocessing import Pool, cpu_count
from sklearn.preprocessing import binarize
from utils.profiling import profile
from numpy.random import randint
from functools import partial
from random import sample
import numpy as np
import logging
logger = logging.getLogger(__name__)
def on_edge(mask, x, y):
""" checks if the point defined with coordinates x and y lies on the edge
of a pedestrian on the pedestrian mask
to lie on an edge is defined by having at least one non-pedestrian
pixel in the surrouding of the given pixel (left, right, up or down)
e.g. we're checking if the middle pixel is an edge one
0 1 1
... 0 1 1 ... -> on_edge? True
0 0 1
0 1 1
... 1 1 1 ... -> on_edge? False
0 1 1
mask: array-like
two dimensional array of binarized pixels
x: int
point coordinate on the x-axis
y: int
point coordinate on the y-axis
returns: bool
a boolean stating weather the point lies on the edge of the
pedestrian
"""
return mask[x, y] and not all([mask[x + dx, y + dy] for dx, dy in
zip([-1, 1, 0, 0], [0, 0, -1, 1])])
def window(image, d, x, y):
""" extracts a window of size d pixels in each direction from the point
defined by x and y coordinates
total number of pixels in the window is (2 * d + 1)^2
window is binarized if not already binary and reshaped to a vector
e.g. d = 2, P(x, y)
0 0 0 0 0 0 0 0 0 0
-----------
0 | 0 0 0 0 0 | 0 0 1 1
0 | 0 0 0 0 0 | 1 1 1 1
0 | 0 0 P 0 1 | 1 1 1 1
0 | 0 0 0 0 1 | 1 1 1 1
0 | 0 0 0 1 1 | 1 1 1 1
-----------
0 0 0 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 1 1
0 0 0 1 1 1 1 1 1 1
image: array-like
two dimensional array
d: int
number of pixels to take in each direction from the center
x: int
x coordinate of the window center
y: int
x coordinate of the window center
returns: array
a binary array with (2 * d + 1)^2 elements
"""
b, g, r = image
w = lambda img: img[(x - d):(x + d + 1), (y - d):(y + d + 1)].reshape(-1)
return binarize(np.hstack([w(b), w(g), w(r)]), 0.5)
def samples(s, d):
""" generates classifier input samples from a dataset sample
s: object
compatible with the sample class interface
d: int
number of pixels to take in each direction from the center when
generating an input sample via the moving window
return: list of tuples
tuples contain two elements, an input vector and a target vector
extracted from a given sample
"""
shape = s.proc[0].shape
# generate a cartesian product of all possible point coordinates given
# image shape and offset d
# filter out all points not representing pedestrian mask edges
# compute input vectors for all remaining points from their respective
# windows
positive = imap(lambda xy: (window(s.proc, d, *xy), 1),
ifilter(lambda xy: on_edge(s.mask, *xy),
product(*map(lambda x: xrange(d, x - d),
shape))))
# create an infinite uniform random sampling list of point coordinates
# inside the given image
# filter out all points representing positive examples to get an infinite
# list of point coordinates representing negative examples
# compute input vectors for all points from their respective windows
negative = imap(lambda xy: (window(s.proc, d, *xy), 0),
ifilter(lambda xy: not s.mask.item(*xy),
imap(lambda o: map(lambda x: randint(d, x - d), o),
repeat(shape))))
# zip a finite list of positive examples and an infinite list of negative
# examples to get an equal amount of positive and negative examples and has
# a length of len(positive)
# chain all the zipped elements to get a flattened list of examples
# containing both positive and negative examples in one list
return list(chain(*zip(positive, negative)))
def generate(dataset, w, threaded=True):
""" generate a list of classifier data samples from all dataset samples
with a parallel implementation using a thread pool
dataset: object
object containing samples list compatible with the sample class
interface
w: int
size of the window used to extract features from an image
must be an odd number
returns: iterator
iterator contains all the positive and negative data samples
generated from the dataset
"""
if not threaded:
logger.info('extracting samples using 1 thread')
return chain(*map(partial(samples, d=(w - 1) / 2), dataset.samples))
logger.info('extracting samples using {0} threads'.format(cpu_count()))
return chain(*pool.map(partial(samples, d=(w - 1) / 2), dataset.samples))
@profile
def extract(dataset, w=11, N=25000, threaded=True):
""" extracts the training inputs and targets from the dataset
dataset: object
object containing samples list compatible with the sample class
interface
w: int
size of the window used to extract features from an image
must be an odd number
N: int
the number of samples to extract from the dataset. samples are
extracted randomly from the list of all possible samples
must be positive
returns: tuple of numpy arrays
the tuple contains two numpy arrays, one represents an input two
dimensional array and the other one represents a target vector
"""
assert(w % 2 == 1)
assert(N > 0)
# generates a list of data samples used in the model training
#
# randomly samples the list of samples and returns a maximum of
# N data samples as tuples of (input, target) vectors
#
# zips the sample tuples to divide input vectors in a separate tuple and
# target vectors in a separate tuple
ins, ts = zip(*sample(list(generate(dataset, w, threaded=threaded)), N))
# vertically concatenates list of numpy arrays and concatenates a list
# of target vectors to a numpy array
return (np.vstack(ins), np.array(ts))
# process pool for concurrent sample generation
pool = Pool(cpu_count())
|
dominiktomicevic/pedestrian
|
classifier/extractor.py
|
Python
|
mit
| 6,723 | 0.000149 |
#!/bin/env python
# Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Unittests that verify that the various test_types (e.g., simplified_diff)
are working."""
import difflib
import os
import unittest
from test_types import simplified_text_diff
class SimplifiedDiffUnittest(unittest.TestCase):
def testSimplifiedDiff(self):
"""Compares actual output with expected output for some test cases. The
simplified diff of these test cases should be the same."""
test_names = [
'null-offset-parent',
'textAreaLineHeight',
'form-element-geometry',
]
differ = simplified_text_diff.SimplifiedTextDiff(None)
for prefix in test_names:
output_filename = os.path.join(self.GetTestDataDir(),
prefix + "-actual-win.txt")
expected_filename = os.path.join(self.GetTestDataDir(),
prefix + "-expected.txt")
output = differ._SimplifyText(open(output_filename).read())
expected = differ._SimplifyText(open(expected_filename).read())
if output != expected:
lst = difflib.unified_diff(expected.splitlines(True),
output.splitlines(True),
'expected',
'actual')
for line in lst:
print line.rstrip()
self.failUnlessEqual(output, expected)
def GetTestDataDir(self):
return os.path.join(os.path.abspath('testdata'), 'difftests')
if '__main__' == __name__:
unittest.main()
|
amyvmiwei/chromium
|
webkit/tools/layout_tests/layout_package/test_types_unittest.py
|
Python
|
bsd-3-clause
| 1,667 | 0.007798 |
from erukar.system.engine import Enemy, BasicAI
from ..templates.Undead import Undead
from erukar.content.inventory import Shortsword, Buckler
from erukar.content.modifiers import Steel, Oak
class Skeleton(Undead):
ClassName = 'Skeleton'
ClassLevel = 1
BaseMitigations = {
'bludgeoning': (-0.25, 0),
'piercing': (0.2, 0),
'slashing': (0.15, 0)
}
BriefDescription = "a skeleton holding a {describe|right} and a {describe|left}."
def init_stats(self):
self.strength = 5
self.dexterity = 4
self.vitality = -1
self.acuity = -2
self.sense = -2
def init_personality(self):
self.ai_module = BasicAI(self)
self.str_ratio = 0.4
self.dex_ratio = 0.3
self.vit_ratio = 0.2
self.acu_ratio = 0.0
self.sen_ratio = 0.0
self.res_ratio = 0.1
self.stat_points = 8
def init_inventory(self):
self.left = Buckler(modifiers=[Oak])
self.right = Shortsword(modifiers=[Steel])
self.inventory = [self.left, self.right]
|
etkirsch/legends-of-erukar
|
erukar/content/enemies/undead/Skeleton.py
|
Python
|
agpl-3.0
| 1,103 | 0.012693 |
from django.contrib import sitemaps
from django.core.urlresolvers import reverse
from .models import Artist, Song, User
class StaticViewSitemap(sitemaps.Sitemap):
changefreq = "weekly"
priority = 0.5
def items(self):
return ['index', 'popular', 'recently_added', 'search', 'contact']
def location(self, item):
return reverse('chords:' + item)
class SongSitemap(sitemaps.Sitemap):
changefreq = "weekly"
priority = 0.5
def items(self):
return Song.objects.filter(published=True)
def lastmod(self, obj):
return obj.mod_date
class ArtistSitemap(sitemaps.Sitemap):
changefreq = "weekly"
priority = 0.5
def items(self):
return Artist.objects.all()
class UserSitemap(sitemaps.Sitemap):
changefreq = "monthly"
priority = 0.5
def items(self):
return User.objects.all()
def location(self, user):
return reverse('chords:user', args=(user.get_username(),))
|
Ilias95/guitarchords
|
chords/sitemaps.py
|
Python
|
mit
| 977 | 0 |
# -*- coding: utf-8 -*-
#
# SRL 5 documentation build configuration file, created by
# sphinx-quickstart on Sat Oct 16 15:51:55 2010.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys, os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.append(os.path.abspath('.'))
# -- General configuration -----------------------------------------------------
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
#extensions = ['sphinx.ext.pngmath', 'sphinx.ext.jsmath']
extensions = []
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'SRL 5'
copyright = u'2010, SRL Developers'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '5'
# The full version, including alpha/beta/rc tags.
release = '1'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of documents that shouldn't be included in the build.
#unused_docs = []
# List of directories, relative to source directory, that shouldn't be searched
# for source files.
exclude_trees = ['_build']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. Major themes that come with
# Sphinx are currently 'default' and 'sphinxdoc'.
html_theme = 'nature'
#html_theme = 'default'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_use_modindex = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = ''
# Output file base name for HTML help builder.
htmlhelp_basename = 'SRL5doc'
# -- Options for LaTeX output --------------------------------------------------
# The paper size ('letter' or 'a4').
#latex_paper_size = 'letter'
# The font size ('10pt', '11pt' or '12pt').
#latex_font_size = '10pt'
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'SRL5.tex', u'SRL 5 Documentation',
u'SRL Developers', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# Additional stuff for the LaTeX preamble.
#latex_preamble = ''
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_use_modindex = True
|
SRL/SRL-5
|
doc/sphinx/conf.py
|
Python
|
gpl-3.0
| 6,360 | 0.006918 |
#
# ImageViewAgg.py -- a backend for Ginga using the aggdraw library
#
# This is open-source software licensed under a BSD license.
# Please see the file LICENSE.txt for details.
import numpy
from io import BytesIO
import aggdraw as agg
from . import AggHelp
from ginga import ImageView
from ginga.aggw.CanvasRenderAgg import CanvasRenderer
try:
import PIL.Image as PILimage
have_PIL = True
except ImportError:
have_PIL = False
class ImageViewAggError(ImageView.ImageViewError):
pass
class ImageViewAgg(ImageView.ImageViewBase):
def __init__(self, logger=None, rgbmap=None, settings=None):
ImageView.ImageViewBase.__init__(self, logger=logger,
rgbmap=rgbmap,
settings=settings)
self.surface = None
self._rgb_order = 'RGBA'
self.renderer = CanvasRenderer(self)
self.message = None
# cursors
self.cursor = {}
self.t_.setDefaults(show_pan_position=False,
onscreen_ff='Sans Serif')
def get_surface(self):
return self.surface
def render_image(self, rgbobj, dst_x, dst_y):
"""Render the image represented by (rgbobj) at dst_x, dst_y
in the pixel space.
"""
if self.surface is None:
return
canvas = self.surface
self.logger.debug("redraw surface")
# get window contents as a buffer and load it into the AGG surface
rgb_buf = self.getwin_buffer(order=self._rgb_order)
canvas.fromstring(rgb_buf)
cr = AggHelp.AggContext(canvas)
# Draw a cross in the center of the window in debug mode
if self.t_['show_pan_position']:
ctr_x, ctr_y = self.get_center()
pen = cr.get_pen('red')
canvas.line((ctr_x - 10, ctr_y, ctr_x + 10, ctr_y), pen)
canvas.line((ctr_x, ctr_y - 10, ctr_x, ctr_y + 10), pen)
# render self.message
if self.message:
font = cr.get_font(self.t_['onscreen_ff'], 24.0, self.img_fg)
wd, ht = cr.text_extents(self.message, font)
imgwin_wd, imgwin_ht = self.get_window_size()
y = ((imgwin_ht // 3) * 2) - (ht // 2)
x = (imgwin_wd // 2) - (wd // 2)
canvas.text((x, y), self.message, font)
# for debugging
#self.save_rgb_image_as_file('/tmp/temp.png', format='png')
def configure_surface(self, width, height):
# create agg surface the size of the window
self.surface = agg.Draw("RGBA", (width, height), 'black')
# inform the base class about the actual window size
self.configure(width, height)
def get_image_as_array(self):
if self.surface is None:
raise ImageViewAggError("No AGG surface defined")
# TODO: could these have changed between the time that self.surface
# was last updated?
wd, ht = self.get_window_size()
# Get agg surface as a numpy array
surface = self.get_surface()
arr8 = numpy.fromstring(surface.tostring(), dtype=numpy.uint8)
arr8 = arr8.reshape((ht, wd, 4))
return arr8
def get_image_as_buffer(self, output=None):
if self.surface is None:
raise ImageViewAggError("No AGG surface defined")
obuf = output
if obuf is None:
obuf = BytesIO()
surface = self.get_surface()
obuf.write(surface.tostring())
if not (output is None):
return None
return obuf.getvalue()
def get_rgb_image_as_buffer(self, output=None, format='png', quality=90):
if not have_PIL:
raise ImageViewAggError("Please install PIL to use this method")
if self.surface is None:
raise ImageViewAggError("No AGG surface defined")
obuf = output
if obuf is None:
obuf = BytesIO()
# Get current surface as an array
arr8 = self.get_image_as_array()
# make a PIL image
image = PILimage.fromarray(arr8)
image.save(obuf, format=format, quality=quality)
if not (output is None):
return None
return obuf.getvalue()
def get_rgb_image_as_bytes(self, format='png', quality=90):
buf = self.get_rgb_image_as_buffer(format=format, quality=quality)
return buf
def save_rgb_image_as_file(self, filepath, format='png', quality=90):
if not have_PIL:
raise ImageViewAggError("Please install PIL to use this method")
if self.surface is None:
raise ImageViewAggError("No AGG surface defined")
with open(filepath, 'w') as out_f:
self.get_rgb_image_as_buffer(output=out_f, format=format,
quality=quality)
self.logger.debug("wrote %s file '%s'" % (format, filepath))
def update_image(self):
# subclass implements this method to actually update a widget
# from the agg surface
self.logger.warning("Subclass should override this method")
return False
def set_cursor(self, cursor):
# subclass implements this method to actually set a defined
# cursor on a widget
self.logger.warning("Subclass should override this method")
def reschedule_redraw(self, time_sec):
# subclass implements this method to call delayed_redraw() after
# time_sec
self.delayed_redraw()
def define_cursor(self, ctype, cursor):
self.cursor[ctype] = cursor
def get_cursor(self, ctype):
return self.cursor[ctype]
def switch_cursor(self, ctype):
self.set_cursor(self.cursor[ctype])
def get_rgb_order(self):
return self._rgb_order
def onscreen_message(self, text, delay=None):
# subclass implements this method using a timer
self.logger.warning("Subclass should override this method")
def show_pan_mark(self, tf):
self.t_.set(show_pan_position=tf)
self.redraw(whence=3)
#END
|
rupak0577/ginga
|
ginga/aggw/ImageViewAgg.py
|
Python
|
bsd-3-clause
| 6,082 | 0.000658 |
# -*- coding: utf-8 -*-
import os
import os.path
import tempfile
from django.db import models
from django.conf import settings
from django.contrib.auth.models import User
from django.dispatch import receiver
from registration.signals import user_activated
from imagekit.models import ImageSpecField
from imagekit.processors import Resize
from PIL import Image
class Kategorie(models.Model):
title = models.CharField(max_length=50)
slug = models.CharField(max_length=20, unique=True)
intro = models.TextField(blank=True)
details = models.TextField(blank=True)
position = models.IntegerField(default=0)
def __unicode__(self):
return self.title
class WhiteBackground(object):
def process(self, image):
bg = Image.new("RGBA", image.size, (255, 255, 255, 255))
bg.paste(image, (0,0), )
return bg
class Kapitel(models.Model):
'''Ein Kapitel des "Tutorials".'''
KATEGORIE_CHOICES = [('0', 'Einstieg'),
('1', 'Schleifen'),
('2', 'Funktionen'),
('3', 'Bedingungen'),
('4', 'Für Fortgeschrittene'),
]
titel = models.CharField(max_length=50)
zusammenfassung = models.TextField(max_length=500)
kategorie = models.CharField(choices=KATEGORIE_CHOICES, max_length=2)
platz = models.FloatField()
quelltext = models.TextField(max_length=50000)
doccoHTML = models.TextField(max_length=100000)
bild = models.ImageField(upload_to='tutorial')
docbild = ImageSpecField([WhiteBackground(), Resize(400, 400), ], source='bild', format='JPEG', )
thumbnail = ImageSpecField([WhiteBackground(), Resize(80, 80), ], source='bild', format='JPEG', )
def __unicode__(self):
return u'%s (%s/%d)' % (self.titel, self.kategorie, self.platz)
def save(self, *args, **kwargs):
# fill doccoHTML
sourcefile = tempfile.NamedTemporaryFile(delete=False, dir=settings.TMP_PATH, suffix='.coffee')
sourcefile.write('# ' + self.titel.encode('utf8') + '\n')
sourcefile.write('# ' + '-' * len(self.titel.encode('utf8')) + '\n# \n')
sourcefile.write(self.quelltext.encode('utf8'))
sourcefile.close()
path = tempfile.mkdtemp(dir=settings.TMP_PATH)
os.system('docco -t %s/template.jst -o %s %s' % (settings.DOCCO_TEMPLATE_PATH, path, sourcefile.name))
with open(os.path.join(path, os.path.basename(sourcefile.name)[:-7] + '.html')) as resultfile:
self.doccoHTML = resultfile.read().decode('utf8')
super(Kapitel, self).save(*args, **kwargs)
class Beispiel(models.Model):
'''Ein Beispiel in der Gallerie'''
titel = models.CharField(max_length=50)
autor = models.CharField(max_length=200)
quelltext = models.TextField(max_length=50000)
doccoHTML = models.TextField(max_length=100000)
bild = models.ImageField(upload_to='tutorial')
docbild = ImageSpecField([WhiteBackground(), Resize(400, 400), ], source='bild', format='JPEG', )
thumbnail = ImageSpecField([WhiteBackground(), Resize(200, 200), ], source='bild', format='JPEG', )
updated = models.DateTimeField(auto_now=True)
category = models.ForeignKey(Kategorie, null=True, blank=True)
def __unicode__(self):
return u'%s (%s)' % (self.titel, unicode(self.updated))
def save(self, *args, **kwargs):
# fill doccoHTML
sourcefile = tempfile.NamedTemporaryFile(delete=False, dir=settings.TMP_PATH, suffix='.coffee')
sourcefile.write('# ' + self.titel.encode('utf8') + '\n')
sourcefile.write('# ' + '-' * len(self.titel.encode('utf8')) + '\n#\n#\n')
if self.quelltext.startswith('#'):
sourcefile.write('# <div style="margin-top:400px;"></div>\n\n')
else:
sourcefile.write('# <div style="margin-top:400px;"></div>\n\n# .\n')
sourcefile.write(self.quelltext.encode('utf8'))
sourcefile.close()
path = tempfile.mkdtemp(dir=settings.TMP_PATH)
os.system('docco -t %s/template.jst -o %s %s' % (settings.DOCCO_TEMPLATE_PATH, path, sourcefile.name))
with open(os.path.join(path, os.path.basename(sourcefile.name)[:-7] + '.html')) as resultfile:
self.doccoHTML = resultfile.read().decode('utf8')
super(Beispiel, self).save(*args, **kwargs)
class Aufgabe(models.Model):
'''Eine Aufgabe in der Aufgabensammlung'''
KATEGORIE_CHOICES = [('0', 'Einstieg'),
('1', 'Schleifen'),
('2', 'Funktionen'),
('3', 'Bedingungen'),
('4', 'Für Fortgeschrittene'),
]
titel = models.CharField(max_length=50)
zusammenfassung = models.TextField(max_length=500)
kategorie = models.CharField(choices=KATEGORIE_CHOICES, max_length=2)
platz = models.FloatField()
quelltext = models.TextField(max_length=50000)
doccoHTML = models.TextField(max_length=100000)
bild = models.ImageField(upload_to='tutorial')
docbild = ImageSpecField([WhiteBackground(), Resize(400, 400), ], source='bild', format='JPEG', )
thumbnail = ImageSpecField([WhiteBackground(), Resize(200, 200), ], source='bild', format='JPEG', )
def __unicode__(self):
return u'%s (%s/%d)' % (self.titel, self.kategorie, self.platz)
def save(self, *args, **kwargs):
# fill doccoHTML
sourcefile = tempfile.NamedTemporaryFile(delete=False, dir=settings.TMP_PATH, suffix='.coffee')
sourcefile.write('# ' + self.titel.encode('utf8') + '\n')
sourcefile.write('# ' + '-' * len(self.titel.encode('utf8')) + '\n# \n')
sourcefile.write(self.quelltext.encode('utf8'))
sourcefile.close()
path = tempfile.mkdtemp(dir=settings.TMP_PATH)
os.system('docco -t %s/template.jst -o %s %s' % (settings.DOCCO_TEMPLATE_PATH, path, sourcefile.name))
with open(os.path.join(path, os.path.basename(sourcefile.name)[:-7] + '.html')) as resultfile:
self.doccoHTML = resultfile.read().decode('utf8')
super(Aufgabe, self).save(*args, **kwargs)
class Userdata(models.Model):
user = models.OneToOneField(User)
class Skript(models.Model):
key = models.CharField(max_length=20)
skript = models.TextField(max_length=2000)
ud = models.ForeignKey(Userdata)
bild = models.ImageField(upload_to='userskripte', null=True)
thumbnail = ImageSpecField([WhiteBackground(), Resize(150, 150), ], source='bild', format='png', )
def __unicode__(self):
return '%s: %s (%d)' % (self.ud.user.email, self.key, len(self.skript))
@receiver(user_activated)
def user_activated_callback(sender, user, request, **kwargs):
ud = Userdata(user=user)
ud.save()
|
ugoertz/igelgrafik
|
igelmain/models.py
|
Python
|
bsd-3-clause
| 6,801 | 0.003971 |
import pytest
def test_app_hostname_is_not_none():
from openods import app
value = app.config['APP_HOSTNAME']
assert value is not None
def test_cache_timeout_is_greater_equal_0():
from openods import app
value = app.config['CACHE_TIMEOUT']
assert value >= 0
def test_database_url_is_not_none():
from openods import app
value = app.config['DATABASE_URL']
assert value is not None
|
open-ods/open-ods
|
tests/test_openods_api_config.py
|
Python
|
gpl-3.0
| 421 | 0 |
"""Unit tests for PyGraphviz interface."""
import os
import tempfile
import pytest
import pytest
pygraphviz = pytest.importorskip('pygraphviz')
from networkx.testing import assert_edges_equal, assert_nodes_equal, \
assert_graphs_equal
import networkx as nx
class TestAGraph(object):
def build_graph(self, G):
edges = [('A', 'B'), ('A', 'C'), ('A', 'C'), ('B', 'C'), ('A', 'D')]
G.add_edges_from(edges)
G.add_node('E')
G.graph['metal'] = 'bronze'
return G
def assert_equal(self, G1, G2):
assert_nodes_equal(G1.nodes(), G2.nodes())
assert_edges_equal(G1.edges(), G2.edges())
assert G1.graph['metal'] == G2.graph['metal']
def agraph_checks(self, G):
G = self.build_graph(G)
A = nx.nx_agraph.to_agraph(G)
H = nx.nx_agraph.from_agraph(A)
self.assert_equal(G, H)
fname = tempfile.mktemp()
nx.drawing.nx_agraph.write_dot(H, fname)
Hin = nx.nx_agraph.read_dot(fname)
os.unlink(fname)
self.assert_equal(H, Hin)
(fd, fname) = tempfile.mkstemp()
with open(fname, 'w') as fh:
nx.drawing.nx_agraph.write_dot(H, fh)
with open(fname, 'r') as fh:
Hin = nx.nx_agraph.read_dot(fh)
os.unlink(fname)
self.assert_equal(H, Hin)
def test_from_agraph_name(self):
G = nx.Graph(name='test')
A = nx.nx_agraph.to_agraph(G)
H = nx.nx_agraph.from_agraph(A)
assert G.name == 'test'
def test_undirected(self):
self.agraph_checks(nx.Graph())
def test_directed(self):
self.agraph_checks(nx.DiGraph())
def test_multi_undirected(self):
self.agraph_checks(nx.MultiGraph())
def test_multi_directed(self):
self.agraph_checks(nx.MultiDiGraph())
def test_view_pygraphviz(self):
G = nx.Graph() # "An empty graph cannot be drawn."
pytest.raises(nx.NetworkXException, nx.nx_agraph.view_pygraphviz, G)
G = nx.barbell_graph(4, 6)
nx.nx_agraph.view_pygraphviz(G)
def test_view_pygraphviz_edgelable(self):
G = nx.Graph()
G.add_edge(1, 2, weight=7)
G.add_edge(2, 3, weight=8)
nx.nx_agraph.view_pygraphviz(G, edgelabel='weight')
def test_graph_with_reserved_keywords(self):
# test attribute/keyword clash case for #1582
# node: n
# edges: u,v
G = nx.Graph()
G = self.build_graph(G)
G.nodes['E']['n'] = 'keyword'
G.edges[('A', 'B')]['u'] = 'keyword'
G.edges[('A', 'B')]['v'] = 'keyword'
A = nx.nx_agraph.to_agraph(G)
def test_round_trip(self):
G = nx.Graph()
A = nx.nx_agraph.to_agraph(G)
H = nx.nx_agraph.from_agraph(A)
#assert_graphs_equal(G, H)
AA = nx.nx_agraph.to_agraph(H)
HH = nx.nx_agraph.from_agraph(AA)
assert_graphs_equal(H, HH)
G.graph['graph'] = {}
G.graph['node'] = {}
G.graph['edge'] = {}
assert_graphs_equal(G, HH)
def test_2d_layout(self):
G = nx.Graph()
G = self.build_graph(G)
G.graph["dimen"] = 2
pos = nx.nx_agraph.pygraphviz_layout(G, prog='neato')
pos = list(pos.values())
assert len(pos) == 5
assert len(pos[0]) == 2
def test_3d_layout(self):
G = nx.Graph()
G = self.build_graph(G)
G.graph["dimen"] = 3
pos = nx.nx_agraph.pygraphviz_layout(G, prog='neato')
pos = list(pos.values())
assert len(pos) == 5
assert len(pos[0]) == 3
|
sserrot/champion_relationships
|
venv/Lib/site-packages/networkx/drawing/tests/test_agraph.py
|
Python
|
mit
| 3,587 | 0.000836 |
import bpy
from ... base_types.node import AnimationNode
class an_EdgesOfPolygonsNode(bpy.types.Node, AnimationNode):
bl_idname = "an_EdgesOfPolygonsNode"
bl_label = "Edges of Polygons"
def create(self):
self.newInput("Polygon Indices List", "Polygons", "polygons")
self.newOutput("Edge Indices List", "Edges", "edges")
def execute(self, polygons):
edges = []
for polygon in polygons:
for i, index in enumerate(polygon):
startIndex = polygon[i - 1]
edge = (startIndex, index) if index > startIndex else (index, startIndex)
edges.append(edge)
return list(set(edges))
|
Thortoise/Super-Snake
|
Blender/animation_nodes-master/nodes/mesh/edges_of_polygons.py
|
Python
|
gpl-3.0
| 685 | 0.00292 |
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""
Tests for database migrations.
There are "opportunistic" tests which allows testing against all 3 databases
(sqlite in memory, mysql, pg) in a properly configured unit test environment.
For the opportunistic testing you need to set up db's named 'openstack_citest'
with user 'openstack_citest' and password 'openstack_citest' on localhost. The
test will then use that db and u/p combo to run the tests.
For postgres on Ubuntu this can be done with the following commands::
| sudo -u postgres psql
| postgres=# create user openstack_citest with createdb login password
| 'openstack_citest';
| postgres=# create database openstack_citest with owner openstack_citest;
"""
import os
from migrate.versioning import repository
import mock
from oslo_db.sqlalchemy import test_base
from oslo_db.sqlalchemy import test_migrations
from oslo_db.sqlalchemy import utils as db_utils
import sqlalchemy
from sqlalchemy.engine import reflection
from nova.db import migration
from nova.db.sqlalchemy.api_migrations import migrate_repo
from nova.db.sqlalchemy import api_models
from nova.db.sqlalchemy import migration as sa_migration
from nova import test
from nova.tests import fixtures as nova_fixtures
class NovaAPIModelsSync(test_migrations.ModelsMigrationsSync):
"""Test that the models match the database after migrations are run."""
def db_sync(self, engine):
with mock.patch.object(sa_migration, 'get_engine',
return_value=engine):
sa_migration.db_sync(database='api')
@property
def migrate_engine(self):
return self.engine
def get_engine(self, context=None):
return self.migrate_engine
def get_metadata(self):
return api_models.API_BASE.metadata
def include_object(self, object_, name, type_, reflected, compare_to):
if type_ == 'table':
# migrate_version is a sqlalchemy-migrate control table and
# isn't included in the model.
if name == 'migrate_version':
return False
return True
def filter_metadata_diff(self, diff):
# Filter out diffs that shouldn't cause a sync failure.
new_diff = []
# Define a whitelist of ForeignKeys that exist on the model but not in
# the database. They will be removed from the model at a later time.
fkey_whitelist = {'build_requests': ['request_spec_id']}
# Define a whitelist of columns that will be removed from the
# DB at a later release and aren't on a model anymore.
column_whitelist = {
'build_requests': ['vm_state', 'instance_metadata',
'display_name', 'access_ip_v6', 'access_ip_v4', 'key_name',
'locked_by', 'image_ref', 'progress', 'request_spec_id',
'info_cache', 'user_id', 'task_state', 'security_groups',
'config_drive']
}
for element in diff:
if isinstance(element, list):
# modify_nullable is a list
new_diff.append(element)
else:
# tuple with action as first element. Different actions have
# different tuple structures.
if element[0] == 'add_fk':
fkey = element[1]
tablename = fkey.table.name
column_keys = fkey.column_keys
if (tablename in fkey_whitelist and
column_keys == fkey_whitelist[tablename]):
continue
elif element[0] == 'remove_column':
tablename = element[2]
column = element[3]
if (tablename in column_whitelist and
column.name in column_whitelist[tablename]):
continue
new_diff.append(element)
return new_diff
class TestNovaAPIMigrationsSQLite(NovaAPIModelsSync,
test_base.DbTestCase,
test.NoDBTestCase):
pass
class TestNovaAPIMigrationsMySQL(NovaAPIModelsSync,
test_base.MySQLOpportunisticTestCase,
test.NoDBTestCase):
pass
class TestNovaAPIMigrationsPostgreSQL(NovaAPIModelsSync,
test_base.PostgreSQLOpportunisticTestCase, test.NoDBTestCase):
pass
class NovaAPIMigrationsWalk(test_migrations.WalkVersionsMixin):
def setUp(self):
# NOTE(sdague): the oslo_db base test case completely
# invalidates our logging setup, we actually have to do that
# before it is called to keep this from vomiting all over our
# test output.
self.useFixture(nova_fixtures.StandardLogging())
super(NovaAPIMigrationsWalk, self).setUp()
@property
def INIT_VERSION(self):
return migration.db_initial_version('api')
@property
def REPOSITORY(self):
return repository.Repository(
os.path.abspath(os.path.dirname(migrate_repo.__file__)))
@property
def migration_api(self):
return sa_migration.versioning_api
@property
def migrate_engine(self):
return self.engine
def _skippable_migrations(self):
mitaka_placeholders = list(range(8, 13))
newton_placeholders = list(range(21, 26))
ocata_placeholders = list(range(31, 41))
special_cases = [
30, # Enforcement migration, no changes to test
]
return (mitaka_placeholders +
newton_placeholders +
ocata_placeholders +
special_cases)
def migrate_up(self, version, with_data=False):
if with_data:
check = getattr(self, '_check_%03d' % version, None)
if version not in self._skippable_migrations():
self.assertIsNotNone(check,
('API DB Migration %i does not have a '
'test. Please add one!') % version)
super(NovaAPIMigrationsWalk, self).migrate_up(version, with_data)
def test_walk_versions(self):
self.walk_versions(snake_walk=False, downgrade=False)
def assertColumnExists(self, engine, table_name, column):
self.assertTrue(db_utils.column_exists(engine, table_name, column),
'Column %s.%s does not exist' % (table_name, column))
def assertIndexExists(self, engine, table_name, index):
self.assertTrue(db_utils.index_exists(engine, table_name, index),
'Index %s on table %s does not exist' %
(index, table_name))
def assertUniqueConstraintExists(self, engine, table_name, columns):
inspector = reflection.Inspector.from_engine(engine)
constrs = inspector.get_unique_constraints(table_name)
constr_columns = [constr['column_names'] for constr in constrs]
self.assertIn(columns, constr_columns)
def assertTableNotExists(self, engine, table_name):
self.assertRaises(sqlalchemy.exc.NoSuchTableError,
db_utils.get_table, engine, table_name)
def _check_001(self, engine, data):
for column in ['created_at', 'updated_at', 'id', 'uuid', 'name',
'transport_url', 'database_connection']:
self.assertColumnExists(engine, 'cell_mappings', column)
self.assertIndexExists(engine, 'cell_mappings', 'uuid_idx')
self.assertUniqueConstraintExists(engine, 'cell_mappings',
['uuid'])
def _check_002(self, engine, data):
for column in ['created_at', 'updated_at', 'id', 'instance_uuid',
'cell_id', 'project_id']:
self.assertColumnExists(engine, 'instance_mappings', column)
for index in ['instance_uuid_idx', 'project_id_idx']:
self.assertIndexExists(engine, 'instance_mappings', index)
self.assertUniqueConstraintExists(engine, 'instance_mappings',
['instance_uuid'])
inspector = reflection.Inspector.from_engine(engine)
# There should only be one foreign key here
fk = inspector.get_foreign_keys('instance_mappings')[0]
self.assertEqual('cell_mappings', fk['referred_table'])
self.assertEqual(['id'], fk['referred_columns'])
self.assertEqual(['cell_id'], fk['constrained_columns'])
def _check_003(self, engine, data):
for column in ['created_at', 'updated_at', 'id',
'cell_id', 'host']:
self.assertColumnExists(engine, 'host_mappings', column)
self.assertIndexExists(engine, 'host_mappings', 'host_idx')
self.assertUniqueConstraintExists(engine, 'host_mappings',
['host'])
inspector = reflection.Inspector.from_engine(engine)
# There should only be one foreign key here
fk = inspector.get_foreign_keys('host_mappings')[0]
self.assertEqual('cell_mappings', fk['referred_table'])
self.assertEqual(['id'], fk['referred_columns'])
self.assertEqual(['cell_id'], fk['constrained_columns'])
def _check_004(self, engine, data):
columns = ['created_at', 'updated_at', 'id', 'instance_uuid', 'spec']
for column in columns:
self.assertColumnExists(engine, 'request_specs', column)
self.assertUniqueConstraintExists(engine, 'request_specs',
['instance_uuid'])
self.assertIndexExists(engine, 'request_specs',
'request_spec_instance_uuid_idx')
def _check_005(self, engine, data):
# flavors
for column in ['created_at', 'updated_at', 'name', 'id', 'memory_mb',
'vcpus', 'swap', 'vcpu_weight', 'flavorid', 'rxtx_factor',
'root_gb', 'ephemeral_gb', 'disabled', 'is_public']:
self.assertColumnExists(engine, 'flavors', column)
self.assertUniqueConstraintExists(engine, 'flavors',
['flavorid'])
self.assertUniqueConstraintExists(engine, 'flavors',
['name'])
# flavor_extra_specs
for column in ['created_at', 'updated_at', 'id', 'flavor_id', 'key',
'value']:
self.assertColumnExists(engine, 'flavor_extra_specs', column)
self.assertIndexExists(engine, 'flavor_extra_specs',
'flavor_extra_specs_flavor_id_key_idx')
self.assertUniqueConstraintExists(engine, 'flavor_extra_specs',
['flavor_id', 'key'])
inspector = reflection.Inspector.from_engine(engine)
# There should only be one foreign key here
fk = inspector.get_foreign_keys('flavor_extra_specs')[0]
self.assertEqual('flavors', fk['referred_table'])
self.assertEqual(['id'], fk['referred_columns'])
self.assertEqual(['flavor_id'], fk['constrained_columns'])
# flavor_projects
for column in ['created_at', 'updated_at', 'id', 'flavor_id',
'project_id']:
self.assertColumnExists(engine, 'flavor_projects', column)
self.assertUniqueConstraintExists(engine, 'flavor_projects',
['flavor_id', 'project_id'])
inspector = reflection.Inspector.from_engine(engine)
# There should only be one foreign key here
fk = inspector.get_foreign_keys('flavor_projects')[0]
self.assertEqual('flavors', fk['referred_table'])
self.assertEqual(['id'], fk['referred_columns'])
self.assertEqual(['flavor_id'], fk['constrained_columns'])
def _check_006(self, engine, data):
for column in ['id', 'request_spec_id', 'project_id', 'user_id',
'display_name', 'instance_metadata', 'progress', 'vm_state',
'image_ref', 'access_ip_v4', 'access_ip_v6', 'info_cache',
'security_groups', 'config_drive', 'key_name', 'locked_by']:
self.assertColumnExists(engine, 'build_requests', column)
self.assertIndexExists(engine, 'build_requests',
'build_requests_project_id_idx')
self.assertUniqueConstraintExists(engine, 'build_requests',
['request_spec_id'])
inspector = reflection.Inspector.from_engine(engine)
# There should only be one foreign key here
fk = inspector.get_foreign_keys('build_requests')[0]
self.assertEqual('request_specs', fk['referred_table'])
self.assertEqual(['id'], fk['referred_columns'])
self.assertEqual(['request_spec_id'], fk['constrained_columns'])
def _check_007(self, engine, data):
map_table = db_utils.get_table(engine, 'instance_mappings')
self.assertTrue(map_table.columns['cell_id'].nullable)
# Ensure the foreign key still exists
inspector = reflection.Inspector.from_engine(engine)
# There should only be one foreign key here
fk = inspector.get_foreign_keys('instance_mappings')[0]
self.assertEqual('cell_mappings', fk['referred_table'])
self.assertEqual(['id'], fk['referred_columns'])
self.assertEqual(['cell_id'], fk['constrained_columns'])
def _check_013(self, engine, data):
for column in ['instance_uuid', 'instance']:
self.assertColumnExists(engine, 'build_requests', column)
self.assertIndexExists(engine, 'build_requests',
'build_requests_instance_uuid_idx')
self.assertUniqueConstraintExists(engine, 'build_requests',
['instance_uuid'])
def _check_014(self, engine, data):
for column in ['name', 'public_key']:
self.assertColumnExists(engine, 'key_pairs', column)
self.assertUniqueConstraintExists(engine, 'key_pairs',
['user_id', 'name'])
def _check_015(self, engine, data):
build_requests_table = db_utils.get_table(engine, 'build_requests')
for column in ['request_spec_id', 'user_id', 'security_groups',
'config_drive']:
self.assertTrue(build_requests_table.columns[column].nullable)
inspector = reflection.Inspector.from_engine(engine)
constrs = inspector.get_unique_constraints('build_requests')
constr_columns = [constr['column_names'] for constr in constrs]
self.assertNotIn(['request_spec_id'], constr_columns)
def _check_016(self, engine, data):
self.assertColumnExists(engine, 'resource_providers', 'id')
self.assertIndexExists(engine, 'resource_providers',
'resource_providers_name_idx')
self.assertIndexExists(engine, 'resource_providers',
'resource_providers_uuid_idx')
self.assertColumnExists(engine, 'inventories', 'id')
self.assertIndexExists(engine, 'inventories',
'inventories_resource_class_id_idx')
self.assertColumnExists(engine, 'allocations', 'id')
self.assertColumnExists(engine, 'resource_provider_aggregates',
'aggregate_id')
def _check_017(self, engine, data):
# aggregate_metadata
for column in ['created_at',
'updated_at',
'id',
'aggregate_id',
'key',
'value']:
self.assertColumnExists(engine, 'aggregate_metadata', column)
self.assertUniqueConstraintExists(engine, 'aggregate_metadata',
['aggregate_id', 'key'])
self.assertIndexExists(engine, 'aggregate_metadata',
'aggregate_metadata_key_idx')
# aggregate_hosts
for column in ['created_at',
'updated_at',
'id',
'host',
'aggregate_id']:
self.assertColumnExists(engine, 'aggregate_hosts', column)
self.assertUniqueConstraintExists(engine, 'aggregate_hosts',
['host', 'aggregate_id'])
# aggregates
for column in ['created_at',
'updated_at',
'id',
'name']:
self.assertColumnExists(engine, 'aggregates', column)
self.assertIndexExists(engine, 'aggregates',
'aggregate_uuid_idx')
self.assertUniqueConstraintExists(engine, 'aggregates', ['name'])
def _check_018(self, engine, data):
# instance_groups
for column in ['created_at',
'updated_at',
'id',
'user_id',
'project_id',
'uuid',
'name']:
self.assertColumnExists(engine, 'instance_groups', column)
self.assertUniqueConstraintExists(engine, 'instance_groups', ['uuid'])
# instance_group_policy
for column in ['created_at',
'updated_at',
'id',
'policy',
'group_id']:
self.assertColumnExists(engine, 'instance_group_policy', column)
self.assertIndexExists(engine, 'instance_group_policy',
'instance_group_policy_policy_idx')
# Ensure the foreign key still exists
inspector = reflection.Inspector.from_engine(engine)
# There should only be one foreign key here
fk = inspector.get_foreign_keys('instance_group_policy')[0]
self.assertEqual('instance_groups', fk['referred_table'])
self.assertEqual(['id'], fk['referred_columns'])
# instance_group_member
for column in ['created_at',
'updated_at',
'id',
'instance_uuid',
'group_id']:
self.assertColumnExists(engine, 'instance_group_member', column)
self.assertIndexExists(engine, 'instance_group_member',
'instance_group_member_instance_idx')
def _check_019(self, engine, data):
self.assertColumnExists(engine, 'build_requests',
'block_device_mappings')
def _pre_upgrade_020(self, engine):
build_requests = db_utils.get_table(engine, 'build_requests')
fake_build_req = {'id': 2020,
'project_id': 'fake_proj_id',
'block_device_mappings': 'fake_BDM'}
build_requests.insert().execute(fake_build_req)
def _check_020(self, engine, data):
build_requests = db_utils.get_table(engine, 'build_requests')
if engine.name == 'mysql':
self.assertIsInstance(build_requests.c.block_device_mappings.type,
sqlalchemy.dialects.mysql.MEDIUMTEXT)
fake_build_req = build_requests.select(
build_requests.c.id == 2020).execute().first()
self.assertEqual('fake_BDM', fake_build_req.block_device_mappings)
def _check_026(self, engine, data):
self.assertColumnExists(engine, 'resource_classes', 'id')
self.assertColumnExists(engine, 'resource_classes', 'name')
def _check_027(self, engine, data):
# quota_classes
for column in ['created_at',
'updated_at',
'id',
'class_name',
'resource',
'hard_limit']:
self.assertColumnExists(engine, 'quota_classes', column)
self.assertIndexExists(engine, 'quota_classes',
'quota_classes_class_name_idx')
# quota_usages
for column in ['created_at',
'updated_at',
'id',
'project_id',
'resource',
'in_use',
'reserved',
'until_refresh',
'user_id']:
self.assertColumnExists(engine, 'quota_usages', column)
self.assertIndexExists(engine, 'quota_usages',
'quota_usages_project_id_idx')
self.assertIndexExists(engine, 'quota_usages',
'quota_usages_user_id_idx')
# quotas
for column in ['created_at',
'updated_at',
'id',
'project_id',
'resource',
'hard_limit']:
self.assertColumnExists(engine, 'quotas', column)
self.assertUniqueConstraintExists(engine, 'quotas',
['project_id', 'resource'])
# project_user_quotas
for column in ['created_at',
'updated_at',
'id',
'user_id',
'project_id',
'resource',
'hard_limit']:
self.assertColumnExists(engine, 'project_user_quotas', column)
self.assertUniqueConstraintExists(engine, 'project_user_quotas',
['user_id', 'project_id', 'resource'])
self.assertIndexExists(engine, 'project_user_quotas',
'project_user_quotas_project_id_idx')
self.assertIndexExists(engine, 'project_user_quotas',
'project_user_quotas_user_id_idx')
# reservations
for column in ['created_at',
'updated_at',
'id',
'uuid',
'usage_id',
'project_id',
'resource',
'delta',
'expire',
'user_id']:
self.assertColumnExists(engine, 'reservations', column)
self.assertIndexExists(engine, 'reservations',
'reservations_project_id_idx')
self.assertIndexExists(engine, 'reservations',
'reservations_uuid_idx')
self.assertIndexExists(engine, 'reservations',
'reservations_expire_idx')
self.assertIndexExists(engine, 'reservations',
'reservations_user_id_idx')
# Ensure the foreign key still exists
inspector = reflection.Inspector.from_engine(engine)
# There should only be one foreign key here
fk = inspector.get_foreign_keys('reservations')[0]
self.assertEqual('quota_usages', fk['referred_table'])
self.assertEqual(['id'], fk['referred_columns'])
def _pre_upgrade_028(self, engine):
build_requests = db_utils.get_table(engine, 'build_requests')
fake_build_req = {'id': 2021,
'project_id': 'fake_proj_id',
'instance': '{"uuid": "foo", "name": "bar"}'}
build_requests.insert().execute(fake_build_req)
def _check_028(self, engine, data):
build_requests = db_utils.get_table(engine, 'build_requests')
if engine.name == 'mysql':
self.assertIsInstance(build_requests.c.block_device_mappings.type,
sqlalchemy.dialects.mysql.MEDIUMTEXT)
fake_build_req = build_requests.select(
build_requests.c.id == 2021).execute().first()
self.assertEqual('{"uuid": "foo", "name": "bar"}',
fake_build_req.instance)
def _check_029(self, engine, data):
for column in ['created_at', 'updated_at', 'id', 'uuid']:
self.assertColumnExists(engine, 'placement_aggregates', column)
def _check_041(self, engine, data):
self.assertColumnExists(engine, 'traits', 'id')
self.assertUniqueConstraintExists(engine, 'traits', ['name'])
self.assertColumnExists(engine, 'resource_provider_traits', 'trait_id')
self.assertColumnExists(engine, 'resource_provider_traits',
'resource_provider_id')
self.assertIndexExists(
engine, 'resource_provider_traits',
'resource_provider_traits_resource_provider_trait_idx')
inspector = reflection.Inspector.from_engine(engine)
self.assertEqual(
2, len(inspector.get_foreign_keys('resource_provider_traits')))
for fk in inspector.get_foreign_keys('resource_provider_traits'):
if 'traits' == fk['referred_table']:
self.assertEqual(['id'], fk['referred_columns'])
self.assertEqual(['trait_id'], fk['constrained_columns'])
elif 'resource_providers' == fk['referred_table']:
self.assertEqual(['id'], fk['referred_columns'])
self.assertEqual(['resource_provider_id'],
fk['constrained_columns'])
class TestNovaAPIMigrationsWalkSQLite(NovaAPIMigrationsWalk,
test_base.DbTestCase,
test.NoDBTestCase):
pass
class TestNovaAPIMigrationsWalkMySQL(NovaAPIMigrationsWalk,
test_base.MySQLOpportunisticTestCase,
test.NoDBTestCase):
pass
class TestNovaAPIMigrationsWalkPostgreSQL(NovaAPIMigrationsWalk,
test_base.PostgreSQLOpportunisticTestCase, test.NoDBTestCase):
pass
|
vmturbo/nova
|
nova/tests/functional/db/api/test_migrations.py
|
Python
|
apache-2.0
| 25,993 | 0.001731 |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from certproxy.certproxy import run
if __name__ == '__main__':
run()
|
geneanet/certproxy
|
main.py
|
Python
|
bsd-3-clause
| 118 | 0 |
# !/usr/bin/python3
# -*- coding: utf-8 -*-
import json
import os
from typing import Optional, List, Tuple, Dict, Union
from models.literalConstants import LiteralConstants
class FileProcessing:
BASE_PATH: str = os.getcwd() + "/"
def __init__(self, path: str, file_type: LiteralConstants.FileType) -> None:
self.path: str = FileProcessing.BASE_PATH + path
self.file_type: LiteralConstants.FileType = file_type
def read_file(self) -> Optional[Union[str, List, Tuple, Dict, bytes]]:
try:
file = open(self.path, 'r') if self.file_type != LiteralConstants.FileType.BYTES else open(self.path, 'rb')
if self.file_type == LiteralConstants.FileType.REG or self.file_type == LiteralConstants.FileType.BYTES:
return file.read()
elif self.file_type == LiteralConstants.FileType.JSON:
return json.load(file)
except EnvironmentError:
LiteralConstants.STA_LOG.logger.exception(LiteralConstants.ExceptionMessages.FILE_CANT_OPEN, exc_info=True)
return None
else:
file.close()
def write_file(self, data: Union[str, List, Tuple, Dict]) -> bool:
try:
file = open(self.path, 'w') if self.file_type != LiteralConstants.FileType.BYTES else open(self.path, 'wb')
if self.file_type == LiteralConstants.FileType.REG or self.file_type == LiteralConstants.FileType.BYTES:
file.write(data)
return True
elif self.file_type == LiteralConstants.FileType.JSON:
json.dump(data, file)
return True
except EnvironmentError:
LiteralConstants.STA_LOG.logger.exception(LiteralConstants.ExceptionMessages.FILE_CANT_WRITE, exc_info=True)
return False
else:
file.close()
|
gmm96/Txt2SpeechBot
|
models/fileProcessing.py
|
Python
|
gpl-3.0
| 1,856 | 0.00431 |
from show_latent import LatentView
|
mzwiessele/GPyNotebook
|
GPyNotebook/latent/__init__.py
|
Python
|
bsd-2-clause
| 34 | 0.029412 |
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function
import unittest
import numpy as np
from operator import mul
import paddle.fluid.core as core
import paddle.fluid as fluid
from op_test import OpTest
from testsuite import create_op
def group_norm_naive(x, scale, bias, epsilon, groups, data_layout):
if data_layout == "NHWC":
x = np.transpose(x, (0, 3, 1, 2)) # NHWC => NCHW
N, C, H, W = x.shape
G = groups
x = x.reshape((N * G, -1))
mean = np.mean(x, axis=1, keepdims=True)
var = np.var(x, axis=1, keepdims=True)
output = (x - mean) / np.sqrt(var + epsilon)
output = output.reshape((N, C, H, W)) * scale.reshape(
(-1, 1, 1)) + bias.reshape((-1, 1, 1))
if data_layout == "NHWC":
output = np.transpose(output, (0, 2, 3, 1)) # NCHW => NHWC
return output, mean.reshape((N, G)), var.reshape((N, G))
class TestGroupNormOp(OpTest):
def setUp(self):
self.op_type = "group_norm"
self.data_format = "NCHW"
self.dtype = np.float32
self.shape = (2, 4, 3, 3)
self.attrs = {'epsilon': 1e-5, 'groups': 2, 'data_layout': "NCHW"}
self.compare_between_place = False
self.init_test_case()
input = np.random.random(self.shape).astype(self.dtype)
if self.data_format == "NHWC":
input = np.transpose(input, (0, 2, 3, 1))
scale = np.random.random([self.shape[1]]).astype(self.dtype)
bias = np.random.random([self.shape[1]]).astype(self.dtype)
output, mean, var = group_norm_naive(
input, scale, bias, self.attrs['epsilon'], self.attrs['groups'],
self.data_format)
self.inputs = {
'X': OpTest.np_dtype_to_fluid_dtype(input),
'Scale': OpTest.np_dtype_to_fluid_dtype(scale),
'Bias': OpTest.np_dtype_to_fluid_dtype(bias)
}
self.outputs = {'Y': output, 'Mean': mean, 'Variance': var}
self.attrs['data_layout'] = self.data_format
def test_check_output(self):
atol = 1e-4
inplace_atol = 1e-4
place = core.CPUPlace()
# add inplace_atol bacause group_norm doesn't ensure computational consistency
self.check_output_with_place(
place, atol=atol, inplace_atol=inplace_atol)
if core.is_compiled_with_cuda():
place = core.CUDAPlace(0)
self.check_output_with_place(
place, atol=atol, inplace_atol=inplace_atol)
def do_compare_between_place(self):
if not core.is_compiled_with_cuda(): return
place = core.CPUPlace()
place2 = core.CUDAPlace(0)
self.scope = core.Scope()
op_inputs = self.inputs if hasattr(self, "inputs") else dict()
op_outputs = self.outputs if hasattr(self, "outputs") else dict()
op_attrs = self.attrs if hasattr(self, "attrs") else dict()
self.op = create_op(self.scope, self.op_type, op_inputs, op_outputs,
op_attrs)
inputs_to_check = set(['X', 'Scale', 'Bias'])
output_names = 'Y'
cpu_grads = self._get_gradient(inputs_to_check, place, output_names,
None)
gpu_grads = self._get_gradient(inputs_to_check, place2, output_names,
None)
self._assert_is_close(cpu_grads, gpu_grads, inputs_to_check, 0.005,
"Gradient Check On %s" % str(place))
def test_check_grad(self):
if self.compare_between_place:
self.do_compare_between_place()
return
place = core.CPUPlace()
self.check_grad_with_place(
place, set(['X', 'Scale', 'Bias']), 'Y', max_relative_error=0.01)
if core.is_compiled_with_cuda():
place = core.CUDAPlace(0)
self.check_grad_with_place(
place,
set(['X', 'Scale', 'Bias']),
'Y',
max_relative_error=0.01)
def init_test_case(self):
pass
class TestGroupNormOp1(TestGroupNormOp):
def init_test_case(self):
self.attrs['groups'] = 1
class TestGroupNormOp2(TestGroupNormOp):
def init_test_case(self):
self.attrs['groups'] = 4
class TestGroupNormOpBigEps1(TestGroupNormOp):
def init_test_case(self):
self.attrs['groups'] = 1
self.attrs['epsilon'] = 0.5
class TestGroupNormOpBigEps2(TestGroupNormOp):
def init_test_case(self):
self.attrs['groups'] = 4
self.attrs['epsilon'] = 0.5
class TestGroupNormOpBigEps3(TestGroupNormOp):
def init_test_case(self):
self.attrs['epsilon'] = 0.5
class TestGroupNormOpLargeData(TestGroupNormOp):
def init_test_case(self):
self.shape = (2, 32, 64, 64)
self.attrs['groups'] = 8
self.compare_between_place = True
class TestGroupNormOp1_With_NHWC(TestGroupNormOp):
def init_test_case(self):
self.attrs['groups'] = 1
self.data_format = "NHWC"
class TestGroupNormOp2_With_NHWC(TestGroupNormOp):
def init_test_case(self):
self.attrs['groups'] = 4
self.data_format = "NHWC"
class TestGroupNormOpBigEps1_With_NHWC(TestGroupNormOp):
def init_test_case(self):
self.attrs['groups'] = 1
self.attrs['epsilon'] = 0.5
self.data_format = "NHWC"
class TestGroupNormOpBigEps2_With_NHWC(TestGroupNormOp):
def init_test_case(self):
self.attrs['groups'] = 4
self.attrs['epsilon'] = 0.5
self.data_format = "NHWC"
class TestGroupNormOpBigEps3_With_NHWC(TestGroupNormOp):
def init_test_case(self):
self.attrs['epsilon'] = 0.5
self.data_format = "NHWC"
class TestGroupNormOpLargeData_With_NHWC(TestGroupNormOp):
def init_test_case(self):
self.shape = (2, 64, 32, 32) # NCHW
self.attrs['groups'] = 8
self.data_format = "NHWC"
self.compare_between_place = True
class TestGroupNormAPI_With_NHWC(OpTest):
def test_case1(self):
data1 = fluid.data(name='data1', shape=[None, 3, 3, 4], dtype='float32')
out1 = fluid.layers.group_norm(
input=data1, groups=2, data_layout="NHWC")
data2 = fluid.data(name='data2', shape=[None, 4, 3, 3], dtype='float32')
out2 = fluid.layers.group_norm(
input=data2, groups=2, data_layout="NCHW")
data1_np = np.random.random((2, 3, 3, 4)).astype("float32")
data2_np = np.random.random((2, 4, 3, 3)).astype("float32")
scale = np.array([1]).astype("float32")
bias = np.array([0]).astype("float32")
place = core.CPUPlace()
exe = fluid.Executor(place)
results = exe.run(fluid.default_main_program(),
feed={"data1": data1_np,
"data2": data2_np},
fetch_list=[out1, out2],
return_numpy=True)
expect_res1 = group_norm_naive(
data1_np, scale, bias, epsilon=1e-5, groups=2, data_layout="NHWC")
expect_res2 = group_norm_naive(
data2_np, scale, bias, epsilon=1e-5, groups=2, data_layout="NCHW")
self.assertTrue(np.allclose(results[0], expect_res1[0]))
self.assertTrue(np.allclose(results[1], expect_res2[0]))
class TestGroupNormException(OpTest):
# data_layout is not NHWC or NCHW
def test_exception(self):
data = fluid.data(name='data', shape=[None, 3, 3, 4], dtype="float32")
def attr_data_format():
out = fluid.layers.group_norm(
input=data, groups=2, data_layout="NDHW")
self.assertRaises(ValueError, attr_data_format)
if __name__ == '__main__':
unittest.main()
|
chengduoZH/Paddle
|
python/paddle/fluid/tests/unittests/test_group_norm_op.py
|
Python
|
apache-2.0
| 8,301 | 0.000482 |
"""SCons.Tool.gfortran
Tool-specific initialization for gfortran, the GNU Fortran 95/Fortran
2003 compiler.
There normally shouldn't be any need to import this module directly.
It will usually be imported through the generic SCons.Tool.Tool()
selection method.
"""
#
# Copyright (c) 2001 - 2014 The SCons Foundation
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
__revision__ = "src/engine/SCons/Tool/gfortran.py 2014/09/27 12:51:43 garyo"
import SCons.Util
import fortran
def generate(env):
"""Add Builders and construction variables for gfortran to an
Environment."""
fortran.generate(env)
for dialect in ['F77', 'F90', 'FORTRAN', 'F95', 'F03']:
env['%s' % dialect] = 'gfortran'
env['SH%s' % dialect] = '$%s' % dialect
if env['PLATFORM'] in ['cygwin', 'win32']:
env['SH%sFLAGS' % dialect] = SCons.Util.CLVar('$%sFLAGS' % dialect)
else:
env['SH%sFLAGS' % dialect] = SCons.Util.CLVar('$%sFLAGS -fPIC' % dialect)
env['INC%sPREFIX' % dialect] = "-I"
env['INC%sSUFFIX' % dialect] = ""
def exists(env):
return env.Detect('gfortran')
# Local Variables:
# tab-width:4
# indent-tabs-mode:nil
# End:
# vim: set expandtab tabstop=4 shiftwidth=4:
|
stonekyx/binary
|
vendor/scons-local-2.3.4/SCons/Tool/gfortran.py
|
Python
|
gpl-3.0
| 2,256 | 0.00133 |
from OpenGLCffi.GL import params
@params(api='gl', prms=['value'])
def glMinSampleShadingARB(value):
pass
|
cydenix/OpenGLCffi
|
OpenGLCffi/GL/EXT/ARB/sample_shading.py
|
Python
|
mit
| 109 | 0.027523 |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import math
import operator
from pycket import values
from pycket import vector as values_vector
from pycket.arity import Arity
from pycket.error import SchemeException
from pycket.prims.expose import expose, default, unsafe
from rpython.rlib import jit, longlong2float, rarithmetic, unroll
from rpython.rlib.rarithmetic import r_uint
from rpython.rlib.objectmodel import always_inline, specialize
from rpython.rlib.rbigint import rbigint
from rpython.rtyper.lltypesystem.lloperation import llop
from rpython.rtyper.lltypesystem.lltype import Signed
# imported for side effects
from pycket import arithmetic
def make_cmp(name, op, con):
@expose(name, simple=True, arity=Arity.geq(2))
@jit.unroll_safe
def do(args):
if len(args) < 2:
raise SchemeException("number of arguments to %s too small" % name)
idx = 2
truth = True
while idx <= len(args):
start = idx - 2
assert start >= 0
w_a, w_b = args[start], args[start + 1]
if not isinstance(w_a, values.W_Number):
raise SchemeException("expected number")
if not isinstance(w_b, values.W_Number):
raise SchemeException("expected number")
idx += 1
truth = truth and getattr(w_a, "arith_" + op)(w_b)
return con(truth)
do.__name__ = op
for args in [
("=", "eq", values.W_Bool.make),
("<", "lt", values.W_Bool.make),
(">", "gt", values.W_Bool.make),
("<=", "le", values.W_Bool.make),
(">=", "ge", values.W_Bool.make),
]:
make_cmp(*args)
@expose("integer?", [values.W_Object])
def integerp(n):
return values.W_Bool.make(isinstance(n, values.W_Number) and n.isinteger())
@expose("exact-integer?", [values.W_Object])
def exact_integerp(n):
return values.W_Bool.make(isinstance(n, values.W_Integer))
@expose("exact-nonnegative-integer?", [values.W_Object])
def exact_nonneg_integerp(n):
from rpython.rlib.rbigint import NULLRBIGINT
if isinstance(n, values.W_Fixnum):
return values.W_Bool.make(n.value >= 0)
if isinstance(n, values.W_Bignum):
return values.W_Bool.make(n.value.ge(NULLRBIGINT))
return values.w_false
@expose("exact-positive-integer?", [values.W_Object])
def exact_nonneg_integerp(n):
from rpython.rlib.rbigint import NULLRBIGINT
if isinstance(n, values.W_Fixnum):
return values.W_Bool.make(n.value > 0)
if isinstance(n, values.W_Bignum):
return values.W_Bool.make(n.value.gt(NULLRBIGINT))
return values.w_false
@always_inline
def is_real(obj):
return isinstance(obj, values.W_Real)
@expose("real?", [values.W_Object])
def realp(n):
return values.W_Bool.make(is_real(n))
@expose("inexact-real?", [values.W_Object])
def inexact_real(n):
return values.W_Bool.make(isinstance(n, values.W_Flonum))
@expose("single-flonum?", [values.W_Object])
def single_flonum(n):
return values.w_false
@expose("double-flonum?", [values.W_Object])
def double_flonum(n):
return values.W_Bool.make(isinstance(n, values.W_Flonum))
@expose("real->double-flonum", [values.W_Number])
def real_to_double_flonum(num):
if is_real(num):
return num.arith_exact_inexact()
raise SchemeException("real->double-flonum: %s is not real" % num.tostring())
@expose("rational?", [values.W_Object])
def rationalp(n):
if isinstance(n, values.W_Fixnum) or isinstance(n, values.W_Bignum):
return values.w_true
if isinstance(n, values.W_Flonum):
v = n.value
return values.W_Bool.make(not (math.isnan(v) or math.isinf(v)))
return values.W_Bool.make(isinstance(n, values.W_Rational))
def is_exact(n):
if isinstance(n, values.W_Complex):
return is_exact(n.real) and is_exact(n.imag)
return (isinstance(n, values.W_Fixnum) or
isinstance(n, values.W_Bignum) or
isinstance(n, values.W_Rational))
def is_inexact(n):
if isinstance(n, values.W_Complex):
return is_inexact(n.real) or is_inexact(n.imag)
return isinstance(n, values.W_Flonum)
@expose("exact?", [values.W_Object])
def exactp(n):
return values.W_Bool.make(is_exact(n))
@expose("inexact?", [values.W_Object])
def inexactp(n):
return values.W_Bool.make(is_inexact(n))
@expose("quotient/remainder", [values.W_Integer, values.W_Integer])
def quotient_remainder(a, b):
return values.Values._make2(a.arith_quotient(b), a.arith_mod(b)) #FIXME
def make_binary_arith(name, methname):
@expose(name, [values.W_Number, values.W_Number], simple=True)
def do(a, b):
return getattr(a, methname)(b)
do.__name__ = methname
for args in [
("quotient", "arith_quotient"),
("remainder", "arith_remainder"),
("modulo", "arith_mod"),
("expt", "arith_pow"),
]:
make_binary_arith(*args)
@expose("flexpt", [values.W_Flonum] * 2)
def flexpt(n, m):
return n.arith_pow_same(m)
def make_arith(name, neutral_element, methname, supports_zero_args):
@expose(name, simple=True)
@jit.unroll_safe
def do(args):
# XXX so far (+ '()) returns '(). need better type checking here
if not args:
if not supports_zero_args:
raise SchemeException("expected at least 1 argument to %s" % name)
return neutral_element
if len(args) == 1:
if neutral_element is not None:
return getattr(neutral_element, methname)(args[0])
return args[0]
else:
init = args[0]
for i in range(1, jit.promote(len(args))):
init = getattr(init, methname)(args[i])
return init
do.__name__ = methname
for args in [
("+" , values.W_Fixnum.ZERO , "arith_add" , True ) ,
("-" , values.W_Fixnum.ZERO , "arith_sub" , False ) ,
("*" , values.W_Fixnum.ONE , "arith_mul" , True ) ,
("/" , values.W_Fixnum.ONE , "arith_div" , False ) ,
("max" , None , "arith_max" , False ) ,
("min" , None , "arith_min" , False ) ,
("gcd" , values.W_Fixnum.ZERO , "arith_gcd" , True ) ,
("lcm" , values.W_Fixnum.ONE , "arith_lcm" , True ) ,
("bitwise-and" , values.W_Fixnum.make(-1) , "arith_and" , True ) ,
("bitwise-ior" , values.W_Fixnum.ZERO , "arith_or" , True ) ,
("bitwise-xor" , values.W_Fixnum.ZERO , "arith_xor" , True ) ,
]:
make_arith(*args)
def make_fixedtype_binary_arith(
name, methname, intversion=True, floatversion=True):
methname += "_same"
if floatversion:
@expose("fl" + name, [values.W_Flonum] * 2, simple=True)
def do(a, b):
return getattr(a, methname)(b)
do.__name__ = "fl_" + methname
if intversion:
@expose("fx" + name, [values.W_Fixnum] * 2, simple=True)
def do(a, b):
return getattr(a, methname)(b)
do.__name__ = "fx_" + methname
for args in [
("+" , "arith_add" ) ,
("-" , "arith_sub" ) ,
("*" , "arith_mul" ) ,
("/" , "arith_div" , False ) ,
("and" , "arith_and" , True , False ) ,
("max" , "arith_max" ) ,
("min" , "arith_min" ) ,
("quotient" , "arith_quotient" , True , False ) ,
("remainder" , "arith_remainder" , True , False ) ,
("modulo" , "arith_mod" , True , False ) ,
]:
make_fixedtype_binary_arith(*args)
def make_fixedtype_cmps(name, methname):
methname = "arith_%s_same" % methname
def do(a, b):
return values.W_Bool.make(getattr(a, methname)(b))
do.__name__ = "fl_" + methname
expose("fl" + name, [values.W_Flonum] * 2, simple=True)(do)
expose("unsafe-fl" + name, [unsafe(values.W_Flonum)] * 2, simple=True)(do)
def do(a, b):
return values.W_Bool.make(getattr(a, methname)(b))
do.__name__ = "fx_" + methname
expose("fx" + name, [values.W_Fixnum] * 2, simple=True)(do)
expose("unsafe-fx" + name, [unsafe(values.W_Fixnum)] * 2, simple=True)(do)
for args in [
("<", "lt"),
("<=", "le"),
(">", "gt"),
(">=", "ge"),
("=", "eq"),
]:
make_fixedtype_cmps(*args)
@expose("unsafe-flsqrt", [unsafe(values.W_Flonum)])
def flsqrt(f):
return f.arith_sqrt()
@expose("add1", [values.W_Number])
def add1(v):
return v.arith_add(values.W_Fixnum.ONE)
@expose("atan", [values.W_Number, default(values.W_Number, None)])
def atan(y, x):
if x is not None:
# FIXME: signs determine the quadrant of the result
# and care about NaNs and precision
if x.arith_zerop() is values.w_false:
z = y.arith_div(x)
else:
# we should raise exn_fail_contract_divide_by_zero
raise SchemeException("zero_divisor")
else:
z = y
return getattr(z, "arith_atan")()
def make_unary_arith(name, methname, flversion=False, fxversion=False,
unwrap_type=values.W_Number):
def do(a):
return getattr(a, methname)()
do.__name__ = methname
expose(name, [unwrap_type], simple=True)(do)
if flversion:
@expose("fl" + name, [values.W_Flonum], simple=True)
def dofl(a):
return getattr(a, methname)()
dofl.__name__ = methname
if fxversion:
@expose("fx" + name, [values.W_Fixnum], simple=True)
def dofx(a):
return getattr(a, methname)()
dofx.__name__ = methname
for args in [
("sin", "arith_sin", True),
("cos", "arith_cos", True),
("tan", "arith_tan", True),
("sinh", "arith_sinh", True),
("cosh", "arith_cosh", True),
("tanh", "arith_tanh", True),
("sqrt", "arith_sqrt", True),
("asin", "arith_asin", True),
("acos", "arith_acos", True),
# ("tan", "arith_tan", True), down below
("log", "arith_log", True),
("sub1", "arith_sub1"),
("inexact->exact", "arith_inexact_exact"),
("exact->inexact", "arith_exact_inexact"),
("zero?", "arith_zerop"),
("abs", "arith_abs", True),
("round", "arith_round", True),
("truncate", "arith_truncate", True),
("floor", "arith_floor", True),
("ceiling", "arith_ceiling", True),
("bitwise-not", "arith_not", False, False, values.W_Integer),
("exp", "arith_exp", True),
]:
make_unary_arith(*args)
@expose("odd?", [values.W_Number])
def oddp(n):
if not n.isinteger():
raise SchemeException("odd?: expected integer got %s" % n.tostring())
return n.arith_oddp()
@expose("even?", [values.W_Number])
def evenp(n):
if not n.isinteger():
raise SchemeException("even?: expected integer got %s" % n.tostring())
return n.arith_evenp()
@expose("negative?", [values.W_Number])
def negative_predicate(n):
if not is_real(n):
raise SchemeException("negative?: expected real? in argument 0")
return n.arith_negativep()
@expose("positive?", [values.W_Number])
def positive_predicate(n):
if not is_real(n):
raise SchemeException("positive?: expected real? in argument 0")
return n.arith_positivep()
@expose("bitwise-bit-set?", [values.W_Integer, values.W_Integer])
def bitwise_bit_setp(w_n, w_m):
if w_m.arith_negativep() is values.w_true:
raise SchemeException("bitwise-bit-set?: second argument must be non-negative")
if not isinstance(w_m, values.W_Fixnum):
# a bignum that has such a big bit set does not fit in memory
return w_n.arith_negativep()
v = w_n.arith_and(arith_shift(values.W_Fixnum.ONE, w_m))
if isinstance(v, values.W_Fixnum) and 0 == v.value:
return values.w_false
else:
return values.w_true
def arith_shift(w_a, w_b):
# XXX support biginteger as second argument (returning 0 and out of memory)
b = w_b.value
if b >= 0:
return w_a.arith_shl(w_b)
else:
return w_a.arith_shr(values.W_Fixnum(-b))
# don't use the decorator to make the function usable in this file
expose("arithmetic-shift", [values.W_Integer, values.W_Fixnum])(arith_shift)
@expose("fxlshift", [values.W_Fixnum, values.W_Fixnum])
def fxlshift(w_a, w_b):
b = w_b.value
if 0 <= b <= 64:
try:
res = rarithmetic.ovfcheck(w_a.value << b)
except OverflowError:
raise SchemeException(
"fxlshift: result is not a fixnum")
return values.W_Fixnum(res)
else:
raise SchemeException(
"fxlshift: expected integer >= 0 and <= 64, got %s" % w_b.tostring())
@expose("fxrshift", [values.W_Fixnum, values.W_Fixnum])
def fxrshift(w_a, w_b):
b = w_b.value
if b >= 0:
return w_a.arith_shr(w_b)
else:
raise SchemeException("fxrshift: expected positive argument, got %s"%w_b)
@expose("make-rectangular", [values.W_Number, values.W_Number])
def make_rectangular(x, y):
if not is_real(x) or not is_real(y):
raise SchemeException("make-rectangular: expected real inputs")
return values.W_Complex.from_real_pair(x, y)
## Unsafe Fixnum ops
@expose("unsafe-fxlshift", [unsafe(values.W_Fixnum), unsafe(values.W_Fixnum)])
def unsafe_fxlshift(w_a, w_b):
res = rarithmetic.intmask(w_a.value << w_b.value)
return values.W_Fixnum(res)
@expose("unsafe-fxrshift", [unsafe(values.W_Fixnum), unsafe(values.W_Fixnum)])
def unsafe_fxrshift(w_a, w_b):
res = w_a.value >> w_b.value
return values.W_Fixnum(res)
@expose("unsafe-fxand", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxand(w_a, w_b):
return w_a.arith_and(w_b)
@expose("unsafe-fxior", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxior(w_a, w_b):
return w_a.arith_or(w_b)
@expose("unsafe-fxxor", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxxor(w_a, w_b):
return w_a.arith_xor(w_b)
@expose("unsafe-fx+", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxplus(a, b):
return values.W_Fixnum(a.value + b.value)
@expose("unsafe-fx-", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxminus(a, b):
return values.W_Fixnum(a.value - b.value)
@expose("unsafe-fx*", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxtimes(a, b):
return values.W_Fixnum(a.value * b.value)
@expose("unsafe-fxmin", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxmin(a, b):
return values.W_Fixnum(min(a.value, b.value))
@expose("unsafe-fxmax", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxmax(a, b):
return values.W_Fixnum(max(a.value, b.value))
@expose("unsafe-fxmodulo", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxtimes(a, b):
return values.W_Fixnum(a.value % b.value)
@expose("unsafe-fxquotient", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxquotient(a, b):
return values.W_Fixnum(rarithmetic.int_c_div(a.value, b.value))
@expose("unsafe-fxremainder", [unsafe(values.W_Fixnum)] * 2)
def unsafe_fxquotient(w_a, w_b):
a = abs(w_a.value)
b = abs(w_b.value)
res = a % b
if w_a.value < 0:
res = -res
return values.W_Fixnum(res)
@expose("fx->fl", [values.W_Fixnum])
def fxfl(a):
return values.W_Flonum(float(a.value))
@expose("unsafe-fx->fl", [unsafe(values.W_Fixnum)])
def unsafe_fxfl(a):
return values.W_Flonum(float(a.value))
@expose("->fl", [values.W_Object])
def to_fl(n):
if isinstance(n, values.W_Fixnum):
return values.W_Flonum(float(n.value))
if isinstance(n, values.W_Bignum):
return values.W_Flonum(rbigint.tofloat(n.value))
raise SchemeException("->fl: expected an exact-integer")
@expose("real->floating-point-bytes",
[values.W_Number, values.W_Fixnum, default(values.W_Bool, values.w_false)])
def real_floating_point_bytes(n, _size, big_endian):
if isinstance(n, values.W_Flonum):
v = n.value
elif isinstance(n, values.W_Fixnum):
v = float(n.value)
elif isinstance(n, values.W_Bignum):
v = rbigint.tofloat(n.value)
else:
raise SchemeException("real->floating-point-bytes: expected real")
size = _size.value
if size != 4 and size != 8:
raise SchemeException("real->floating-point-bytes: size not 4 or 8")
intval = longlong2float.float2longlong(v)
if big_endian is not values.w_false:
intval = rarithmetic.byteswap(intval)
chars = [chr((intval >> (i * 8)) % 256) for i in range(size)]
return values.W_Bytes.from_charlist(chars)
@expose("floating-point-bytes->real",
[values.W_Bytes, default(values.W_Object, values.w_false)])
def integer_bytes_to_integer(bstr, signed):
# XXX Currently does not make use of the signed parameter
bytes = bstr.as_bytes_list()
if len(bytes) not in (4, 8):
raise SchemeException(
"floating-point-bytes->real: byte string must have length 2, 4, or 8")
val = 0
for i, v in enumerate(bytes):
val += ord(v) << (i * 8)
return values.W_Flonum(longlong2float.longlong2float(val))
@expose("integer-bytes->integer",
[values.W_Bytes,
default(values.W_Object, values.w_false),
default(values.W_Object, values.w_false),
default(values.W_Fixnum, values.W_Fixnum.ZERO),
default(values.W_Fixnum, None)])
def integer_bytes_to_integer(bstr, signed, big_endian, w_start, w_end):
bytes = bstr.as_bytes_list()
start = w_start.value
if w_end is None:
end = len(bytes)
else:
end = w_end.value
if not (0 <= start < len(bytes)):
raise SchemeException(
"integer-bytes->integer: start position not in byte string")
if not (0 <= end <= len(bytes)):
raise SchemeException(
"integer-bytes->integer: end position not in byte string")
if end < start:
raise SchemeException(
"integer-bytes->integer: end position less than start position")
length = end - start
if length not in (2, 4, 8):
raise SchemeException(
"integer-bytes->integer: byte string must have length 2, 4, or 8")
if start != 0 or end != len(bytes):
bytes = bytes[start:end]
byteorder = "little" if big_endian is values.w_false else "big"
is_signed = signed is not values.w_false
big = rbigint.frombytes(bytes, byteorder, is_signed)
try:
result = values.W_Fixnum(big.toint())
except OverflowError:
result = values.W_Bignum(big)
return result
@expose("integer->integer-bytes",
[values.W_Number,
values.W_Fixnum,
default(values.W_Object, values.w_false),
default(values.W_Object, values.w_false),
default(values.W_Bytes, None),
default(values.W_Fixnum, values.W_Fixnum.ZERO)])
@jit.unroll_safe
def integer_to_integer_bytes(n, w_size, signed, big_endian, w_dest, w_start):
from rpython.rtyper.lltypesystem import rffi
if isinstance(n, values.W_Fixnum):
intval = n.value
elif isinstance(n, values.W_Bignum):
raise NotImplementedError("not implemented yet")
else:
raise SchemeException("integer->integer-bytes: expected exact integer")
size = jit.promote(w_size.value)
if size not in (2, 4, 8):
raise SchemeException("integer->integer-bytes: size not 2, 4, or 8")
size = size
start = w_start.value
if w_dest is not None:
chars = w_dest.as_bytes_list()
result = w_dest
else:
chars = ['\x00'] * size
result = values.W_Bytes.from_charlist(chars, immutable=False)
if start < 0:
raise SchemeException(
"integer->integer-bytes: start value less than zero")
if start + size > len(chars):
raise SchemeException(
"integer->integer-bytes: byte string length is less than starting "
"position plus size")
is_signed = signed is not values.w_false
for i in range(start, start+size):
chars[i] = chr(intval & 0xFF)
intval >>= 8
if big_endian is values.w_false:
return result
# Swap the bytes if for big endian
left = start
right = start + size - 1
while left < right:
chars[left], chars[right] = chars[right], chars[left]
left, right = left + 1, right - 1
return result
@expose("integer-length", [values.W_Object])
@jit.elidable
def integer_length(obj):
if isinstance(obj, values.W_Fixnum):
val = obj.value
if val < 0:
val = ~val
n = r_uint(val)
result = 0
while n:
n >>= r_uint(1)
result += 1
return values.wrap(result)
if isinstance(obj, values.W_Bignum):
# XXX The bit_length operation on rbigints is off by one for negative
# powers of two (this may be intentional?).
# So, we detect this case and apply a correction.
bignum = obj.value
negative_power_of_two = True
if not bignum.tobool():
return values.W_Fixnum.ZERO
elif bignum.sign != -1:
negative_power_of_two = False
else:
for i in range(bignum.size - 1):
if bignum.udigit(i) != 0:
negative_power_of_two = False
break
msd = bignum.udigit(r_uint(bignum.size - 1))
while msd:
if (msd & r_uint(0x1)) and msd != r_uint(1):
negative_power_of_two = False
break
msd >>= r_uint(1)
bit_length = bignum.bit_length()
if negative_power_of_two:
bit_length -= 1
return values.wrap(bit_length)
raise SchemeException("integer-length: expected exact-integer? got %s" % obj.tostring())
# FIXME: implementation
@expose("fxvector?", [values.W_Object])
def is_fxvector(v):
return values.w_false
@expose("flvector?", [values.W_Object])
def is_flvector(v):
return values.W_Bool.make(isinstance(v, values_vector.W_FlVector))
## Unsafe Flonum ops
@expose("unsafe-fl+", [unsafe(values.W_Flonum)] * 2)
def unsafe_flplus(a, b):
return values.W_Flonum(a.value + b.value)
@expose("unsafe-fl-", [unsafe(values.W_Flonum)] * 2)
def unsafe_flminus(a, b):
return values.W_Flonum(a.value - b.value)
@expose("unsafe-fl*", [unsafe(values.W_Flonum)] * 2)
def unsafe_fltimes(a, b):
return values.W_Flonum(a.value * b.value)
@expose("unsafe-fl/", [unsafe(values.W_Flonum)] * 2)
def unsafe_fldiv(a, b):
return values.W_Flonum(a.value / b.value)
@expose("unsafe-flmin", [unsafe(values.W_Flonum)] * 2)
def unsafe_flmin(a, b):
return values.W_Flonum(min(a.value, b.value))
@expose("unsafe-flmax", [unsafe(values.W_Flonum)] * 2)
def unsafe_flmax(a, b):
return values.W_Flonum(max(a.value, b.value))
@expose("unsafe-flabs", [unsafe(values.W_Flonum)])
def unsafe_flabs(a):
return values.W_Flonum(abs(a.value))
|
magnusmorton/pycket
|
pycket/prims/numeric.py
|
Python
|
mit
| 23,301 | 0.008412 |
"""
SALTS XBMC Addon
Copyright (C) 2014 tknorris
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 re
import urlparse
import kodi
import log_utils # @UnusedImport
import dom_parser
from salts_lib import scraper_utils
from salts_lib.constants import FORCE_NO_MATCH
from salts_lib.constants import VIDEO_TYPES
from salts_lib.utils2 import i18n
import scraper
BASE_URL = 'http://www.rlshd.net'
class Scraper(scraper.Scraper):
base_url = BASE_URL
def __init__(self, timeout=scraper.DEFAULT_TIMEOUT):
self.timeout = timeout
self.base_url = kodi.get_setting('%s-base_url' % (self.get_name()))
@classmethod
def provides(cls):
return frozenset([VIDEO_TYPES.EPISODE])
@classmethod
def get_name(cls):
return 'RLSHD'
def get_sources(self, video):
source_url = self.get_url(video)
hosters = []
if source_url and source_url != FORCE_NO_MATCH:
url = urlparse.urljoin(self.base_url, source_url)
html = self._http_get(url, require_debrid=True, cache_limit=.5)
sources = self.__get_post_links(html, video)
for source in sources:
if scraper_utils.excluded_link(source): continue
host = urlparse.urlparse(source).hostname
hoster = {'multi-part': False, 'host': host, 'class': self, 'views': None, 'url': source, 'rating': None, 'quality': sources[source], 'direct': False}
hosters.append(hoster)
return hosters
def __get_post_links(self, html, video):
sources = {}
post = dom_parser.parse_dom(html, 'article', {'id': 'post-\d+'})
if post:
for fragment in dom_parser.parse_dom(post[0], 'h2'):
for match in re.finditer('href="([^"]+)', fragment):
stream_url = match.group(1)
meta = scraper_utils.parse_episode_link(stream_url)
release_quality = scraper_utils.height_get_quality(meta['height'])
host = urlparse.urlparse(stream_url).hostname
quality = scraper_utils.get_quality(video, host, release_quality)
sources[stream_url] = quality
return sources
def get_url(self, video):
return self._blog_get_url(video)
@classmethod
def get_settings(cls):
settings = super(cls, cls).get_settings()
settings = scraper_utils.disable_sub_check(settings)
name = cls.get_name()
settings.append(' <setting id="%s-filter" type="slider" range="0,180" option="int" label=" %s" default="30" visible="eq(-3,true)"/>' % (name, i18n('filter_results_days')))
settings.append(' <setting id="%s-select" type="enum" label=" %s" lvalues="30636|30637" default="0" visible="eq(-4,true)"/>' % (name, i18n('auto_select')))
return settings
def search(self, video_type, title, year, season=''): # @UnusedVariable
html = self._http_get(self.base_url, params={'s': title}, require_debrid=True, cache_limit=1)
post_pattern = 'class="entry-title">\s*<a[^>]+href="(?P<url>[^"]*/(?P<date>\d{4}/\d{1,2}/\d{1,2})/[^"]*)[^>]+>(?P<post_title>[^<]+)'
date_format = '%Y/%m/%d'
return self._blog_proc_results(html, post_pattern, date_format, video_type, title, year)
|
odicraig/kodi2odi
|
addons/plugin.video.salts/scrapers/rlshd_scraper.py
|
Python
|
gpl-3.0
| 3,957 | 0.004043 |
"""Order/create a VLAN instance."""
# :license: MIT, see LICENSE for more details.
import click
import SoftLayer
from SoftLayer.managers import ordering
from SoftLayer.CLI import environment
from SoftLayer.CLI import exceptions
from SoftLayer.CLI import formatting
@click.command()
@click.option('--name', required=False, prompt=True, help="Vlan name")
@click.option('--datacenter', '-d', required=False, help="Datacenter shortname")
@click.option('--pod', '-p', required=False, help="Pod name. E.g dal05.pod01")
@click.option('--network', default='public', show_default=True, type=click.Choice(['public', 'private']),
help='Network vlan type')
@click.option('--billing', default='hourly', show_default=True, type=click.Choice(['hourly', 'monthly']),
help="Billing rate")
@environment.pass_env
def cli(env, name, datacenter, pod, network, billing):
"""Order/create a VLAN instance."""
item_package = ['PUBLIC_NETWORK_VLAN']
complex_type = 'SoftLayer_Container_Product_Order_Network_Vlan'
extras = {'name': name}
if pod:
datacenter = pod.split('.')[0]
mgr = SoftLayer.NetworkManager(env.client)
pods = mgr.get_pods()
for router in pods:
if router.get('name') == pod:
if network == 'public':
extras['routerId'] = router.get('frontendRouterId')
elif network == 'private':
extras['routerId'] = router.get('backendRouterId')
break
if not extras.get('routerId'):
raise exceptions.CLIAbort(
"Unable to find pod name: {}".format(pod))
if network == 'private':
item_package = ['PRIVATE_NETWORK_VLAN']
ordering_manager = ordering.OrderingManager(env.client)
result = ordering_manager.place_order(package_keyname='NETWORK_VLAN',
location=datacenter,
item_keynames=item_package,
complex_type=complex_type,
hourly=billing,
extras=extras)
table = formatting.KeyValueTable(['name', 'value'])
table.align['name'] = 'r'
table.align['value'] = 'l'
table.add_row(['id', result['orderId']])
table.add_row(['created', result['orderDate']])
table.add_row(['name', result['orderDetails']['orderContainers'][0]['name']])
env.fout(table)
|
softlayer/softlayer-python
|
SoftLayer/CLI/vlan/create.py
|
Python
|
mit
| 2,493 | 0.001604 |
"""Interpolators wrap arrays to allow the array to be indexed in continuous coordinates
This module uses the trackvis coordinate system, for more information about
this coordinate system please see dipy.tracking.utils
The following modules also use this coordinate system:
dipy.tracking.utils
dipy.tracking.integration
dipy.reconst.interpolate
"""
from numpy import array
from dipy.reconst.recspeed import trilinear_interp
class OutsideImage(Exception):
pass
class Interpolator(object):
"""Class to be subclassed by different interpolator types"""
def __init__(self, data, voxel_size):
self.data = data
self.voxel_size = array(voxel_size, dtype=float, copy=True)
class NearestNeighborInterpolator(Interpolator):
"""Interpolates data using nearest neighbor interpolation"""
def __getitem__(self, index):
index = tuple(index // self.voxel_size)
if min(index) < 0:
raise OutsideImage('Negative Index')
try:
return self.data[index]
except IndexError:
raise OutsideImage
class TriLinearInterpolator(Interpolator):
"""Interpolates data using trilinear interpolation
interpolate 4d diffusion volume using 3 indices, ie data[x, y, z]
"""
def __init__(self, data, voxel_size):
super(TriLinearInterpolator, self).__init__(data, voxel_size)
if self.voxel_size.shape != (3,) or self.data.ndim != 4:
raise ValueError("Data should be 4d volume of diffusion data and "
"voxel_size should have 3 values, ie the size "
"of a 3d voxel")
def __getitem__(self, index):
index = array(index, copy=False, dtype="float")
try:
return trilinear_interp(self.data, index, self.voxel_size)
except IndexError:
raise OutsideImage
|
mdesco/dipy
|
dipy/reconst/interpolate.py
|
Python
|
bsd-3-clause
| 1,865 | 0.002681 |
# copied from OpenCAMLib Google code project, Anders Wallin says it was originally from Julian Todd. License unknown, likely to be GPL
# python stl file tools
import re
import struct
import math
import sys
###########################################################################
def TriangleNormal(x0, y0, z0, x1, y1, z1, x2, y2, z2):
# calculate facet normal
v01 = (x1 - x0, y1 - y0, z1 - z0)
v02 = (x2 - x0, y2 - y0, z2 - z0)
n = ( v01[1] * v02[2] - v01[2] * v02[1],
v01[2] * v02[0] - v01[0] * v02[2],
v01[0] * v02[1] - v01[1] * v02[0])
ln = math.sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2])
if ln > 0.0:
return (n[0] / ln, n[1] / ln, n[2] / ln)
###########################################################################
class reader:
def __init__(self, fn = None):
self.fn = fn
if self.fn:
fl = open(self.fn, "r")
self.isascii = self.IsAscii(fl)
fl.close()
self.little_endian = (struct.unpack("<f", struct.pack("@f", 140919.00))[0] == 140919.00)
# print "computer is little endian: ", self.little_endian
# print "file is ascii: ", self.isascii
self.nfacets = 0
self.ndegenerate = 0
self.mr = MeasureBoundingBox()
def IsAscii(self, fdata):
l = fdata.readline(1024)
isascii = l[:5] == "solid" and (len(l) == 5 or (re.search("[^A-Za-z0-9\,\.\/\;\:\'\"\+\-\s\r\n]", l[6:]) == None)) # some files say 'solid' but are binary files, we try to find a non alphanumerical character in the rest to the first line
fdata.seek(0)
return isascii
def ReadVertex(self, l):
l = l.replace(",", ".") # Catia writes ASCII STL with , as decimal point
if re.search("facet", l) or re.search("outer", l) or re.search("endloop", l) or re.search("endfacet", l):
return
vertex = re.search("vertex\s*([\d\-+\.EeDd]+)\s*([\d\-+\.EeDd]+)\s*([\d\-+\.EeDd]+)", l)
if vertex:
return (float(vertex.group(1)), float(vertex.group(2)), float(vertex.group(3)))
def BinaryReadFacets(self, fl, fs = None):
# 80 bytes of header
hdr = fl.read(80)
# 4 bytes for number of facets
self.nfacets = struct.unpack("<i", fl.read(4))[0]
nfacets = 0
# we dont loop over self.nfacets because then we can recover any broken headers that show the wrong number of facets
while True:
try:
#50 byte records with normals and vertices per facet
fl.read(12) # override normal
xyz = struct.unpack("<9f", fl.read(36)) # little endian
if TriangleNormal(xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8]) == None:
self.ndegenerate = self.ndegenerate + 1
if (fs):
fs.PushTriangle(xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8])
self.mr.PushTriangle(xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8])
fl.read(2) # padding
nfacets += 1
except struct.error, e:
break
if self.nfacets != nfacets:
sys.stderr.write("Number of facets according to header: %d, number of facets read: %d\n" % (self.nfacets, nfacets))
self.nfacets = nfacets
def AsciiReadFacets(self, fl, fs = None):
lines = fl.readlines()
xyz = []
for l in lines:
tpl = self.ReadVertex(l)
if tpl:
xyz.append(tpl[0])
xyz.append(tpl[1])
xyz.append(tpl[2])
if len(xyz) == 9:
if not TriangleNormal(xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8]):
self.ndegenerate += 1
if (fs):
fs.PushTriangle(xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8])
self.nfacets += 1
self.mr.PushTriangle(xyz[0], xyz[1], xyz[2], xyz[3], xyz[4], xyz[5], xyz[6], xyz[7], xyz[8])
xyz = []
################################################################################
class writer:
def __init__(self, fn, write_ascii = False):
self.fn = fn
self.ascii = write_ascii
self.scale = 1.0
def write(self, fc):
self.fl = open(self.fn, "w")
self.WriteHeader(self.fl, fc.nfacets)
for t in xrange(fc.nfacets):
x0, y0, z0, x1, y1, z1, x2, y2, z2 = fc.GetFacet(t)
self.WriteFacet(x0, y0, z0, x1, y1, z1, x2, y2, z2)
self.WriteFooter(self.fl)
self.fl.flush()
self.fl.close()
def WriteHeader(self, fl, nfacets):
if self.ascii:
fl.write("solid\n")
else:
str = "Stereolithography "
assert(len(str) == 80)
fl.write(str)
fl.write(struct.pack("<i", nfacets))
def WriteFacet(self, x0, y0, z0, x1, y1, z1, x2, y2, z2, skip_degenerated = True):
if self.scale != 1.0:
x0 *= self.scale
y0 *= self.scale
z0 *= self.scale
x1 *= self.scale
y1 *= self.scale
z1 *= self.scale
x2 *= self.scale
y2 *= self.scale
z2 *= self.scale
# calculate facet normal
n = TriangleNormal(x0, y0, z0, x1, y1, z1, x2, y2, z2)
if n == None:
if skip_degenerated: return
n = (0.0, 0.0, 0.0)
if self.ascii:
self.fl.write("facet normal %f %f %f\n" % n)
self.fl.write("outer loop\n vertex %f %f %f\n vertex %f %f %f\n vertex %f %f %f\nendloop\nendfacet\n" %
(x0, y0, z0, x1, y1, z1, x2, y2, z2))
else:
self.fl.write(struct.pack("<12f2c", n[0], n[1], n[2], x0, y0, z0, x1, y1, z1, x2, y2, z2, " ", " "))
def WriteFooter(self, fl):
if self.ascii:
fl.write("endsolid\n")
def PushTriangle(self, x0, y0, z0, x1, y1, z1, x2, y2, z2):
self.WriteFacet(x0, y0, z0, x1, y1, z1, x2, y2, z2)
################################################################################
class MeasureBoundingBox:
def __init__(self):
self.xlo = None
self.xhi = None
self.ylo = None
self.yhi = None
self.zlo = None
self.zhi = None
def PushTriangle(self, x0, y0, z0, x1, y1, z1, x2, y2, z2):
for v in [(x0, y0, z0), (x1, y1, z1), (x2, y2, z2)]:
if self.xlo is None or v[0] < self.xlo:
self.xlo = v[0]
if self.ylo is None or v[1] < self.ylo:
self.ylo = v[1]
if self.zlo is None or v[2] < self.zlo:
self.zlo = v[2]
if self.xhi is None or v[0] > self.xhi:
self.xhi = v[0]
if self.yhi is None or v[1] > self.yhi:
self.yhi = v[1]
if self.zhi is None or v[2] > self.zhi:
self.zhi = v[2]
###########################################################################
class converter(reader):
def __init__(self, fin = None):
reader.__init__(self, fin)
# read to find number of facets, but substract degenerated facets
self.wr = None
def convert(self, fout, freadfrom = None):
if self.fn:
rmod = self.isascii and "r" or "rb"
fl = open(self.fn, rmod)
if self.isascii:
self.AsciiReadFacets(fl)
else:
self.BinaryReadFacets(fl)
fl.close()
elif freadfrom:
if self.isascii:
self.AsciiReadFacets(freadfrom)
else:
self.BinaryReadFacets(freadfrom)
freadfrom.seek(0) # rewind to start
self.wr = writer(fout, not self.isascii)
wmod = self.isascii and "wb" or "w"
self.fpout = open(fout, wmod)
self.wr.fl = self.fpout
self.wr.WriteHeader(self.fpout, self.nfacets - self.ndegenerate)
self.ndegenerate = 0
if self.fn:
rmod = self.isascii and "r" or "rb"
fl = open(self.fn, rmod)
if self.isascii:
self.AsciiReadFacets(fl, self)
else:
self.BinaryReadFacets(fl, self)
fl.close()
elif freadfrom:
if self.isascii:
self.AsciiReadFacets(freadfrom, self)
else:
self.BinaryReadFacets(freadfrom, self)
self.wr.WriteFooter(self.fpout)
self.fpout.close()
def PushTriangle(self, x0, y0, z0, x1, y1, z1, x2, y2, z2):
if self.wr != None:
self.wr.WriteFacet(x0, y0, z0, x1, y1, z1, x2, y2, z2)
###########################################################################
# use all the options flag. could have -tk which causes it to import using tk, -in, -out
# design all the settings so it works as pipe, or as files.
# stltools --in=file.stl --out=fil1.stl -b/-a if --out missing then piping
# stltools --tk does the following.
# stltools --in=file.stl --stats prints bounding box etc.
if __name__ == '__main__':
import tkFileDialog
fin = tkFileDialog.askopenfilename(
defaultextension = '*.stl',
filetypes = [('Stereolithography','*.stl'),('all files','*.*')],
title = "Open STL")
a = converter(fin)
t = a.isascii and "Save as STL (Binary format)" or "Save as STL (ASCII format)"
fout = tkFileDialog.asksaveasfilename(
defaultextension = '*.stl',
filetypes = [('Stereolithography','*.stl'),('all files','*.*')],
title = t)
a.convert(fout)
# Example STL ascii file:
#
# solid
# ...
# facet normal 0.00 0.00 1.00
# outer loop
# vertex 2.00 2.00 0.00
# vertex -1.00 1.00 0.00
# vertex 0.00 -1.00 0.00
# endloop
# endfacet
# ...
# endsolid
|
JohnyEngine/CNC
|
heekscnc/STLTools.py
|
Python
|
apache-2.0
| 10,565 | 0.015618 |
##########################################################################
#
# Copyright (c) 2011-2012, John Haddon. All rights reserved.
# Copyright (c) 2011-2012, Image Engine Design Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above
# copyright notice, this list of conditions and the following
# disclaimer.
#
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following
# disclaimer in the documentation and/or other materials provided with
# the distribution.
#
# * Neither the name of John Haddon nor the names of
# any other contributors to this software 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 OWNER 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 unittest
import IECore
import Gaffer
import GafferTest
import GafferUI
import GafferUITest
class GadgetTest( GafferUITest.TestCase ) :
def testTransform( self ) :
g = GafferUI.TextGadget( "hello" )
self.assertEqual( g.getTransform(), IECore.M44f() )
t = IECore.M44f.createScaled( IECore.V3f( 2 ) )
g.setTransform( t )
self.assertEqual( g.getTransform(), t )
c1 = GafferUI.LinearContainer()
c1.addChild( g )
c2 = GafferUI.LinearContainer()
c2.addChild( c1 )
t2 = IECore.M44f.createTranslated( IECore.V3f( 1, 2, 3 ) )
c2.setTransform( t2 )
self.assertEqual( g.fullTransform(), t * t2 )
self.assertEqual( g.fullTransform( c1 ), t )
def testToolTip( self ) :
g = GafferUI.TextGadget( "hello" )
self.assertEqual( g.getToolTip( IECore.LineSegment3f() ), "" )
g.setToolTip( "hi" )
self.assertEqual( g.getToolTip( IECore.LineSegment3f() ), "hi" )
def testDerivationInPython( self ) :
class MyGadget( GafferUI.Gadget ) :
def __init__( self ) :
GafferUI.Gadget.__init__( self )
def bound( self ) :
return IECore.Box3f( IECore.V3f( -20, 10, 2 ), IECore.V3f( 10, 15, 5 ) )
mg = MyGadget()
# we can't call the methods of the gadget directly in python to test the
# bindings, as that doesn't prove anything (we're no exercising the virtual
# method override code in the wrapper). instead cause c++ to call through
# for us by adding our gadget to a parent and making calls to the parent.
c = GafferUI.IndividualContainer()
c.addChild( mg )
self.assertEqual( c.bound().size(), mg.bound().size() )
def testStyle( self ) :
g = GafferUI.TextGadget( "test" )
l = GafferUI.LinearContainer()
l.addChild( g )
self.assertEqual( g.getStyle(), None )
self.assertEqual( l.getStyle(), None )
self.failUnless( g.style().isSame( GafferUI.Style.getDefaultStyle() ) )
self.failUnless( l.style().isSame( GafferUI.Style.getDefaultStyle() ) )
s = GafferUI.StandardStyle()
l.setStyle( s )
self.failUnless( l.getStyle().isSame( s ) )
self.assertEqual( g.getStyle(), None )
self.failUnless( g.style().isSame( s ) )
self.failUnless( l.style().isSame( s ) )
def testTypeNamePrefixes( self ) :
self.assertTypeNamesArePrefixed( GafferUI )
self.assertTypeNamesArePrefixed( GafferUITest )
def testRenderRequestOnStyleChange( self ) :
g = GafferUI.Gadget()
cs = GafferTest.CapturingSlot( g.renderRequestSignal() )
self.assertEqual( len( cs ), 0 )
s = GafferUI.StandardStyle()
g.setStyle( s )
self.assertEqual( len( cs ), 1 )
self.assertTrue( cs[0][0].isSame( g ) )
s2 = GafferUI.StandardStyle()
g.setStyle( s2 )
self.assertEqual( len( cs ), 2 )
self.assertTrue( cs[1][0].isSame( g ) )
s2.setColor( GafferUI.StandardStyle.Color.BackgroundColor, IECore.Color3f( 1 ) )
self.assertEqual( len( cs ), 3 )
self.assertTrue( cs[2][0].isSame( g ) )
def testHighlighting( self ) :
g = GafferUI.Gadget()
self.assertEqual( g.getHighlighted(), False )
g.setHighlighted( True )
self.assertEqual( g.getHighlighted(), True )
g.setHighlighted( False )
self.assertEqual( g.getHighlighted(), False )
cs = GafferTest.CapturingSlot( g.renderRequestSignal() )
g.setHighlighted( False )
self.assertEqual( len( cs ), 0 )
g.setHighlighted( True )
self.assertEqual( len( cs ), 1 )
self.assertTrue( cs[0][0].isSame( g ) )
def testVisibility( self ) :
g1 = GafferUI.Gadget()
self.assertEqual( g1.getVisible(), True )
self.assertEqual( g1.visible(), True )
g1.setVisible( False )
self.assertEqual( g1.getVisible(), False )
self.assertEqual( g1.visible(), False )
g2 = GafferUI.Gadget()
g1.addChild( g2 )
self.assertEqual( g2.getVisible(), True )
self.assertEqual( g2.visible(), False )
g1.setVisible( True )
self.assertEqual( g2.visible(), True )
g3 = GafferUI.Gadget()
g2.addChild( g3 )
self.assertEqual( g3.getVisible(), True )
self.assertEqual( g3.visible(), True )
g1.setVisible( False )
self.assertEqual( g3.getVisible(), True )
self.assertEqual( g3.visible(), False )
self.assertEqual( g3.visible( relativeTo = g2 ), True )
self.assertEqual( g3.visible( relativeTo = g1 ), True )
def testVisibilitySignals( self ) :
g = GafferUI.Gadget()
cs = GafferTest.CapturingSlot( g.renderRequestSignal() )
self.assertEqual( len( cs ), 0 )
g.setVisible( True )
self.assertEqual( len( cs ), 0 )
g.setVisible( False )
self.assertEqual( len( cs ), 1 )
self.assertEqual( cs[0][0], g )
g.setVisible( False )
self.assertEqual( len( cs ), 1 )
self.assertEqual( cs[0][0], g )
g.setVisible( True )
self.assertEqual( len( cs ), 2 )
self.assertEqual( cs[1][0], g )
def testBoundIgnoresHiddenChildren( self ) :
g = GafferUI.Gadget()
t = GafferUI.TextGadget( "text" )
g.addChild( t )
b = t.bound()
self.assertEqual( g.bound(), b )
t.setVisible( False )
# we still want to know what the bound would be for t,
# even when it's hidden.
self.assertEqual( t.bound(), b )
# but we don't want it taken into account when computing
# the parent bound.
self.assertEqual( g.bound(), IECore.Box3f() )
def testVisibilityChangedSignal( self ) :
g = GafferUI.Gadget()
g["a"] = GafferUI.Gadget()
g["a"]["c"] = GafferUI.Gadget()
g["b"] = GafferUI.Gadget()
events = []
def visibilityChanged( gadget ) :
events.append( ( gadget, gadget.visible() ) )
connnections = [
g.visibilityChangedSignal().connect( visibilityChanged ),
g["a"].visibilityChangedSignal().connect( visibilityChanged ),
g["a"]["c"].visibilityChangedSignal().connect( visibilityChanged ),
g["b"].visibilityChangedSignal().connect( visibilityChanged ),
]
g["b"].setVisible( True )
self.assertEqual( len( events ), 0 )
g["b"].setVisible( False )
self.assertEqual( len( events ), 1 )
self.assertEqual( events[0], ( g["b"], False ) )
g["b"].setVisible( True )
self.assertEqual( len( events ), 2 )
self.assertEqual( events[1], ( g["b"], True ) )
g["a"].setVisible( True )
self.assertEqual( len( events ), 2 )
g["a"].setVisible( False )
self.assertEqual( len( events ), 4 )
self.assertEqual( events[-2], ( g["a"]["c"], False ) )
self.assertEqual( events[-1], ( g["a"], False ) )
g["a"].setVisible( True )
self.assertEqual( len( events ), 6 )
self.assertEqual( events[-2], ( g["a"]["c"], True ) )
self.assertEqual( events[-1], ( g["a"], True ) )
g["a"]["c"].setVisible( False )
self.assertEqual( len( events ), 7 )
self.assertEqual( events[-1], ( g["a"]["c"], False ) )
g.setVisible( False )
self.assertEqual( len( events ), 10 )
self.assertEqual( events[-3], ( g["a"], False ) )
self.assertEqual( events[-2], ( g["b"], False ) )
self.assertEqual( events[-1], ( g, False ) )
g["a"]["c"].setVisible( True )
self.assertEqual( len( events ), 10 )
if __name__ == "__main__":
unittest.main()
|
chippey/gaffer
|
python/GafferUITest/GadgetTest.py
|
Python
|
bsd-3-clause
| 8,732 | 0.065964 |
import unittest
from distutils.errors import CompileError
from pythran.tests import TestFromDir
import os
import pythran
from pythran.syntax import PythranSyntaxError
from pythran.spec import Spec
class TestOpenMP(TestFromDir):
path = os.path.join(os.path.dirname(__file__), "openmp")
class TestOpenMP4(TestFromDir):
path = os.path.join(os.path.dirname(__file__), "openmp.4")
@staticmethod
def interface(name, file=None):
return Spec({name: []})
@staticmethod
def extract_runas(name, filepath):
return ['#runas {}()'.format(name)]
class TestOpenMPLegacy(TestFromDir):
'''
Test old style OpenMP constructs, not using comments but strings
and relying on function-scope locals
'''
path = os.path.join(os.path.dirname(__file__), "openmp.legacy")
@staticmethod
def interface(name, file=None):
return Spec({name: []})
@staticmethod
def extract_runas(name, filepath):
return ['#runas {}()'.format(name)]
# only activate OpenMP tests if the underlying compiler supports OpenMP
try:
pythran.compile_cxxcode("omp", '#include <omp.h>',
extra_compile_args=['-fopenmp'],
extra_link_args=['-fopenmp'])
import omp
if '-fopenmp' in pythran.config.cfg.get('compiler', 'ldflags'):
TestOpenMP4.populate(TestOpenMP4)
TestOpenMP.populate(TestOpenMP)
TestOpenMPLegacy.populate(TestOpenMPLegacy)
except PythranSyntaxError:
raise
except (CompileError, ImportError):
pass
if __name__ == '__main__':
unittest.main()
|
serge-sans-paille/pythran
|
pythran/tests/test_openmp.py
|
Python
|
bsd-3-clause
| 1,597 | 0.001879 |
# testyacc.py
import unittest
try:
import StringIO
except ImportError:
import io as StringIO
import sys
import os
sys.path.insert(0,"..")
sys.tracebacklimit = 0
import ply.yacc
def check_expected(result,expected):
resultlines = []
for line in result.splitlines():
if line.startswith("WARNING: "):
line = line[9:]
elif line.startswith("ERROR: "):
line = line[7:]
resultlines.append(line)
expectedlines = expected.splitlines()
if len(resultlines) != len(expectedlines):
return False
for rline,eline in zip(resultlines,expectedlines):
if not rline.endswith(eline):
return False
return True
def run_import(module):
code = "import "+module
exec(code)
del sys.modules[module]
# Tests related to errors and warnings when building parsers
class YaccErrorWarningTests(unittest.TestCase):
def setUp(self):
sys.stderr = StringIO.StringIO()
sys.stdout = StringIO.StringIO()
try:
os.remove("parsetab.py")
os.remove("parsetab.pyc")
except OSError:
pass
def tearDown(self):
sys.stderr = sys.__stderr__
sys.stdout = sys.__stdout__
def test_yacc_badargs(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_badargs")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_badargs.py:23: Rule 'p_statement_assign' has too many arguments\n"
"yacc_badargs.py:27: Rule 'p_statement_expr' requires an argument\n"
))
def test_yacc_badid(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_badid")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_badid.py:32: Illegal name 'bad&rule' in rule 'statement'\n"
"yacc_badid.py:36: Illegal rule name 'bad&rule'\n"
))
def test_yacc_badprec(self):
try:
run_import("yacc_badprec")
except ply.yacc.YaccError:
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"precedence must be a list or tuple\n"
))
def test_yacc_badprec2(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_badprec2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"Bad precedence table\n"
))
def test_yacc_badprec3(self):
run_import("yacc_badprec3")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"Precedence already specified for terminal 'MINUS'\n"
"Generating LALR tables\n"
))
def test_yacc_badrule(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_badrule")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_badrule.py:24: Syntax error. Expected ':'\n"
"yacc_badrule.py:28: Syntax error in rule 'statement'\n"
"yacc_badrule.py:33: Syntax error. Expected ':'\n"
"yacc_badrule.py:42: Syntax error. Expected ':'\n"
))
def test_yacc_badtok(self):
try:
run_import("yacc_badtok")
except ply.yacc.YaccError:
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"tokens must be a list or tuple\n"))
def test_yacc_dup(self):
run_import("yacc_dup")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_dup.py:27: Function p_statement redefined. Previously defined on line 23\n"
"Token 'EQUALS' defined, but not used\n"
"There is 1 unused token\n"
"Generating LALR tables\n"
))
def test_yacc_error1(self):
try:
run_import("yacc_error1")
except ply.yacc.YaccError:
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_error1.py:61: p_error() requires 1 argument\n"))
def test_yacc_error2(self):
try:
run_import("yacc_error2")
except ply.yacc.YaccError:
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_error2.py:61: p_error() requires 1 argument\n"))
def test_yacc_error3(self):
try:
run_import("yacc_error3")
except ply.yacc.YaccError:
e = sys.exc_info()[1]
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"'p_error' defined, but is not a function or method\n"))
def test_yacc_error4(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_error4")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_error4.py:62: Illegal rule name 'error'. Already defined as a token\n"
))
def test_yacc_inf(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_inf")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"Token 'NUMBER' defined, but not used\n"
"There is 1 unused token\n"
"Infinite recursion detected for symbol 'statement'\n"
"Infinite recursion detected for symbol 'expression'\n"
))
def test_yacc_literal(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_literal")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_literal.py:36: Literal token '**' in rule 'expression' may only be a single character\n"
))
def test_yacc_misplaced(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_misplaced")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_misplaced.py:32: Misplaced '|'\n"
))
def test_yacc_missing1(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_missing1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_missing1.py:24: Symbol 'location' used, but not defined as a token or a rule\n"
))
def test_yacc_nested(self):
run_import("yacc_nested")
result = sys.stdout.getvalue()
self.assert_(check_expected(result,
"A\n"
"A\n"
"A\n",
))
def test_yacc_nodoc(self):
run_import("yacc_nodoc")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_nodoc.py:27: No documentation string specified in function 'p_statement_expr' (ignored)\n"
"Generating LALR tables\n"
))
def test_yacc_noerror(self):
run_import("yacc_noerror")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"no p_error() function is defined\n"
"Generating LALR tables\n"
))
def test_yacc_nop(self):
run_import("yacc_nop")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_nop.py:27: Possible grammar rule 'statement_expr' defined without p_ prefix\n"
"Generating LALR tables\n"
))
def test_yacc_notfunc(self):
run_import("yacc_notfunc")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"'p_statement_assign' not defined as a function\n"
"Token 'EQUALS' defined, but not used\n"
"There is 1 unused token\n"
"Generating LALR tables\n"
))
def test_yacc_notok(self):
try:
run_import("yacc_notok")
except ply.yacc.YaccError:
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"No token list is defined\n"))
def test_yacc_rr(self):
run_import("yacc_rr")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"Generating LALR tables\n"
"1 reduce/reduce conflict\n"
"reduce/reduce conflict in state 15 resolved using rule (statement -> NAME EQUALS NUMBER)\n"
"rejected rule (expression -> NUMBER)\n"
))
def test_yacc_simple(self):
run_import("yacc_simple")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"Generating LALR tables\n"
))
def test_yacc_sr(self):
run_import("yacc_sr")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"Generating LALR tables\n"
"20 shift/reduce conflicts\n"
))
def test_yacc_term1(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_term1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_term1.py:24: Illegal rule name 'NUMBER'. Already defined as a token\n"
))
def test_yacc_unused(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_unused")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_unused.py:62: Symbol 'COMMA' used, but not defined as a token or a rule\n"
"Symbol 'COMMA' is unreachable\n"
"Symbol 'exprlist' is unreachable\n"
))
def test_yacc_unused_rule(self):
run_import("yacc_unused_rule")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_unused_rule.py:62: Rule 'integer' defined, but not used\n"
"There is 1 unused rule\n"
"Symbol 'integer' is unreachable\n"
"Generating LALR tables\n"
))
def test_yacc_uprec(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_uprec")
result = sys.stderr.getvalue()
print repr(result)
self.assert_(check_expected(result,
"yacc_uprec.py:37: Nothing known about the precedence of 'UMINUS'\n"
))
def test_yacc_uprec2(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_uprec2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"yacc_uprec2.py:37: Syntax error. Nothing follows %prec\n"
))
def test_yacc_prec1(self):
self.assertRaises(ply.yacc.YaccError,run_import,"yacc_prec1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
"Precedence rule 'left' defined for unknown symbol '+'\n"
"Precedence rule 'left' defined for unknown symbol '*'\n"
"Precedence rule 'left' defined for unknown symbol '-'\n"
"Precedence rule 'left' defined for unknown symbol '/'\n"
))
unittest.main()
|
anuragiitg/nixysa
|
third_party/ply-3.1/test/testyacc.py
|
Python
|
apache-2.0
| 13,190 | 0.006444 |
import requests
import json
import restful_webapi
import os
# This example shows how to use the Requests library with RESTful API
# This web service stores arbitrary JSON data under integer keys
# We can use GET/POST/PUT/DELETE HTTP methods to modify the data
# Run a local server that we can use
restful_webapi.run_server()
service = 'http://localhost:8000'
print "Creating the message..."
created = None
data = json.dumps("Hello world")
r = requests.post(service, data=data)
created = r.json()['created']
print "Message ID: " + str(created)
print "Showing the message..."
r = requests.get(service + '/' + str(created))
print "Service returned: " + str(r.json())
print "Updating the message..."
data = json.dumps("Welcome, world")
r = requests.put(service + '/' + str(created), data=data)
print "Service returned: " + str(r.json())
print "Showing the message again..."
r = requests.get(service + '/' + str(created))
print "Service returned: " + str(r.json())
print "Deleting the message..."
r = requests.delete(service + '/' + str(created))
print "Service returned: " + str(r.json())
# Stop the s
|
sudikrt/costproML
|
staticDataGSir/restful.py
|
Python
|
apache-2.0
| 1,107 | 0 |
# -*- coding:utf-8 -*-
# @author xupingmao <578749341@qq.com>
# @since 2020/08/22 21:54:56
# @modified 2022/02/26 10:40:22
import xauth
import xtemplate
import xutils
import os
import re
import sys
import platform
import xconfig
from xutils import dateutil
from xutils import fsutil
from xutils import Storage
from xutils import mem_util
try:
import sqlite3
except ImportError:
sqlite3 = None
def get_xnote_version():
return xconfig.get_global_config("system.version")
def get_mem_info():
mem_used = 0
mem_total = 0
result = mem_util.get_mem_info()
mem_used = result.mem_used
sys_mem_used = result.sys_mem_used
sys_mem_total = result.sys_mem_total
return "%s/%s/%s" % (mem_used, sys_mem_used, sys_mem_total)
def get_python_version():
return sys.version
def get_startup_time():
return dateutil.format_time(xconfig.START_TIME)
def get_free_data_space():
try:
size = fsutil.get_free_space(xconfig.get_system_dir("data"))
return xutils.format_size(size)
except:
xutils.print_exc()
return "<未知>"
class SystemInfoItem:
def __init__(self, name = "", value = ""):
self.name = name
self.value = value
class InfoHandler:
@xauth.login_required("admin")
def GET(self):
items = [
SystemInfoItem("Python版本", value = get_python_version()),
SystemInfoItem("Xnote版本", value = get_xnote_version()),
SystemInfoItem("内存信息", value = get_mem_info()),
SystemInfoItem("磁盘可用容量", get_free_data_space()),
SystemInfoItem("sqlite版本", sqlite3.sqlite_version if sqlite3 != None else ''),
SystemInfoItem("CPU型号", platform.processor()),
SystemInfoItem("操作系统", platform.system()),
SystemInfoItem("操作系统版本", platform.version()),
SystemInfoItem("系统启动时间", get_startup_time()),
]
return xtemplate.render("system/page/system_info.html", items = items,
runtime_id = xconfig.RUNTIME_ID)
xurls = (
r"/system/info", InfoHandler
)
|
xupingmao/xnote
|
handlers/system/system_info.py
|
Python
|
gpl-3.0
| 2,138 | 0.013069 |
#
# Copyright (C) 2010 Kelvin Lawson (kelvinl@users.sourceforge.net)
#
# 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, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""This module defines the class pykPlayer, which is a base class used
by the modules pykar.py, pycdg.py, and pympg.py. This collects
together some common interfaces used by these different
implementations for different types of Karaoke files."""
from pykconstants import *
from pykmanager import manager
from pykenv import env
import pygame
import sys
import types
import os
class pykPlayer:
def __init__(self, song, songDb,
errorNotifyCallback = None, doneCallback = None,
windowTitle = None):
"""The first parameter, song, may be either a pykdb.SongStruct
instance, or it may be a filename. """
if songDb == None:
import pykdb
songDb = pykdb.globalSongDB
songDb.LoadSettings(None)
self.songDb = songDb
# Set the global command-line options if they have not already
# been set.
if manager.options == None:
parser = self.SetupOptions()
(manager.options, args) = parser.parse_args()
manager.ApplyOptions(self.songDb)
if song is None:
if (len(args) != 1):
parser.print_help()
sys.exit(2)
song = args[0]
# Unfortunately, we can't capture sound when dumping. There
# are two reasons for this. (1) pymedia doesn't currently
# support multiplexing audio with a video stream, so when
# you're dumping an mpeg file, it has to be video-only. (2)
# pygame doesn't provide a way for us to programmatically
# convert a midi file to sound samples anyway--all you can do
# with a midi file is route it through the speakers.
# So, for these reasons, we always just disable sound when
# dumping images or movies.
if manager.options.dump:
manager.options.nomusic = True
if isinstance(song, types.StringTypes):
# We were given a filename. Convert it to a SongStruct.
song = self.songDb.makeSongStruct(song)
# Store the parameters
self.Song = song
self.WindowTitle = windowTitle
# And look up the actual files corresponding to this SongStruct.
self.SongDatas = song.GetSongDatas()
if windowTitle is None:
self.WindowTitle = song.DisplayFilename
# Caller can register a callback by which we
# print out error information, use stdout if none registered
if errorNotifyCallback:
self.ErrorNotifyCallback = errorNotifyCallback
else:
self.ErrorNotifyCallback = self.__defaultErrorPrint
# Caller can register a callback by which we
# let them know when the song is finished
if doneCallback:
self.SongFinishedCallback = doneCallback
else:
self.SongFinishedCallback = None
self.State = STATE_INIT
self.InternalOffsetTime = 0
# These values are used to keep track of the current position
# through the song based on pygame's get_ticks() interface.
# It's used only when get_pos() cannot be used or is
# unreliable for some reason.
self.PlayTime = 0
self.PlayStartTime = 0
self.PlayFrame = 0
# self.PlayStartTime is valid while State == STATE_PLAYING; it
# indicates the get_ticks() value at which the song started
# (adjusted for any pause intervals that occurred during
# play). self.PlayTime is valid while State != STATE_PLAYING;
# it indicates the total number of ticks (milliseconds) that
# have elapsed in the song so far.
# self.PlayFrame starts at 0 and increments once for each
# frame. It's not very meaningful, except in STATE_CAPTURING
# mode.
# Keep track of the set of modifier buttons that are held
# down. This is currently used only for the GP2X interface.
self.ShoulderLHeld = False
self.ShoulderRHeld = False
# Set this true if the player can zoom font sizes.
self.SupportsFontZoom = False
# The following methods are part of the public API and intended to
# be exported from this class.
def Validate(self):
""" Returns True if the karaoke file appears to be playable
and contains lyrics, or False otherwise. """
return self.doValidate()
def Play(self):
self.doPlay()
if manager.options.dump:
self.setupDump()
else:
self.PlayStartTime = pygame.time.get_ticks()
self.State = STATE_PLAYING
# Pause the song - Use Pause() again to unpause
def Pause(self):
if self.State == STATE_PLAYING:
self.doPause()
self.PlayTime = pygame.time.get_ticks() - self.PlayStartTime
self.State = STATE_PAUSED
elif self.State == STATE_PAUSED:
self.doUnpause()
self.PlayStartTime = pygame.time.get_ticks() - self.PlayTime
self.State = STATE_PLAYING
# Close the whole thing down
def Close(self):
self.State = STATE_CLOSING
# you must call Play() to restart. Blocks until pygame is initialised
def Rewind(self):
self.doRewind()
self.PlayTime = 0
self.PlayStartTime = 0
self.PlayFrame = 0
self.State = STATE_NOT_PLAYING
# Stop the song and go back to the start. As you would
# expect Stop to do on a CD player. Play() restarts from
# the beginning
def Stop(self):
self.Rewind()
# Get the song length (in seconds)
def GetLength(self):
ErrorString = "GetLength() not supported"
self.ErrorNotifyCallback (ErrorString)
return None
# Get the current time (in milliseconds).
def GetPos(self):
if self.State == STATE_PLAYING:
return pygame.time.get_ticks() - self.PlayStartTime
else:
return self.PlayTime
def SetupOptions(self, usage = None):
""" Initialise and return optparse OptionParser object,
suitable for parsing the command line options to this
application. """
if usage == None:
usage = "%prog [options] <Karaoke file>"
return manager.SetupOptions(usage, self.songDb)
# Below methods are internal.
def setupDump(self):
# Capture the output as a sequence of numbered frame images.
self.PlayTime = 0
self.PlayStartTime = 0
self.PlayFrame = 0
self.State = STATE_CAPTURING
self.dumpFrameRate = manager.options.dump_fps
assert self.dumpFrameRate
filename = manager.options.dump
base, ext = os.path.splitext(filename)
ext_lower = ext.lower()
self.dumpEncoder = None
if ext_lower == '.mpg':
# Use pymedia to convert frames to an mpeg2 stream
# on-the-fly.
import pymedia
import pymedia.video.vcodec as vcodec
self.dumpFile = open(filename, 'wb')
frameRate = int(self.dumpFrameRate * 100 + 0.5)
self.dumpFrameRate = float(frameRate) / 100.0
params= { \
'type': 0,
'gop_size': 12,
'frame_rate_base': 125,
'max_b_frames': 0,
'height': manager.options.size_y,
'width': manager.options.size_x,
'frame_rate': frameRate,
'deinterlace': 0,
'bitrate': 9800000,
'id': vcodec.getCodecID('mpeg2video')
}
self.dumpEncoder = vcodec.Encoder( params )
return
# Don't dump a video file; dump a sequence of frames instead.
self.dumpPPM = (ext_lower == '.ppm' or ext_lower == '.pnm')
self.dumpAppend = False
# Convert the filename to a pattern.
if '#' in filename:
hash = filename.index('#')
end = hash
while end < len(filename) and filename[end] == '#':
end += 1
count = end - hash
filename = filename[:hash] + '%0' + str(count) + 'd' + filename[end:]
else:
# There's no hash in the filename.
if self.dumpPPM:
# We can dump a series of frames all to the same file,
# if we're dumping ppm frames. Mjpegtools likes this.
self.dumpAppend = True
try:
os.remove(filename)
except OSError:
pass
else:
# Implicitly append a frame number.
filename = base + '%04d' + ext
self.dumpFilename = filename
def doFrameDump(self):
if self.dumpEncoder:
import pymedia.video.vcodec as vcodec
ss = pygame.image.tostring(manager.surface, "RGB")
bmpFrame = vcodec.VFrame(
vcodec.formats.PIX_FMT_RGB24,
manager.surface.get_size(), (ss,None,None))
yuvFrame = bmpFrame.convert(vcodec.formats.PIX_FMT_YUV420P)
d = self.dumpEncoder.encode(yuvFrame)
self.dumpFile.write(d.data)
return
if self.dumpAppend:
filename = self.dumpFilename
else:
filename = self.dumpFilename % self.PlayFrame
print filename
if self.dumpPPM:
# Dump a PPM file. We do PPM by hand since pygame
# doesn't support it directly, but it's so easy and
# useful.
w, h = manager.surface.get_size()
if self.dumpAppend:
f = open(filename, 'ab')
else:
f = open(filename, 'wb')
f.write('P6\n%s %s 255\n' % (w, h))
f.write(pygame.image.tostring(manager.surface, 'RGB'))
else:
# Ask pygame to dump the file. We trust that pygame knows
# how to store an image in the requested format.
pygame.image.save(manager.surface, filename)
def doValidate(self):
return True
def doPlay(self):
pass
def doPause(self):
pass
def doUnpause(self):
pass
def doRewind(self):
pass
def doStuff(self):
# Override this in a derived class to do some useful per-frame
# activity.
# Common handling code for a close request or if the
# pygame window was quit
if self.State == STATE_CLOSING:
if manager.display:
manager.display.fill((0,0,0))
pygame.display.flip()
self.shutdown()
elif self.State == STATE_CAPTURING:
# We are capturing a video file.
self.doFrameDump()
# Set the frame time for the next frame.
self.PlayTime = 1000.0 * self.PlayFrame / self.dumpFrameRate
self.PlayFrame += 1
def doResize(self, newSize):
# This will be called internally whenever the window is
# resized for any reason, either due to an application resize
# request being processed, or due to the user dragging the
# window handles.
pass
def doResizeBegin(self):
# This will be called internally before the screen is resized
# by pykmanager and doResize() is called. Not all players need
# to do anything here.
pass
def doResizeEnd(self):
# This will be called internally after the screen is resized
# by pykmanager and doResize() is called. Not all players need
# to do anything here.
pass
def handleEvent(self, event):
if event.type == pygame.USEREVENT:
self.Close()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.Close()
elif event.key == pygame.K_PAUSE or event.key == pygame.K_p:
self.Pause()
elif event.key == pygame.K_BACKSPACE or event.key == pygame.K_DELETE:
self.Rewind()
self.Play()
# Use control-left/right arrow to offset the current
# graphics time by 1/4 sec. Use control-down arrow to
# restore them to sync.
elif self.State == STATE_PLAYING and event.key == pygame.K_RIGHT and event.mod & (pygame.KMOD_LCTRL | pygame.KMOD_RCTRL):
manager.settings.SyncDelayMs += 250
print "sync %s" % manager.settings.SyncDelayMs
elif self.State == STATE_PLAYING and event.key == pygame.K_LEFT and event.mod & (pygame.KMOD_LCTRL | pygame.KMOD_RCTRL):
manager.settings.SyncDelayMs -= 250
print "sync %s" % manager.settings.SyncDelayMs
elif self.State == STATE_PLAYING and event.key == pygame.K_DOWN and event.mod & (pygame.KMOD_LCTRL | pygame.KMOD_RCTRL):
manager.settings.SyncDelayMs = 0
print "sync %s" % manager.settings.SyncDelayMs
if self.SupportsFontZoom:
if event.key == pygame.K_PLUS or event.key == pygame.K_EQUALS or \
event.key == pygame.K_KP_PLUS:
manager.ZoomFont(1.0/0.9)
elif event.key == pygame.K_MINUS or event.key == pygame.K_UNDERSCORE or \
event.key == pygame.K_KP_MINUS:
manager.ZoomFont(0.9)
elif event.type == pygame.QUIT:
self.Close()
elif env == ENV_GP2X and event.type == pygame.JOYBUTTONDOWN:
if event.button == GP2X_BUTTON_SELECT:
self.Close()
elif event.button == GP2X_BUTTON_START:
self.Pause()
elif event.button == GP2X_BUTTON_L:
self.ShoulderLHeld = True
elif event.button == GP2X_BUTTON_R:
self.ShoulderRHeld = True
if self.SupportsFontZoom:
if event.button == GP2X_BUTTON_RIGHT and self.ShoulderLHeld:
manager.ZoomFont(1.0/0.9)
elif event.button == GP2X_BUTTON_LEFT and self.ShoulderLHeld:
manager.ZoomFont(0.9)
elif env == ENV_GP2X and event.type == pygame.JOYBUTTONUP:
if event.button == GP2X_BUTTON_L:
self.ShoulderLHeld = False
elif event.button == GP2X_BUTTON_R:
self.ShoulderRHeld = False
def shutdown(self):
# This will be called by the pykManager to shut down the thing
# immediately.
# If the caller gave us a callback, let them know we're finished
if self.State != STATE_CLOSED:
self.State = STATE_CLOSED
if self.SongFinishedCallback != None:
self.SongFinishedCallback()
def __defaultErrorPrint(self, ErrorString):
print (ErrorString)
def findPygameFont(self, fontData, fontSize):
""" Returns a pygame.Font selected by this data. """
if not fontData.size:
# The font names a specific filename.
filename = fontData.name
if os.path.sep not in filename:
filename = os.path.join(manager.FontPath, filename)
return pygame.font.Font(filename, fontSize)
# The font names a system font.
pointSize = int(fontData.size * fontSize / 10.0 + 0.5)
return pygame.font.SysFont(
fontData.name, pointSize, bold = fontData.bold,
italic = fontData.italic)
|
kelvinlawson/pykaraoke
|
pykplayer.py
|
Python
|
lgpl-2.1
| 16,454 | 0.003343 |
# The Hazard Library
# Copyright (C) 2015, GEM Foundation
#
# 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/>.
import os
import unittest
import collections
import mock
import h5py
import numpy as np
from scipy.interpolate import interp1d
from openquake.hazardlib import const
from openquake.hazardlib.gsim.gsim_table import (
SitesContext, RuptureContext, DistancesContext, GMPETable,
AmplificationTable, hdf_arrays_to_dict)
from openquake.hazardlib.tests.gsim.utils import BaseGSIMTestCase
from openquake.hazardlib import imt as imt_module
BASE_DATA_PATH = os.path.join(os.path.dirname(__file__),
"data",
"gsimtables")
def midpoint(low, high, point=0.5):
"""
Returns the logarithmic midpoint between two value
"""
return 10.0 ** (point * (np.log10(low) + np.log10(high)))
class HDFArraysToDictTestCase(unittest.TestCase):
"""
Tests the conversion of a group containing a set of datasets(array) into
a dictionary
"""
def setUp(self):
self.fle = h5py.File("foo.hdf5")
self.group = self.fle.create_group("TestGroup")
dset1 = self.group.create_dataset("DSET1", (3, 3), dtype="f")
dset1[:] = np.zeros([3, 3])
dset2 = self.group.create_dataset("DSET2", (3, 3), dtype="f")
dset2[:] = np.ones([3, 3])
def test_array_conversion(self):
"""
Tests the simple array conversion
"""
# Setup two
expected_dset1 = np.zeros([3, 3])
expected_dset2 = np.ones([3, 3])
output_dict = hdf_arrays_to_dict(self.group)
assert isinstance(output_dict, dict)
self.assertIn("DSET1", output_dict)
self.assertIn("DSET2", output_dict)
np.testing.assert_array_almost_equal(output_dict["DSET1"],
expected_dset1)
np.testing.assert_array_almost_equal(output_dict["DSET2"],
expected_dset2)
def tearDown(self):
"""
Close and delete the hdf5 file
"""
self.fle.close()
os.remove("foo.hdf5")
class AmplificationTableSiteTestCase(unittest.TestCase):
"""
Tests the amplification tables for a site parameter
"""
TABLE_FILE = os.path.join(BASE_DATA_PATH, "model_amplification_site.hdf5")
IDX = 0
def setUp(self):
"""
Open the hdf5 file
"""
self.fle = h5py.File(self.TABLE_FILE)
self.amp_table = AmplificationTable(self.fle["Amplification"],
self.fle["Mw"][:],
self.fle["Distances"][:])
def test_instantiation(self):
"""
Tests the setup and loading of data from file to memory
"""
# Check setup
# 1. Shape
self.assertTupleEqual(self.amp_table.shape, (10, 3, 5, 2))
# 2. Parameter
self.assertEqual(self.amp_table.parameter, "vs30")
# 3. Element
self.assertEqual(self.amp_table.element, "Sites")
# 4. Interpolation values
np.testing.assert_array_almost_equal(self.amp_table.values,
np.array([400.0, 1000.0]))
# 5. Periods
np.testing.assert_array_almost_equal(self.amp_table.periods,
np.array([0.1, 0.5, 1.0]))
# 6. Means and Standard Deviations
expected_mean, expected_sigma = self._build_mean_and_stddev_table()
for key in self.amp_table.mean:
np.testing.assert_array_almost_equal(self.amp_table.mean[key],
expected_mean[key])
np.testing.assert_array_almost_equal(
self.amp_table.sigma["Total"][key],
expected_sigma["Total"][key])
def _build_mean_and_stddev_table(self):
"""
Builds the expected mean and standard deviation tables
"""
expected_means = {
"PGA": np.ones([10, 1, 5, 2]),
"PGV": np.ones([10, 1, 5, 2]),
"SA": np.ones([10, 3, 5, 2])
}
# For second level revise values
expected_means["PGA"][:, :, :, self.IDX] *= 1.5
expected_means["PGV"][:, :, :, self.IDX] *= 0.5
expected_means["SA"][:, 0, :, self.IDX] *= 1.5
expected_means["SA"][:, 1, :, self.IDX] *= 2.0
expected_means["SA"][:, 2, :, self.IDX] *= 0.5
expected_sigma = {const.StdDev.TOTAL: {
"PGA": np.ones([10, 1, 5, 2]),
"PGV": np.ones([10, 1, 5, 2]),
"SA": np.ones([10, 3, 5, 2])
}}
expected_sigma[const.StdDev.TOTAL]["PGA"][:, :, :, self.IDX] *= 0.8
expected_sigma[const.StdDev.TOTAL]["PGV"][:, :, :, self.IDX] *= 0.8
expected_sigma[const.StdDev.TOTAL]["SA"][:, :, :, self.IDX] *= 0.8
return expected_means, expected_sigma
def test_get_set(self):
"""
Test that the set function operates correctly
"""
self.assertSetEqual(self.amp_table.get_set(), {"vs30"})
def test_get_mean_table(self, idx=0):
"""
Test the retrieval of the mean amplification tables for a given
magnitude and IMT
"""
rctx = RuptureContext()
rctx.mag = 6.0
# PGA
expected_table = np.ones([10, 2])
expected_table[:, self.IDX] *= 1.5
np.testing.assert_array_almost_equal(
self.amp_table.get_mean_table(imt_module.PGA(), rctx),
expected_table)
# SA
expected_table[:, self.IDX] = 2.0 * np.ones(10)
np.testing.assert_array_almost_equal(
self.amp_table.get_mean_table(imt_module.SA(0.5), rctx),
expected_table)
# SA (period interpolation)
interpolator = interp1d(np.log10(self.amp_table.periods),
np.log10(np.array([1.5, 2.0, 0.5])))
period = 0.3
expected_table[:, self.IDX] = (
10.0 ** interpolator(np.log10(period))) * np.ones(10.)
np.testing.assert_array_almost_equal(
self.amp_table.get_mean_table(imt_module.SA(period), rctx),
expected_table)
def test_get_sigma_table(self):
"""
Test the retrieval of the standard deviation modification tables
for a given magnitude and IMT
"""
rctx = RuptureContext()
rctx.mag = 6.0
# PGA
expected_table = np.ones([10, 2])
expected_table[:, self.IDX] *= 0.8
stddevs = ["Total"]
pga_table = self.amp_table.get_sigma_tables(imt_module.PGA(),
rctx,
stddevs)[0]
np.testing.assert_array_almost_equal(pga_table, expected_table)
# SA (for coverage)
sa_table = self.amp_table.get_sigma_tables(imt_module.SA(0.3),
rctx,
stddevs)[0]
np.testing.assert_array_almost_equal(sa_table, expected_table)
def test_get_amplification_factors(self):
"""
Tests the amplification tables
"""
rctx = RuptureContext()
rctx.mag = 6.0
dctx = DistancesContext()
# Takes distances at the values found in the table (not checking
# distance interpolation)
dctx.rjb = np.copy(self.amp_table.distances[:, 0, 0])
# Test Vs30 is 700.0 m/s midpoint between the 400 m/s and 1000 m/s
# specified in the table
sctx = SitesContext()
sctx.vs30 = 700.0 * np.ones_like(dctx.rjb)
stddevs = [const.StdDev.TOTAL]
expected_mean = np.ones_like(dctx.rjb)
expected_sigma = np.ones_like(dctx.rjb)
# Check PGA and PGV
mean_amp, sigma_amp = self.amp_table.get_amplification_factors(
imt_module.PGA(), sctx, rctx, dctx.rjb, stddevs)
np.testing.assert_array_almost_equal(
mean_amp,
midpoint(1.0, 1.5) * expected_mean)
np.testing.assert_array_almost_equal(
sigma_amp[0],
0.9 * expected_mean)
mean_amp, sigma_amp = self.amp_table.get_amplification_factors(
imt_module.PGV(), sctx, rctx, dctx.rjb, stddevs)
np.testing.assert_array_almost_equal(
mean_amp,
midpoint(1.0, 0.5) * expected_mean)
np.testing.assert_array_almost_equal(
sigma_amp[0],
0.9 * expected_mean)
# Sa (0.5)
mean_amp, sigma_amp = self.amp_table.get_amplification_factors(
imt_module.SA(0.5), sctx, rctx, dctx.rjb, stddevs)
np.testing.assert_array_almost_equal(
mean_amp,
midpoint(1.0, 2.0) * expected_mean)
np.testing.assert_array_almost_equal(
sigma_amp[0],
0.9 * expected_mean)
def tearDown(self):
"""
Close the hdf5 file
"""
self.fle.close()
class AmplificationTableRuptureTestCase(AmplificationTableSiteTestCase):
"""
Test case for the amplification table when applied to a rupture specific
parameter
"""
TABLE_FILE = os.path.join(BASE_DATA_PATH, "model_amplification_rake.hdf5")
IDX = 1
def test_instantiation(self):
"""
Tests the setup and loading of data from file to memory
"""
# Check setup
# 1. Shape
self.assertTupleEqual(self.amp_table.shape, (10, 3, 5, 2))
# 2. Parameter
self.assertEqual(self.amp_table.parameter, "rake")
# 3. Element
self.assertEqual(self.amp_table.element, "Rupture")
# 4. Interpolation values
np.testing.assert_array_almost_equal(self.amp_table.values,
np.array([0.0, 90.0]))
# 5. Periods
np.testing.assert_array_almost_equal(self.amp_table.periods,
np.array([0.1, 0.5, 1.0]))
# 6. Means and Standard Deviations
expected_mean, expected_sigma = self._build_mean_and_stddev_table()
for key in self.amp_table.mean:
np.testing.assert_array_almost_equal(self.amp_table.mean[key],
expected_mean[key])
np.testing.assert_array_almost_equal(
self.amp_table.sigma["Total"][key],
expected_sigma["Total"][key])
def test_get_amplification_factors(self):
"""
Tests the amplification tables
"""
rctx = RuptureContext()
rctx.rake = 45.0
rctx.mag = 6.0
dctx = DistancesContext()
# Takes distances at the values found in the table (not checking
# distance interpolation)
dctx.rjb = np.copy(self.amp_table.distances[:, 0, 0])
# Test Vs30 is 700.0 m/s midpoint between the 400 m/s and 1000 m/s
# specified in the table
sctx = SitesContext()
stddevs = [const.StdDev.TOTAL]
expected_mean = np.ones_like(dctx.rjb)
# Check PGA and PGV
mean_amp, sigma_amp = self.amp_table.get_amplification_factors(
imt_module.PGA(), sctx, rctx, dctx.rjb, stddevs)
np.testing.assert_array_almost_equal(
mean_amp,
midpoint(1.0, 1.5) * expected_mean)
np.testing.assert_array_almost_equal(
sigma_amp[0],
0.9 * expected_mean)
mean_amp, sigma_amp = self.amp_table.get_amplification_factors(
imt_module.PGV(), sctx, rctx, dctx.rjb, stddevs)
np.testing.assert_array_almost_equal(
mean_amp,
midpoint(1.0, 0.5) * expected_mean)
np.testing.assert_array_almost_equal(
sigma_amp[0],
0.9 * expected_mean)
# Sa (0.5)
mean_amp, sigma_amp = self.amp_table.get_amplification_factors(
imt_module.SA(0.5), sctx, rctx, dctx.rjb, stddevs)
np.testing.assert_array_almost_equal(
mean_amp,
midpoint(1.0, 2.0) * expected_mean)
np.testing.assert_array_almost_equal(
sigma_amp[0],
0.9 * expected_mean)
def test_get_set(self):
"""
Test that the set function operates correctly
"""
self.assertSetEqual(self.amp_table.get_set(), set(("rake",)))
class AmplificationTableBadTestCase(unittest.TestCase):
"""
Tests the instantiation of the amplification table if a non-supported
parameter is used
"""
TABLE_FILE = os.path.join(BASE_DATA_PATH, "bad_table_parameter.hdf5")
IDX = 0
def setUp(self):
"""
Open the hdf5 file
"""
self.fle = h5py.File(self.TABLE_FILE)
def test_unsupported_parameter(self):
"""
Tests instantiation with a bad input
"""
with self.assertRaises(ValueError) as ve:
AmplificationTable(self.fle["Amplification"], None, None)
self.assertEqual(str(ve.exception),
"Amplification parameter Bad Value not recognised!")
def tearDown(self):
"""
Close the file
"""
self.fle.close()
class GSIMTableGoodTestCase(unittest.TestCase):
"""
Verifies the correct execution of a GMPE Table
"""
TABLE_FILE = os.path.join(BASE_DATA_PATH, "good_dummy_table.hdf5")
def setUp(self):
"""
Opens the hdf5 file
"""
self.fle = h5py.File(self.TABLE_FILE)
def test_correct_instantiation(self):
"""
Verify that the data is loaded successfully
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
np.testing.assert_array_almost_equal(gsim.distances,
self.fle["Distances"][:])
np.testing.assert_array_almost_equal(gsim.m_w,
self.fle["Mw"][:])
self.assertEqual(gsim.distance_type, "rjb")
self.assertSetEqual(gsim.REQUIRES_SITES_PARAMETERS, set(("vs30",)))
self.assertSetEqual(gsim.REQUIRES_DISTANCES, set(("rjb",)))
self.assertSetEqual(
gsim.DEFINED_FOR_INTENSITY_MEASURE_TYPES,
set((imt_module.PGA, imt_module.PGV, imt_module.SA)))
self.assertSetEqual(gsim.DEFINED_FOR_STANDARD_DEVIATION_TYPES,
set((const.StdDev.TOTAL,)))
# Verify correctly parsed IMLs and standard deviations
for iml in ["PGA", "PGV", "SA", "T"]:
np.testing.assert_array_almost_equal(
gsim.imls[iml],
self.fle["IMLs/" + iml][:])
np.testing.assert_array_almost_equal(
gsim.stddevs["Total"][iml],
self.fle["Total/" + iml][:])
def test_instantiation_without_file(self):
"""
Tests the case when no GMPE table file is coded into the GMPE, nor
is any provided - should raise an error
"""
with self.assertRaises(IOError) as ioe:
GMPETable(gmpe_table=None)
self.assertEqual(str(ioe.exception),
"GMPE Table Not Defined!")
def test_retreival_tables_good_no_interp(self):
"""
Tests the retreival of the IML tables for 'good' conditions without
applying magnitude interpolations
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
# PGA
np.testing.assert_array_almost_equal(
gsim._return_tables(6.0, imt_module.PGA(), "IMLs"),
np.array([2., 1., 0.5]))
# PGV
np.testing.assert_array_almost_equal(
gsim._return_tables(6.0, imt_module.PGV(), "IMLs"),
np.array([20., 10., 5.]),
5)
# SA(1.0)
np.testing.assert_array_almost_equal(
gsim._return_tables(6.0, imt_module.SA(1.0), "IMLs"),
np.array([2.0, 1., 0.5]))
# Also for standard deviations
np.testing.assert_array_almost_equal(
gsim._return_tables(6.0, imt_module.PGA(), "Total"),
0.5 * np.ones(3))
np.testing.assert_array_almost_equal(
gsim._return_tables(6.0, imt_module.SA(1.0), "Total"),
0.8 * np.ones(3))
def test_retreival_tables_good_interp(self):
"""
Tests the retreival of the IML tables for 'good' conditions with
magnitude interpolations
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
expected_table_pgv = np.array([midpoint(20., 40.),
midpoint(10., 20.),
midpoint(5., 10.)])
np.testing.assert_array_almost_equal(
gsim._return_tables(6.5, imt_module.PGV(), "IMLs"),
expected_table_pgv,
5)
expected_table_sa1 = np.array([midpoint(2., 4.),
midpoint(1., 2.),
midpoint(0.5, 1.)])
np.testing.assert_array_almost_equal(
gsim._return_tables(6.5, imt_module.SA(1.0), "IMLs"),
expected_table_sa1)
def test_retreival_tables_outside_mag_range(self):
"""
Tests that an error is raised when inputting a magnitude value
outside the supported range
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
with self.assertRaises(ValueError) as ve:
gsim._return_tables(7.5, imt_module.PGA(), "IMLs")
self.assertEqual(
str(ve.exception),
"Magnitude 7.50 outside of supported range (5.00 to 7.00)")
def test_retreival_tables_outside_period_range(self):
"""
Tests that an error is raised when inputting a period value
outside the supported range
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
with self.assertRaises(ValueError) as ve:
gsim._return_tables(6.0, imt_module.SA(2.5), "IMLs")
self.assertEqual(
str(ve.exception),
"Spectral period 2.500 outside of valid range (0.100 to 2.000)")
def test_get_mean_and_stddevs_good(self):
"""
Tests the full execution of the GMPE tables for valid data
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
rctx = RuptureContext()
rctx.mag = 6.0
dctx = DistancesContext()
# Test values at the given distances and those outside range
dctx.rjb = np.array([0.5, 1.0, 10.0, 100.0, 500.0])
sctx = SitesContext()
sctx.vs30 = 1000. * np.ones(5)
stddevs = [const.StdDev.TOTAL]
expected_mean = np.array([2.0, 2.0, 1.0, 0.5, 1.0E-20])
expected_sigma = 0.25 * np.ones(5)
# PGA
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.PGA(),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean), expected_mean, 5)
np.testing.assert_array_almost_equal(sigma[0], expected_sigma, 5)
# SA
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.SA(1.0),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean), expected_mean, 5)
np.testing.assert_array_almost_equal(sigma[0], 0.4 * np.ones(5), 5)
# PGV
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.PGV(),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean),
10. * expected_mean,
5)
np.testing.assert_array_almost_equal(sigma[0], expected_sigma, 5)
def test_get_mean_and_stddevs_good_amplified(self):
"""
Tests the full execution of the GMPE tables for valid data with
amplification
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
rctx = RuptureContext()
rctx.mag = 6.0
dctx = DistancesContext()
# Test values at the given distances and those outside range
dctx.rjb = np.array([0.5, 1.0, 10.0, 100.0, 500.0])
sctx = SitesContext()
sctx.vs30 = 100. * np.ones(5)
stddevs = [const.StdDev.TOTAL]
expected_mean = np.array([20., 20., 10., 5., 1.0E-19])
expected_sigma = 0.25 * np.ones(5)
# PGA
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.PGA(),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean), expected_mean, 5)
np.testing.assert_array_almost_equal(sigma[0], expected_sigma, 5)
# SA
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.SA(1.0),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean), expected_mean, 5)
np.testing.assert_array_almost_equal(sigma[0], 0.4 * np.ones(5), 5)
def test_get_mean_stddevs_unsupported_stddev(self):
"""
Tests the execution of the GMPE with an unsupported standard deviation
type
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
rctx = RuptureContext()
rctx.mag = 6.0
dctx = DistancesContext()
# Test values at the given distances and those outside range
dctx.rjb = np.array([0.5, 1.0, 10.0, 100.0, 500.0])
sctx = SitesContext()
sctx.vs30 = 1000. * np.ones(5)
stddevs = [const.StdDev.TOTAL, const.StdDev.INTER_EVENT]
with self.assertRaises(ValueError) as ve:
gsim.get_mean_and_stddevs(sctx, rctx, dctx, imt_module.PGA(),
stddevs)
self.assertEqual(str(ve.exception),
"Standard Deviation type Inter event not supported")
def tearDown(self):
"""
Close the hdf5 file
"""
self.fle.close()
class GSIMTableTestCaseMultiStdDev(unittest.TestCase):
"""
Tests the instantiation of the GSIM table class in the case when
i. Multiple Standard Deviations are specified
ii. An unrecognised IMT is input
"""
TABLE_FILE = os.path.join(BASE_DATA_PATH,
"good_dummy_table_multi_stddev.hdf5")
def test_instantiation(self):
"""
Runs both instantiation checks
The table file contains data for Inter and intra event standard
deviation, as well as an IMT that is not recognised by OpenQuake
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
expected_stddev_set = set((const.StdDev.TOTAL,
const.StdDev.INTER_EVENT,
const.StdDev.INTRA_EVENT))
self.assertSetEqual(gsim.DEFINED_FOR_STANDARD_DEVIATION_TYPES,
expected_stddev_set)
expected_imt_set = set((imt_module.PGA,
imt_module.PGV,
imt_module.SA))
self.assertSetEqual(gsim.DEFINED_FOR_INTENSITY_MEASURE_TYPES,
expected_imt_set)
class GSIMTableTestCaseRupture(unittest.TestCase):
"""
Tests the case when the amplification is based on a rupture parameter
"""
TABLE_FILE = os.path.join(BASE_DATA_PATH,
"good_dummy_table_rake.hdf5")
def test_instantiation(self):
"""
Tests instantiation of class
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
expected_rupture_set = set(("mag", "rake"))
self.assertSetEqual(gsim.REQUIRES_RUPTURE_PARAMETERS,
expected_rupture_set)
self.assertEqual(gsim.amplification.parameter, "rake")
self.assertEqual(gsim.amplification.element, "Rupture")
self.assertSetEqual(gsim.REQUIRES_SITES_PARAMETERS, set(()))
def test_get_mean_and_stddevs_good(self):
"""
Tests the full execution of the GMPE tables for valid data
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
rctx = RuptureContext()
rctx.mag = 6.0
rctx.rake = 90.0
dctx = DistancesContext()
# Test values at the given distances and those outside range
dctx.rjb = np.array([0.5, 1.0, 10.0, 100.0, 500.0])
sctx = SitesContext()
stddevs = [const.StdDev.TOTAL]
expected_mean = np.array([20.0, 20.0, 10.0, 5.0, 1.0E-19])
# PGA
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.PGA(),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean), expected_mean, 5)
np.testing.assert_array_almost_equal(sigma[0], 0.25 * np.ones(5), 5)
# SA
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.SA(1.0),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean), expected_mean, 5)
np.testing.assert_array_almost_equal(sigma[0], 0.4 * np.ones(5), 5)
class GSIMTableTestCaseBadFile(unittest.TestCase):
"""
Tests the case when the hdf5 file contains spectral accelerations but
is missing the periods
"""
TABLE_FILE = os.path.join(BASE_DATA_PATH,
"missing_periods.hdf5")
def test_missing_periods(self):
"""
Tests missing period information
"""
with self.assertRaises(ValueError) as ve:
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
self.assertEqual(str(ve.exception),
"Spectral Acceleration must be accompanied by periods"
)
class GSIMTableTestCaseNoAmplification(unittest.TestCase):
"""
Tests the simple case in which no amplification is applied
"""
TABLE_FILE = os.path.join(BASE_DATA_PATH,
"good_dummy_table_noamp.hdf5")
def test_instantiation(self):
"""
Tests instantiation without amplification
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
self.assertIsNone(gsim.amplification)
self.assertSetEqual(gsim.REQUIRES_SITES_PARAMETERS, set(()))
self.assertSetEqual(gsim.REQUIRES_RUPTURE_PARAMETERS, set(("mag",)))
def test_get_mean_and_stddevs(self):
"""
Tests mean and standard deviations without amplification
"""
gsim = GMPETable(gmpe_table=self.TABLE_FILE)
rctx = RuptureContext()
rctx.mag = 6.0
dctx = DistancesContext()
# Test values at the given distances and those outside range
dctx.rjb = np.array([0.5, 1.0, 10.0, 100.0, 500.0])
sctx = SitesContext()
stddevs = [const.StdDev.TOTAL]
expected_mean = np.array([2.0, 2.0, 1.0, 0.5, 1.0E-20])
# PGA
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.PGA(),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean), expected_mean, 5)
np.testing.assert_array_almost_equal(sigma[0], 0.5 * np.ones(5), 5)
# SA
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.SA(1.0),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean), expected_mean, 5)
np.testing.assert_array_almost_equal(sigma[0], 0.8 * np.ones(5), 5)
# PGV
mean, sigma = gsim.get_mean_and_stddevs(sctx, rctx, dctx,
imt_module.PGV(),
stddevs)
np.testing.assert_array_almost_equal(np.exp(mean),
10. * expected_mean,
5)
np.testing.assert_array_almost_equal(sigma[0], 0.5 * np.ones(5), 5)
class GSIMTableQATestCase(BaseGSIMTestCase):
"""
Quality Assurance test case with real data taken from the
2015 Canadian National Seismic Hazard Map
"""
GSIM_CLASS = GMPETable
MEAN_FILE = "gsimtables/Wcrust_rjb_med_MEAN.csv"
STD_TOTAL_FILE = "gsimtables/Wcrust_rjb_med_TOTAL.csv"
def setUp(self):
self.GSIM_CLASS.GMPE_TABLE = os.path.join(BASE_DATA_PATH,
"Wcrust_rjb_med.hdf5")
def test_mean(self):
self.check(self.MEAN_FILE, max_discrep_percentage=0.7)
def test_std_total(self):
self.check(self.STD_TOTAL_FILE, max_discrep_percentage=0.7)
def tearDown(self):
self.GSIM_CLASS.GMPE_TABLE = None
|
g-weatherill/oq-hazardlib
|
openquake/hazardlib/tests/gsim/gsim_table_test.py
|
Python
|
agpl-3.0
| 29,750 | 0 |
from .chucky_neighborhood_tool import NeighborhoodTool
|
a0x77n/chucky-tools
|
src/chucky_tools/neighborhood/__init__.py
|
Python
|
gpl-3.0
| 55 | 0 |
#!/usr/bin/env python
# example setselection.py
import pygtk
pygtk.require('2.0')
import gtk
import time
class SetSelectionExample:
# Callback when the user toggles the selection
def selection_toggled(self, widget, window):
if widget.get_active():
self.have_selection = window.selection_owner_set("PRIMARY")
# if claiming the selection failed, we return the button to
# the out state
if not self.have_selection:
widget.set_active(False)
else:
if self.have_selection:
# Not possible to release the selection in PyGTK
# just mark that we don't have it
self.have_selection = False
return
# Called when another application claims the selection
def selection_clear(self, widget, event):
self.have_selection = False
widget.set_active(False)
return True
# Supplies the current time as the selection.
def selection_handle(self, widget, selection_data, info, time_stamp):
current_time = time.time()
timestr = time.asctime(time.localtime(current_time))
# When we return a single string, it should not be null terminated.
# That will be done for us
selection_data.set_text(timestr, len(timestr))
return
def __init__(self):
self.have_selection = False
# Create the toplevel window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_title("Set Selection")
window.set_border_width(10)
window.connect("destroy", lambda w: gtk.main_quit())
self.window = window
# Create an eventbox to hold the button since it no longer has
# a GdkWindow
eventbox = gtk.EventBox()
eventbox.show()
window.add(eventbox)
# Create a toggle button to act as the selection
selection_button = gtk.ToggleButton("Claim Selection")
eventbox.add(selection_button)
selection_button.connect("toggled", self.selection_toggled, eventbox)
eventbox.connect_object("selection_clear_event", self.selection_clear,
selection_button)
eventbox.selection_add_target("PRIMARY", "STRING", 1)
eventbox.selection_add_target("PRIMARY", "COMPOUND_TEXT", 1)
eventbox.connect("selection_get", self.selection_handle)
selection_button.show()
window.show()
def main():
gtk.main()
return 0
if __name__ == "__main__":
SetSelectionExample()
main()
|
certik/pyjamas
|
pygtkweb/demos/065-setselection.py
|
Python
|
apache-2.0
| 2,570 | 0.002335 |
import git
def download_repos(dst, repos):
"""
handles downloading paginated gists
Arguments
---------
dst : string
folder to write repositories to
repos : array-like of git.repo.base.Repo
repositories to download
"""
for repo in repos:
try:
# we can clone the projects, but we only want to download small projects
print("downloading repo {}/{}".format(repo.owner.login, repo.name))
git.repo.base.Repo.clone_from(repo.git_url, dst + '/' + repo.full_name)
except git.exc.GitCommandError as e:
# if the repositority already exists we want to move on
if not e.stderr.endswith('already exists and is not an empty directory.\n\''):
raise e
|
cameres/github-dl
|
download/download_repos.py
|
Python
|
mpl-2.0
| 779 | 0.003851 |
# -*- coding: utf-8 -*-
"""
===========
TaskCarrier
===========
:mod:`taskcarrier` contains a set of tools built on top of the `joblib`
library which allow to use transparently Parallel/Serial code using
simple but nice abstraction.
"""
__author__ = "Begon Jean-Michel <jm.begon@gmail.com>"
__copyright__ = "3-clause BSD License"
__version__ = '1.0'
__date__ = "26 Mar. 2015"
from .taskcarrier import (BoundedIterable, bound_iterable, Partition, Mapper,
SerialMapper, StaticParallelMapper,
DynamicParallelMapper, MapperInstance)
__all__ = ["BoundedIterable", "bound_iterable", "Partition", "Mapper",
"SerialMapper", "StaticParallelMapper", "DynamicParallelMapper",
"MapperInstance"]
|
jm-begon/taskcarrier
|
taskcarrier/__init__.py
|
Python
|
bsd-3-clause
| 764 | 0.001309 |
from __future__ import unicode_literals
import json
import xmltodict
from jinja2 import Template
from six import iteritems
from moto.core.responses import BaseResponse
from .models import redshift_backends
def convert_json_error_to_xml(json_error):
error = json.loads(json_error)
code = error["Error"]["Code"]
message = error["Error"]["Message"]
template = Template(
"""
<RedshiftClientError>
<Error>
<Code>{{ code }}</Code>
<Message>{{ message }}</Message>
<Type>Sender</Type>
</Error>
<RequestId>6876f774-7273-11e4-85dc-39e55ca848d1</RequestId>
</RedshiftClientError>"""
)
return template.render(code=code, message=message)
def itemize(data):
"""
The xmltodict.unparse requires we modify the shape of the input dictionary slightly. Instead of a dict of the form:
{'key': ['value1', 'value2']}
We must provide:
{'key': {'item': ['value1', 'value2']}}
"""
if isinstance(data, dict):
ret = {}
for key in data:
ret[key] = itemize(data[key])
return ret
elif isinstance(data, list):
return {"item": [itemize(value) for value in data]}
else:
return data
class RedshiftResponse(BaseResponse):
@property
def redshift_backend(self):
return redshift_backends[self.region]
def get_response(self, response):
if self.request_json:
return json.dumps(response)
else:
xml = xmltodict.unparse(itemize(response), full_document=False)
if hasattr(xml, "decode"):
xml = xml.decode("utf-8")
return xml
def call_action(self):
status, headers, body = super(RedshiftResponse, self).call_action()
if status >= 400 and not self.request_json:
body = convert_json_error_to_xml(body)
return status, headers, body
def unpack_complex_list_params(self, label, names):
unpacked_list = list()
count = 1
while self._get_param("{0}.{1}.{2}".format(label, count, names[0])):
param = dict()
for i in range(len(names)):
param[names[i]] = self._get_param(
"{0}.{1}.{2}".format(label, count, names[i])
)
unpacked_list.append(param)
count += 1
return unpacked_list
def unpack_list_params(self, label):
unpacked_list = list()
count = 1
while self._get_param("{0}.{1}".format(label, count)):
unpacked_list.append(self._get_param("{0}.{1}".format(label, count)))
count += 1
return unpacked_list
def _get_cluster_security_groups(self):
cluster_security_groups = self._get_multi_param("ClusterSecurityGroups.member")
if not cluster_security_groups:
cluster_security_groups = self._get_multi_param(
"ClusterSecurityGroups.ClusterSecurityGroupName"
)
return cluster_security_groups
def _get_vpc_security_group_ids(self):
vpc_security_group_ids = self._get_multi_param("VpcSecurityGroupIds.member")
if not vpc_security_group_ids:
vpc_security_group_ids = self._get_multi_param(
"VpcSecurityGroupIds.VpcSecurityGroupId"
)
return vpc_security_group_ids
def _get_iam_roles(self):
iam_roles = self._get_multi_param("IamRoles.member")
if not iam_roles:
iam_roles = self._get_multi_param("IamRoles.IamRoleArn")
return iam_roles
def _get_subnet_ids(self):
subnet_ids = self._get_multi_param("SubnetIds.member")
if not subnet_ids:
subnet_ids = self._get_multi_param("SubnetIds.SubnetIdentifier")
return subnet_ids
def create_cluster(self):
cluster_kwargs = {
"cluster_identifier": self._get_param("ClusterIdentifier"),
"node_type": self._get_param("NodeType"),
"master_username": self._get_param("MasterUsername"),
"master_user_password": self._get_param("MasterUserPassword"),
"db_name": self._get_param("DBName"),
"cluster_type": self._get_param("ClusterType"),
"cluster_security_groups": self._get_cluster_security_groups(),
"vpc_security_group_ids": self._get_vpc_security_group_ids(),
"cluster_subnet_group_name": self._get_param("ClusterSubnetGroupName"),
"availability_zone": self._get_param("AvailabilityZone"),
"preferred_maintenance_window": self._get_param(
"PreferredMaintenanceWindow"
),
"cluster_parameter_group_name": self._get_param(
"ClusterParameterGroupName"
),
"automated_snapshot_retention_period": self._get_int_param(
"AutomatedSnapshotRetentionPeriod"
),
"port": self._get_int_param("Port"),
"cluster_version": self._get_param("ClusterVersion"),
"allow_version_upgrade": self._get_bool_param("AllowVersionUpgrade"),
"number_of_nodes": self._get_int_param("NumberOfNodes"),
"publicly_accessible": self._get_param("PubliclyAccessible"),
"encrypted": self._get_param("Encrypted"),
"region_name": self.region,
"tags": self.unpack_complex_list_params("Tags.Tag", ("Key", "Value")),
"iam_roles_arn": self._get_iam_roles(),
"enhanced_vpc_routing": self._get_param("EnhancedVpcRouting"),
"kms_key_id": self._get_param("KmsKeyId"),
}
cluster = self.redshift_backend.create_cluster(**cluster_kwargs).to_json()
cluster["ClusterStatus"] = "creating"
return self.get_response(
{
"CreateClusterResponse": {
"CreateClusterResult": {"Cluster": cluster},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def restore_from_cluster_snapshot(self):
enhanced_vpc_routing = self._get_bool_param("EnhancedVpcRouting")
restore_kwargs = {
"snapshot_identifier": self._get_param("SnapshotIdentifier"),
"cluster_identifier": self._get_param("ClusterIdentifier"),
"port": self._get_int_param("Port"),
"availability_zone": self._get_param("AvailabilityZone"),
"allow_version_upgrade": self._get_bool_param("AllowVersionUpgrade"),
"cluster_subnet_group_name": self._get_param("ClusterSubnetGroupName"),
"publicly_accessible": self._get_param("PubliclyAccessible"),
"cluster_parameter_group_name": self._get_param(
"ClusterParameterGroupName"
),
"cluster_security_groups": self._get_cluster_security_groups(),
"vpc_security_group_ids": self._get_vpc_security_group_ids(),
"preferred_maintenance_window": self._get_param(
"PreferredMaintenanceWindow"
),
"automated_snapshot_retention_period": self._get_int_param(
"AutomatedSnapshotRetentionPeriod"
),
"region_name": self.region,
"iam_roles_arn": self._get_iam_roles(),
}
if enhanced_vpc_routing is not None:
restore_kwargs["enhanced_vpc_routing"] = enhanced_vpc_routing
cluster = self.redshift_backend.restore_from_cluster_snapshot(
**restore_kwargs
).to_json()
cluster["ClusterStatus"] = "creating"
return self.get_response(
{
"RestoreFromClusterSnapshotResponse": {
"RestoreFromClusterSnapshotResult": {"Cluster": cluster},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def describe_clusters(self):
cluster_identifier = self._get_param("ClusterIdentifier")
clusters = self.redshift_backend.describe_clusters(cluster_identifier)
return self.get_response(
{
"DescribeClustersResponse": {
"DescribeClustersResult": {
"Clusters": [cluster.to_json() for cluster in clusters]
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def modify_cluster(self):
request_kwargs = {
"cluster_identifier": self._get_param("ClusterIdentifier"),
"new_cluster_identifier": self._get_param("NewClusterIdentifier"),
"node_type": self._get_param("NodeType"),
"master_user_password": self._get_param("MasterUserPassword"),
"cluster_type": self._get_param("ClusterType"),
"cluster_security_groups": self._get_cluster_security_groups(),
"vpc_security_group_ids": self._get_vpc_security_group_ids(),
"cluster_subnet_group_name": self._get_param("ClusterSubnetGroupName"),
"preferred_maintenance_window": self._get_param(
"PreferredMaintenanceWindow"
),
"cluster_parameter_group_name": self._get_param(
"ClusterParameterGroupName"
),
"automated_snapshot_retention_period": self._get_int_param(
"AutomatedSnapshotRetentionPeriod"
),
"cluster_version": self._get_param("ClusterVersion"),
"allow_version_upgrade": self._get_bool_param("AllowVersionUpgrade"),
"number_of_nodes": self._get_int_param("NumberOfNodes"),
"publicly_accessible": self._get_param("PubliclyAccessible"),
"encrypted": self._get_param("Encrypted"),
"iam_roles_arn": self._get_iam_roles(),
"enhanced_vpc_routing": self._get_param("EnhancedVpcRouting"),
}
cluster_kwargs = {}
# We only want parameters that were actually passed in, otherwise
# we'll stomp all over our cluster metadata with None values.
for (key, value) in iteritems(request_kwargs):
if value is not None and value != []:
cluster_kwargs[key] = value
cluster = self.redshift_backend.modify_cluster(**cluster_kwargs)
return self.get_response(
{
"ModifyClusterResponse": {
"ModifyClusterResult": {"Cluster": cluster.to_json()},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def delete_cluster(self):
request_kwargs = {
"cluster_identifier": self._get_param("ClusterIdentifier"),
"final_cluster_snapshot_identifier": self._get_param(
"FinalClusterSnapshotIdentifier"
),
"skip_final_snapshot": self._get_bool_param("SkipFinalClusterSnapshot"),
}
cluster = self.redshift_backend.delete_cluster(**request_kwargs)
return self.get_response(
{
"DeleteClusterResponse": {
"DeleteClusterResult": {"Cluster": cluster.to_json()},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def create_cluster_subnet_group(self):
cluster_subnet_group_name = self._get_param("ClusterSubnetGroupName")
description = self._get_param("Description")
subnet_ids = self._get_subnet_ids()
tags = self.unpack_complex_list_params("Tags.Tag", ("Key", "Value"))
subnet_group = self.redshift_backend.create_cluster_subnet_group(
cluster_subnet_group_name=cluster_subnet_group_name,
description=description,
subnet_ids=subnet_ids,
region_name=self.region,
tags=tags,
)
return self.get_response(
{
"CreateClusterSubnetGroupResponse": {
"CreateClusterSubnetGroupResult": {
"ClusterSubnetGroup": subnet_group.to_json()
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def describe_cluster_subnet_groups(self):
subnet_identifier = self._get_param("ClusterSubnetGroupName")
subnet_groups = self.redshift_backend.describe_cluster_subnet_groups(
subnet_identifier
)
return self.get_response(
{
"DescribeClusterSubnetGroupsResponse": {
"DescribeClusterSubnetGroupsResult": {
"ClusterSubnetGroups": [
subnet_group.to_json() for subnet_group in subnet_groups
]
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def delete_cluster_subnet_group(self):
subnet_identifier = self._get_param("ClusterSubnetGroupName")
self.redshift_backend.delete_cluster_subnet_group(subnet_identifier)
return self.get_response(
{
"DeleteClusterSubnetGroupResponse": {
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
}
}
}
)
def create_cluster_security_group(self):
cluster_security_group_name = self._get_param("ClusterSecurityGroupName")
description = self._get_param("Description")
tags = self.unpack_complex_list_params("Tags.Tag", ("Key", "Value"))
security_group = self.redshift_backend.create_cluster_security_group(
cluster_security_group_name=cluster_security_group_name,
description=description,
region_name=self.region,
tags=tags,
)
return self.get_response(
{
"CreateClusterSecurityGroupResponse": {
"CreateClusterSecurityGroupResult": {
"ClusterSecurityGroup": security_group.to_json()
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def describe_cluster_security_groups(self):
cluster_security_group_name = self._get_param("ClusterSecurityGroupName")
security_groups = self.redshift_backend.describe_cluster_security_groups(
cluster_security_group_name
)
return self.get_response(
{
"DescribeClusterSecurityGroupsResponse": {
"DescribeClusterSecurityGroupsResult": {
"ClusterSecurityGroups": [
security_group.to_json()
for security_group in security_groups
]
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def delete_cluster_security_group(self):
security_group_identifier = self._get_param("ClusterSecurityGroupName")
self.redshift_backend.delete_cluster_security_group(security_group_identifier)
return self.get_response(
{
"DeleteClusterSecurityGroupResponse": {
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
}
}
}
)
def authorize_cluster_security_group_ingress(self):
cluster_security_group_name = self._get_param("ClusterSecurityGroupName")
cidr_ip = self._get_param("CIDRIP")
security_group = self.redshift_backend.authorize_cluster_security_group_ingress(
cluster_security_group_name, cidr_ip
)
return self.get_response(
{
"AuthorizeClusterSecurityGroupIngressResponse": {
"AuthorizeClusterSecurityGroupIngressResult": {
"ClusterSecurityGroup": {
"ClusterSecurityGroupName": cluster_security_group_name,
"Description": security_group.description,
"IPRanges": [
{
"Status": "authorized",
"CIDRIP": cidr_ip,
"Tags": security_group.tags,
},
],
}
}
}
}
)
def create_cluster_parameter_group(self):
cluster_parameter_group_name = self._get_param("ParameterGroupName")
group_family = self._get_param("ParameterGroupFamily")
description = self._get_param("Description")
tags = self.unpack_complex_list_params("Tags.Tag", ("Key", "Value"))
parameter_group = self.redshift_backend.create_cluster_parameter_group(
cluster_parameter_group_name, group_family, description, self.region, tags
)
return self.get_response(
{
"CreateClusterParameterGroupResponse": {
"CreateClusterParameterGroupResult": {
"ClusterParameterGroup": parameter_group.to_json()
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def describe_cluster_parameter_groups(self):
cluster_parameter_group_name = self._get_param("ParameterGroupName")
parameter_groups = self.redshift_backend.describe_cluster_parameter_groups(
cluster_parameter_group_name
)
return self.get_response(
{
"DescribeClusterParameterGroupsResponse": {
"DescribeClusterParameterGroupsResult": {
"ParameterGroups": [
parameter_group.to_json()
for parameter_group in parameter_groups
]
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def delete_cluster_parameter_group(self):
cluster_parameter_group_name = self._get_param("ParameterGroupName")
self.redshift_backend.delete_cluster_parameter_group(
cluster_parameter_group_name
)
return self.get_response(
{
"DeleteClusterParameterGroupResponse": {
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
}
}
}
)
def create_cluster_snapshot(self):
cluster_identifier = self._get_param("ClusterIdentifier")
snapshot_identifier = self._get_param("SnapshotIdentifier")
tags = self.unpack_complex_list_params("Tags.Tag", ("Key", "Value"))
snapshot = self.redshift_backend.create_cluster_snapshot(
cluster_identifier, snapshot_identifier, self.region, tags
)
return self.get_response(
{
"CreateClusterSnapshotResponse": {
"CreateClusterSnapshotResult": {"Snapshot": snapshot.to_json()},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def describe_cluster_snapshots(self):
cluster_identifier = self._get_param("ClusterIdentifier")
snapshot_identifier = self._get_param("SnapshotIdentifier")
snapshots = self.redshift_backend.describe_cluster_snapshots(
cluster_identifier, snapshot_identifier
)
return self.get_response(
{
"DescribeClusterSnapshotsResponse": {
"DescribeClusterSnapshotsResult": {
"Snapshots": [snapshot.to_json() for snapshot in snapshots]
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def delete_cluster_snapshot(self):
snapshot_identifier = self._get_param("SnapshotIdentifier")
snapshot = self.redshift_backend.delete_cluster_snapshot(snapshot_identifier)
return self.get_response(
{
"DeleteClusterSnapshotResponse": {
"DeleteClusterSnapshotResult": {"Snapshot": snapshot.to_json()},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def create_snapshot_copy_grant(self):
copy_grant_kwargs = {
"snapshot_copy_grant_name": self._get_param("SnapshotCopyGrantName"),
"kms_key_id": self._get_param("KmsKeyId"),
"region_name": self._get_param("Region"),
}
copy_grant = self.redshift_backend.create_snapshot_copy_grant(
**copy_grant_kwargs
)
return self.get_response(
{
"CreateSnapshotCopyGrantResponse": {
"CreateSnapshotCopyGrantResult": {
"SnapshotCopyGrant": copy_grant.to_json()
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def delete_snapshot_copy_grant(self):
copy_grant_kwargs = {
"snapshot_copy_grant_name": self._get_param("SnapshotCopyGrantName")
}
self.redshift_backend.delete_snapshot_copy_grant(**copy_grant_kwargs)
return self.get_response(
{
"DeleteSnapshotCopyGrantResponse": {
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
}
}
}
)
def describe_snapshot_copy_grants(self):
copy_grant_kwargs = {
"snapshot_copy_grant_name": self._get_param("SnapshotCopyGrantName")
}
copy_grants = self.redshift_backend.describe_snapshot_copy_grants(
**copy_grant_kwargs
)
return self.get_response(
{
"DescribeSnapshotCopyGrantsResponse": {
"DescribeSnapshotCopyGrantsResult": {
"SnapshotCopyGrants": [
copy_grant.to_json() for copy_grant in copy_grants
]
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def create_tags(self):
resource_name = self._get_param("ResourceName")
tags = self.unpack_complex_list_params("Tags.Tag", ("Key", "Value"))
self.redshift_backend.create_tags(resource_name, tags)
return self.get_response(
{
"CreateTagsResponse": {
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
}
}
}
)
def describe_tags(self):
resource_name = self._get_param("ResourceName")
resource_type = self._get_param("ResourceType")
tagged_resources = self.redshift_backend.describe_tags(
resource_name, resource_type
)
return self.get_response(
{
"DescribeTagsResponse": {
"DescribeTagsResult": {"TaggedResources": tagged_resources},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def delete_tags(self):
resource_name = self._get_param("ResourceName")
tag_keys = self.unpack_list_params("TagKeys.TagKey")
self.redshift_backend.delete_tags(resource_name, tag_keys)
return self.get_response(
{
"DeleteTagsResponse": {
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
}
}
}
)
def enable_snapshot_copy(self):
snapshot_copy_kwargs = {
"cluster_identifier": self._get_param("ClusterIdentifier"),
"destination_region": self._get_param("DestinationRegion"),
"retention_period": self._get_param("RetentionPeriod", 7),
"snapshot_copy_grant_name": self._get_param("SnapshotCopyGrantName"),
}
cluster = self.redshift_backend.enable_snapshot_copy(**snapshot_copy_kwargs)
return self.get_response(
{
"EnableSnapshotCopyResponse": {
"EnableSnapshotCopyResult": {"Cluster": cluster.to_json()},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def disable_snapshot_copy(self):
snapshot_copy_kwargs = {
"cluster_identifier": self._get_param("ClusterIdentifier")
}
cluster = self.redshift_backend.disable_snapshot_copy(**snapshot_copy_kwargs)
return self.get_response(
{
"DisableSnapshotCopyResponse": {
"DisableSnapshotCopyResult": {"Cluster": cluster.to_json()},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def modify_snapshot_copy_retention_period(self):
snapshot_copy_kwargs = {
"cluster_identifier": self._get_param("ClusterIdentifier"),
"retention_period": self._get_param("RetentionPeriod"),
}
cluster = self.redshift_backend.modify_snapshot_copy_retention_period(
**snapshot_copy_kwargs
)
return self.get_response(
{
"ModifySnapshotCopyRetentionPeriodResponse": {
"ModifySnapshotCopyRetentionPeriodResult": {
"Clusters": [cluster.to_json()]
},
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
def get_cluster_credentials(self):
cluster_identifier = self._get_param("ClusterIdentifier")
db_user = self._get_param("DbUser")
auto_create = self._get_bool_param("AutoCreate", False)
duration_seconds = self._get_int_param("DurationSeconds", 900)
cluster_credentials = self.redshift_backend.get_cluster_credentials(
cluster_identifier, db_user, auto_create, duration_seconds
)
return self.get_response(
{
"GetClusterCredentialsResponse": {
"GetClusterCredentialsResult": cluster_credentials,
"ResponseMetadata": {
"RequestId": "384ac68d-3775-11df-8963-01868b7c937a"
},
}
}
)
|
william-richard/moto
|
moto/redshift/responses.py
|
Python
|
apache-2.0
| 28,522 | 0.001227 |
"""
XmlObject
This module allows concise definitions of XML file formats for python
objects.
"""
#
# KeepNote
# Copyright (c) 2008-2009 Matt Rasmussen
# Author: Matt Rasmussen <rasmus@alum.mit.edu>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
#
# python imports
import sys
import codecs
# xml imports
import xml.parsers.expat
from xml.sax.saxutils import escape
# keepnote imports
from keepnote import safefile
class XmlError (StandardError):
"""Error for parsing XML"""
pass
def bool2str(b):
"""Convert a bool into a string"""
return str(int(b))
def str2bool(s):
"""Convert a string into a bool"""
return bool(int(s))
def str_no_none(x):
if x is None:
return u""
return x
class Tag (object):
def __init__(self, name,
get=None,
set=None,
attr=None,
tags=[]):
self.name = name
self._tag_list = list(tags)
self._read_data = get
self._write_data = set
self._object = None
self._data = []
# set read/write based on 'attr'
if attr is not None:
attr_name, attr_get, attr_set = attr
if attr_get is None:
self._read_data = lambda s,x: s.__setattr__(attr_name, x)
else:
self._read_data = lambda s,x: s.__setattr__(attr_name, attr_get(x))
if attr_set is None:
self._write_data = lambda s: str_no_none(s.__dict__[attr_name])
else:
self._write_data = lambda s: attr_set(s.__dict__[attr_name])
# init tag lookup
self._tags = {}
for tag in tags:
self._tags[tag.name] = tag
# set of initialized tags
self._init_tags = __builtins__["set"]()
#===========================================
# reading
def init(self):
"""Initialize the a tag before its first use"""
self._init_tags.clear()
def set_object(self, obj):
self._object = obj
def new_tag(self, name):
"""Create new child tag"""
tag = self._tags.get(name, None)
if tag:
# initialize new tag
tag.set_object(self._object)
if tag not in self._init_tags:
tag.init()
self._init_tags.add(tag)
return tag
def start_tag(self):
"""Start tag callback"""
self._data = []
def queue_data(self, data):
"""Content data callback"""
if self._read_data:
self._data.append(data)
def end_tag(self):
"""End tag callback"""
# read queued data if read function is supplied
if self._read_data:
data = "".join(self._data)
self._data = []
try:
self._read_data(self._object, data)
except Exception, e:
raise XmlError("Error parsing tag '%s': %s" % (self.name,
str(e)))
def add(self, tag):
"""Add a tag child to this tag"""
self._tag_list.append(tag)
self._tags[tag.name] = tag
#===================
# writing
def write(self, obj, out):
"""Write tag to output stream"""
# write openning
if self.name != "":
out.write("<%s>" % self.name)
if len(self._tags) > 0:
out.write("\n")
for child_tag in self._tag_list:
child_tag.write(obj, out)
elif self._write_data:
text = self._write_data(obj)
if not isinstance(text, basestring):
raise XmlError("bad text (%s,%s): %s" %
(self.name, str(self._object),
str(type(text))))
out.write(escape(text))
if self.name != "":
out.write("</%s>\n" % self.name)
# TODO: remove get?
class TagMany (Tag):
def __init__(self, name, iterfunc, get=None, set=None,
before=None,
after=None,
tags=[]):
Tag.__init__(self, name,
get=None,
set=set,
tags=tags)
self._iterfunc = iterfunc
self._read_item = get
self._write_item = set
self._beforefunc = before
self._afterfunc = after
self._index = 0
#=============================
# reading
def init(self):
"""Initialize the a tag before its first use"""
self._init_tags.clear()
self._index = 0
def new_tag(self, name):
"""Create new child tag"""
tag = self._tags.get(name, None)
if tag:
# initialize new tag
tag.set_object((self._object, self._index))
if tag not in self._init_tags:
tag.init()
self._init_tags.add(tag)
return tag
def start_tag(self):
"""Start tag callback"""
self._data = []
if self._beforefunc:
self._beforefunc((self._object, self._index))
def queue_data(self, data):
"""Content data callback"""
if self._read_item:
self._data.append(data)
def end_tag(self):
"""End tag callback"""
if self._read_item:
data = "".join(self._data)
self._data = []
#try:
if 1:
if self._read_item is not None:
self._read_item((self._object, self._index), data)
#except Exception, e:
# raise XmlError("Error parsing tag '%s': %s" % (self.name,
# str(e)))
if self._afterfunc:
self._afterfunc((self._object, self._index))
self._index += 1
#=====================
# writing
def write(self, obj, out):
# write opening
if len(self._tags) == 0:
assert self._write_item is not None
for i in self._iterfunc(obj):
out.write("<%s>%s</%s>\n" % (self.name,
escape(self._write_item((obj, i))),
self.name))
else:
for i in self._iterfunc(obj):
out.write("<%s>\n" % self.name)
for child_tag in self._tag_list:
child_tag.write((obj, i), out)
out.write("</%s>\n" % self.name)
'''
# TODO: remove get?
class TagList (TagMany):
"""A specialization of TagMany to work with reading and writing lists"""
def __init__(self, name, lst, get=None, set=None, before=None, after=None,
tags=[]):
TagMany.__init__(self, name, self._iter,
get=get, set=set,
before=before, after=after, tags=tags)
self._list = lst
def new_tag(self, name):
tag = self._tags.get(name, None)
if tag:
tag.set_object(self._list)
return tag
'''
class XmlObject (object):
"""Represents an object <--> XML document binding"""
def __init__(self, *tags):
self._object = None
self._root_tag = Tag("", tags=tags)
self._current_tags = [self._root_tag]
def __start_element(self, name, attrs):
"""Start tag callback"""
if len(self._current_tags) > 0:
last_tag = self._current_tags[-1]
if last_tag:
new_tag = last_tag.new_tag(name)
self._current_tags.append(new_tag)
if new_tag:
new_tag.start_tag()
def __end_element(self, name):
"""End tag callback"""
if len(self._current_tags) > 0:
last_tag = self._current_tags.pop()
if last_tag:
if last_tag.name == name:
last_tag.end_tag()
else:
raise XmlError("Malformed XML")
def __char_data(self, data):
"""read character data and give it to current tag"""
if len(self._current_tags) > 0:
tag = self._current_tags[-1]
if tag:
tag.queue_data(data)
def read(self, obj, filename):
"""Read XML from 'filename' and store data into object 'obj'"""
if isinstance(filename, basestring):
infile = open(filename, "r")
else:
infile = filename
self._object = obj
self._root_tag.set_object(self._object)
self._current_tags = [self._root_tag]
self._root_tag.init()
parser = xml.parsers.expat.ParserCreate()
parser.StartElementHandler = self.__start_element
parser.EndElementHandler = self.__end_element
parser.CharacterDataHandler = self.__char_data
try:
parser.ParseFile(infile)
except xml.parsers.expat.ExpatError, e:
raise XmlError("Error reading file '%s': %s" % (filename, str(e)))
if len(self._current_tags) > 1:
print [x.name for x in self._current_tags]
raise XmlError("Incomplete file '%s'" % filename)
infile.close()
def write(self, obj, filename):
"""Write object 'obj' to file 'filename'"""
if isinstance(filename, basestring):
#out = codecs.open(filename, "w", "utf-8")
out = safefile.open(filename, "w", codec="utf-8")
need_close = True
else:
out = filename
need_close = False
out.write(u"<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
self._root_tag.write(obj, out)
out.write(u"\n")
if need_close:
out.close()
if __name__ == "__main__":
import StringIO
parser = XmlObject(
Tag("notebook", tags=[
Tag("window_size",
attr=("window_size",
lambda x: tuple(map(int, x.split(","))),
lambda x: "%d,%d" % x)),
Tag("window_pos",
attr=("window_pos",
lambda x: tuple(map(int, x.split(","))),
lambda x: "%d,%d" % x)),
Tag("vsash_pos",
attr=("vhash_pos", int, str)),
Tag("hsash_pos",
attr=("hsash_pos", int, str)),
Tag("external_apps", tags=[
TagMany("app",
iterfunc=lambda s: range(len(s.apps)),
get=lambda (s,i), x: s.apps.append(x),
set=lambda (s,i): s.apps[i])]),
Tag("external_apps2", tags=[
TagMany("app",
iterfunc=lambda s: range(len(s.apps2)),
before=lambda (s,i): s.apps2.append([None, None]),
tags=[Tag("name",
get=lambda (s,i),x: s.apps2[i].__setitem__(0, x),
set=lambda (s,i): s.apps2[i][0]),
Tag("prog",
get=lambda (s,i),x: s.apps2[i].__setitem__(1,x),
set=lambda (s,i): s.apps2[i][1])
])
]),
]))
class Pref (object):
def __init__(self):
self.window_size = (0, 0)
self.window_pos = (0, 0)
self.vsash_pos = 0
self.hsash_pos = 0
self.apps = []
self.apps2 = []
def read(self, filename):
parser.read(self, filename)
def write(self, filename):
parser.write(self, filename)
#from rasmus import util
#util.tic("run")
infile = StringIO.StringIO("""<?xml version="1.0" encoding="UTF-8"?>
<notebook>
<window_size>1053,905</window_size>
<window_pos>0,0</window_pos>
<vsash_pos>0</vsash_pos>
<hsash_pos>250</hsash_pos>
<external_apps>
<app>web_browser</app>
<app>image_editor</app>
</external_apps>
<external_apps2>
<app><name>web_browser</name><prog>firefox</prog></app>
<app><name>image_editor</name><prog>gimp</prog></app>
</external_apps2>
</notebook>
""")
for i in xrange(1):#0000):
pref = Pref()
pref.read(infile)
pref.write(sys.stdout)
#util.toc()
'''
def get_dom_children(node):
"""Convenience function for iterating the children of a DOM object"""
child = node.firstChild
while child:
yield child
child = child.nextSibling
'''
|
brotchie/keepnote
|
keepnote/compat/xmlobject_v3.py
|
Python
|
gpl-2.0
| 13,706 | 0.008172 |
"""
Admonition extension for Python-Markdown
========================================
Adds rST-style admonitions. Inspired by [rST][] feature with the same name.
[rST]: http://docutils.sourceforge.net/docs/ref/rst/directives.html#specific-admonitions # noqa
See <https://Python-Markdown.github.io/extensions/admonition>
for documentation.
Original code Copyright [Tiago Serafim](http://www.tiagoserafim.com/).
All changes Copyright The Python Markdown Project
License: [BSD](http://www.opensource.org/licenses/bsd-license.php)
"""
from __future__ import absolute_import
from __future__ import unicode_literals
from . import Extension
from ..blockprocessors import BlockProcessor
from ..util import etree
import re
class AdmonitionExtension(Extension):
""" Admonition extension for Python-Markdown. """
def extendMarkdown(self, md):
""" Add Admonition to Markdown instance. """
md.registerExtension(self)
md.parser.blockprocessors.register(AdmonitionProcessor(md.parser), 'admonition', 105)
class AdmonitionProcessor(BlockProcessor):
CLASSNAME = 'admonition'
CLASSNAME_TITLE = 'admonition-title'
RE = re.compile(r'(?:^|\n)!!! ?([\w\-]+(?: +[\w\-]+)*)(?: +"(.*?)")? *(?:\n|$)')
RE_SPACES = re.compile(' +')
def test(self, parent, block):
sibling = self.lastChild(parent)
return self.RE.search(block) or \
(block.startswith(' ' * self.tab_length) and sibling is not None and
sibling.get('class', '').find(self.CLASSNAME) != -1)
def run(self, parent, blocks):
sibling = self.lastChild(parent)
block = blocks.pop(0)
m = self.RE.search(block)
if m:
block = block[m.end():] # removes the first line
block, theRest = self.detab(block)
if m:
klass, title = self.get_class_and_title(m)
div = etree.SubElement(parent, 'div')
div.set('class', '%s %s' % (self.CLASSNAME, klass))
if title:
p = etree.SubElement(div, 'p')
p.text = title
p.set('class', self.CLASSNAME_TITLE)
else:
div = sibling
self.parser.parseChunk(div, block)
if theRest:
# This block contained unindented line(s) after the first indented
# line. Insert these lines as the first block of the master blocks
# list for future processing.
blocks.insert(0, theRest)
def get_class_and_title(self, match):
klass, title = match.group(1).lower(), match.group(2)
klass = self.RE_SPACES.sub(' ', klass)
if title is None:
# no title was provided, use the capitalized classname as title
# e.g.: `!!! note` will render
# `<p class="admonition-title">Note</p>`
title = klass.split(' ', 1)[0].capitalize()
elif title == '':
# an explicit blank title should not be rendered
# e.g.: `!!! warning ""` will *not* render `p` with a title
title = None
return klass, title
def makeExtension(**kwargs): # pragma: no cover
return AdmonitionExtension(**kwargs)
|
unreal666/outwiker
|
plugins/markdown/markdown/markdown_plugin_libs/markdown/extensions/admonition.py
|
Python
|
gpl-3.0
| 3,188 | 0.000941 |
from __future__ import unicode_literals
from datetime import date
from django.test import TestCase
from import_export import fields
class Obj:
def __init__(self, name, date=None):
self.name = name
self.date = date
class FieldTest(TestCase):
def setUp(self):
self.field = fields.Field(column_name='name', attribute='name')
self.row = {
'name': 'Foo',
}
self.obj = Obj(name='Foo', date=date(2012, 8, 13))
def test_clean(self):
self.assertEqual(self.field.clean(self.row),
self.row['name'])
def test_export(self):
self.assertEqual(self.field.export(self.obj),
self.row['name'])
def test_save(self):
self.row['name'] = 'foo'
self.field.save(self.obj, self.row)
self.assertEqual(self.obj.name, 'foo')
def test_save_follow(self):
class Test:
class name:
class follow:
me = 'bar'
test = Test()
field = fields.Field(column_name='name', attribute='name__follow__me')
row = {'name': 'foo'}
field.save(test, row)
self.assertEqual(test.name.follow.me, 'foo')
def test_following_attribute(self):
field = fields.Field(attribute='other_obj__name')
obj2 = Obj(name="bar")
self.obj.other_obj = obj2
self.assertEqual(field.export(self.obj), "bar")
def test_default(self):
field = fields.Field(default=1, column_name='name')
self.assertEqual(field.clean({'name': None}), 1)
def test_default_falsy_values(self):
field = fields.Field(default=1, column_name='name')
self.assertEqual(field.clean({'name': 0}), 0)
def test_default_falsy_values_without_default(self):
field = fields.Field(column_name='name')
self.assertEqual(field.clean({'name': 0}), 0)
def test_saves_null_values(self):
field = fields.Field(column_name='name', attribute='name', saves_null_values=False)
row = {
'name': None,
}
field.save(self.obj, row)
self.assertEqual(self.obj.name, 'Foo')
self.field.save(self.obj, row)
self.assertIsNone(self.obj.name)
|
daniell/django-import-export
|
tests/core/tests/test_fields.py
|
Python
|
bsd-2-clause
| 2,262 | 0.000442 |
## Automatically adapted for scipy Oct 21, 2005 by
"""
Integration routines
====================
Methods for Integrating Functions given function object.
quad -- General purpose integration.
dblquad -- General purpose double integration.
tplquad -- General purpose triple integration.
fixed_quad -- Integrate func(x) using Gaussian quadrature of order n.
quadrature -- Integrate with given tolerance using Gaussian quadrature.
romberg -- Integrate func using Romberg integration.
Methods for Integrating Functions given fixed samples.
trapz -- Use trapezoidal rule to compute integral from samples.
cumtrapz -- Use trapezoidal rule to cumulatively compute integral.
simps -- Use Simpson's rule to compute integral from samples.
romb -- Use Romberg Integration to compute integral from
(2**k + 1) evenly-spaced samples.
See the special module's orthogonal polynomials (special) for Gaussian
quadrature roots and weights for other weighting factors and regions.
Interface to numerical integrators of ODE systems.
odeint -- General integration of ordinary differential equations.
ode -- Integrate ODE using VODE and ZVODE routines.
"""
postpone_import = 1
|
stefanv/scipy3
|
scipy/integrate/info.py
|
Python
|
bsd-3-clause
| 1,311 | 0.000763 |
# -*- coding: utf-8 -*-
##############################################################################
#
# Author: Nicolas Bessi. Copyright Camptocamp SA
# Contributor: Pedro Manuel Baeza <pedro.baeza@serviciosbaeza.com>
# Ignacio Ibeas <ignacio@acysos.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
from openerp.osv import orm, fields
class ResCountryState(orm.Model):
_inherit = 'res.country.state'
_columns = {'better_zip_ids': fields.one2many('res.better.zip', 'state_id', 'Cities')}
|
jmesteve/saas3
|
openerp/addons_extra/base_location/state.py
|
Python
|
agpl-3.0
| 1,248 | 0.000801 |
# Copyright 2013 IBM Corp.
#
# 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 mock
from oslo_utils import timeutils
from nova import db
from nova import exception
from nova.objects import aggregate
from nova.tests.unit import fake_notifier
from nova.tests.unit.objects import test_objects
from nova.tests import uuidsentinel
NOW = timeutils.utcnow().replace(microsecond=0)
fake_aggregate = {
'created_at': NOW,
'updated_at': None,
'deleted_at': None,
'deleted': False,
'id': 123,
'uuid': uuidsentinel.fake_aggregate,
'name': 'fake-aggregate',
'hosts': ['foo', 'bar'],
'metadetails': {'this': 'that'},
}
SUBS = {'metadata': 'metadetails'}
class _TestAggregateObject(object):
def test_get_by_id(self):
self.mox.StubOutWithMock(db, 'aggregate_get')
db.aggregate_get(self.context, 123).AndReturn(fake_aggregate)
self.mox.ReplayAll()
agg = aggregate.Aggregate.get_by_id(self.context, 123)
self.compare_obj(agg, fake_aggregate, subs=SUBS)
@mock.patch('nova.objects.Aggregate.save')
@mock.patch('nova.db.aggregate_get')
def test_load_allocates_uuid(self, mock_get, mock_save):
fake_agg = dict(fake_aggregate)
del fake_agg['uuid']
mock_get.return_value = fake_agg
uuid = uuidsentinel.aggregate
with mock.patch('oslo_utils.uuidutils.generate_uuid') as mock_g:
mock_g.return_value = uuid
obj = aggregate.Aggregate.get_by_id(self.context, 123)
mock_g.assert_called_once_with()
self.assertEqual(uuid, obj.uuid)
mock_save.assert_called_once_with()
def test_create(self):
self.mox.StubOutWithMock(db, 'aggregate_create')
db.aggregate_create(self.context, {'name': 'foo',
'uuid': uuidsentinel.fake_agg},
metadata={'one': 'two'}).AndReturn(fake_aggregate)
self.mox.ReplayAll()
agg = aggregate.Aggregate(context=self.context)
agg.name = 'foo'
agg.metadata = {'one': 'two'}
agg.uuid = uuidsentinel.fake_agg
agg.create()
self.compare_obj(agg, fake_aggregate, subs=SUBS)
def test_recreate_fails(self):
self.mox.StubOutWithMock(db, 'aggregate_create')
db.aggregate_create(self.context, {'name': 'foo',
'uuid': uuidsentinel.fake_agg},
metadata={'one': 'two'}).AndReturn(fake_aggregate)
self.mox.ReplayAll()
agg = aggregate.Aggregate(context=self.context)
agg.name = 'foo'
agg.metadata = {'one': 'two'}
agg.uuid = uuidsentinel.fake_agg
agg.create()
self.assertRaises(exception.ObjectActionError, agg.create)
def test_save(self):
self.mox.StubOutWithMock(db, 'aggregate_update')
db.aggregate_update(self.context, 123, {'name': 'baz'}).AndReturn(
fake_aggregate)
self.mox.ReplayAll()
agg = aggregate.Aggregate(context=self.context)
agg.id = 123
agg.name = 'baz'
agg.save()
self.compare_obj(agg, fake_aggregate, subs=SUBS)
def test_save_and_create_no_hosts(self):
agg = aggregate.Aggregate(context=self.context)
agg.id = 123
agg.hosts = ['foo', 'bar']
self.assertRaises(exception.ObjectActionError,
agg.create)
self.assertRaises(exception.ObjectActionError,
agg.save)
def test_update_metadata(self):
self.mox.StubOutWithMock(db, 'aggregate_metadata_delete')
self.mox.StubOutWithMock(db, 'aggregate_metadata_add')
db.aggregate_metadata_delete(self.context, 123, 'todelete')
db.aggregate_metadata_add(self.context, 123, {'toadd': 'myval'})
self.mox.ReplayAll()
fake_notifier.NOTIFICATIONS = []
agg = aggregate.Aggregate()
agg._context = self.context
agg.id = 123
agg.metadata = {'foo': 'bar'}
agg.obj_reset_changes()
agg.update_metadata({'todelete': None, 'toadd': 'myval'})
self.assertEqual(2, len(fake_notifier.NOTIFICATIONS))
msg = fake_notifier.NOTIFICATIONS[0]
self.assertEqual('aggregate.updatemetadata.start', msg.event_type)
self.assertEqual({'todelete': None, 'toadd': 'myval'},
msg.payload['meta_data'])
msg = fake_notifier.NOTIFICATIONS[1]
self.assertEqual('aggregate.updatemetadata.end', msg.event_type)
self.assertEqual({'todelete': None, 'toadd': 'myval'},
msg.payload['meta_data'])
self.assertEqual({'foo': 'bar', 'toadd': 'myval'}, agg.metadata)
def test_destroy(self):
self.mox.StubOutWithMock(db, 'aggregate_delete')
db.aggregate_delete(self.context, 123)
self.mox.ReplayAll()
agg = aggregate.Aggregate(context=self.context)
agg.id = 123
agg.destroy()
def test_add_host(self):
self.mox.StubOutWithMock(db, 'aggregate_host_add')
db.aggregate_host_add(self.context, 123, 'bar'
).AndReturn({'host': 'bar'})
self.mox.ReplayAll()
agg = aggregate.Aggregate()
agg.id = 123
agg.hosts = ['foo']
agg._context = self.context
agg.add_host('bar')
self.assertEqual(agg.hosts, ['foo', 'bar'])
def test_delete_host(self):
self.mox.StubOutWithMock(db, 'aggregate_host_delete')
db.aggregate_host_delete(self.context, 123, 'foo')
self.mox.ReplayAll()
agg = aggregate.Aggregate()
agg.id = 123
agg.hosts = ['foo', 'bar']
agg._context = self.context
agg.delete_host('foo')
self.assertEqual(agg.hosts, ['bar'])
def test_availability_zone(self):
agg = aggregate.Aggregate()
agg.metadata = {'availability_zone': 'foo'}
self.assertEqual('foo', agg.availability_zone)
def test_get_all(self):
self.mox.StubOutWithMock(db, 'aggregate_get_all')
db.aggregate_get_all(self.context).AndReturn([fake_aggregate])
self.mox.ReplayAll()
aggs = aggregate.AggregateList.get_all(self.context)
self.assertEqual(1, len(aggs))
self.compare_obj(aggs[0], fake_aggregate, subs=SUBS)
def test_by_host(self):
self.mox.StubOutWithMock(db, 'aggregate_get_by_host')
db.aggregate_get_by_host(self.context, 'fake-host', key=None,
).AndReturn([fake_aggregate])
self.mox.ReplayAll()
aggs = aggregate.AggregateList.get_by_host(self.context, 'fake-host')
self.assertEqual(1, len(aggs))
self.compare_obj(aggs[0], fake_aggregate, subs=SUBS)
@mock.patch('nova.db.aggregate_get_by_metadata_key')
def test_get_by_metadata_key(self, get_by_metadata_key):
get_by_metadata_key.return_value = [fake_aggregate]
aggs = aggregate.AggregateList.get_by_metadata_key(
self.context, 'this')
self.assertEqual(1, len(aggs))
self.compare_obj(aggs[0], fake_aggregate, subs=SUBS)
@mock.patch('nova.db.aggregate_get_by_metadata_key')
def test_get_by_metadata_key_and_hosts_no_match(self, get_by_metadata_key):
get_by_metadata_key.return_value = [fake_aggregate]
aggs = aggregate.AggregateList.get_by_metadata_key(
self.context, 'this', hosts=['baz'])
self.assertEqual(0, len(aggs))
@mock.patch('nova.db.aggregate_get_by_metadata_key')
def test_get_by_metadata_key_and_hosts_match(self, get_by_metadata_key):
get_by_metadata_key.return_value = [fake_aggregate]
aggs = aggregate.AggregateList.get_by_metadata_key(
self.context, 'this', hosts=['foo', 'bar'])
self.assertEqual(1, len(aggs))
self.compare_obj(aggs[0], fake_aggregate, subs=SUBS)
class TestAggregateObject(test_objects._LocalTest,
_TestAggregateObject):
pass
class TestRemoteAggregateObject(test_objects._RemoteTest,
_TestAggregateObject):
pass
|
HybridF5/nova
|
nova/tests/unit/objects/test_aggregate.py
|
Python
|
apache-2.0
| 8,667 | 0 |
#!/usr/bin/env python3
"""
script -- A widget displaying output of a script that lets you interact with it.
"""
import gi.repository, subprocess, sys
gi.require_version('Budgie', '1.0')
gi.require_version('Wnck', '3.0')
from gi.repository import Budgie, GObject, Wnck, Gtk, Gio, GLib
class ScriptPlugin(GObject.GObject, Budgie.Plugin):
""" A wrapper for the Script plugin. """
__gtype_name__ = 'Script'
def __init__(self):
super().__init__()
def do_get_panel_widget(self, uuid):
""" Initialize and return a new Script widget. """
return ScriptWidget(uuid)
class ScriptWidget(Budgie.Applet):
def __init__(self, uuid):
super().__init__()
self.uuid = uuid
self.directory = "budgie-script-applet"
self.button = Gtk.Button(label="Script files not found!")
self.add(self.button)
self.button.set_label(subprocess.check_output([GLib.get_user_config_dir()+"/"+self.directory+"/ontimeout.sh"]).decode(sys.stdout.encoding).strip())
self.show_all()
self.button.connect_after('clicked', self.on_click)
self.timeout_id = GObject.timeout_add(1000, self.on_timeout, None)
def on_click(self, button):
subprocess.call([GLib.get_user_config_dir()+"/"+self.directory+"/onclick.sh"])
def on_timeout(self, user_data):
self.button.set_label(subprocess.check_output([GLib.get_user_config_dir()+"/"+self.directory+"/ontimeout.sh"]).decode(sys.stdout.encoding).strip())
return True
|
kacperski1/budgie-script-applet
|
script.py
|
Python
|
gpl-2.0
| 1,518 | 0.003953 |
```
Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:
Integers in each row are sorted from left to right.
The first integer of each row is greater than the last integer of the previous row.
For example,
Consider the following matrix:
[
[1, 3, 5, 7],
[10, 11, 16, 20],
[23, 30, 34, 50]
]
Given target = 3, return true
```
# Good answer !
class Solution:
# @param matrix, a list of lists of integers
# @param target, an integer
# @return a boolean
def searchMatrix(self, matrix, target):
m = len(matrix)
n = len(matrix[0])
left = 0; right = m*n - 1
while left <= right:
mid = (left+right)/2
value = matrix[mid/n][mid%n]
if value == target:
return True
elif value > target:
right = mid -1
elif value < target:
left = mid + 1
return False
|
UmassJin/Leetcode
|
Array/Search_in_2D_matrix.py
|
Python
|
mit
| 999 | 0.013013 |
from __future__ import absolute_import, unicode_literals, print_function, division
import tempfile
import re
import os
import codecs
import sublime
import sublime_plugin
from . import git_root, GitTextCommand
def temp_file(view, key):
if not view.settings().get('git_annotation_temp_%s' % key, False):
fd, filepath = tempfile.mkstemp(prefix='git_annotations_')
os.close(fd)
view.settings().set('git_annotation_temp_%s' % key, filepath)
return view.settings().get('git_annotation_temp_%s' % key)
class GitClearAnnotationCommand(GitTextCommand):
def run(self, view):
self.active_view().settings().set('live_git_annotations', False)
self.view.erase_regions('git.changes.x')
self.view.erase_regions('git.changes.+')
self.view.erase_regions('git.changes.-')
class GitToggleAnnotationsCommand(GitTextCommand):
def run(self, view):
if self.active_view().settings().get('live_git_annotations'):
self.view.run_command('git_clear_annotation')
else:
self.view.run_command('git_annotate')
class GitAnnotationListener(sublime_plugin.EventListener):
def on_modified(self, view):
if not view.settings().get('live_git_annotations'):
return
view.run_command('git_annotate')
def on_load(self, view):
s = sublime.load_settings("Git.sublime-settings")
if s.get('annotations'):
view.run_command('git_annotate')
class GitAnnotateCommand(GitTextCommand):
# Unfortunately, git diff does not support text from stdin, making a *live*
# annotation difficult. Therefore I had to resort to the system diff
# command.
# This works as follows:
# 1. When the command is run for the first time for this file, a temporary
# file with the current state of the HEAD is being pulled from git.
# 2. All consecutive runs will pass the current buffer into diffs stdin.
# The resulting output is then parsed and regions are set accordingly.
may_change_files = False
def run(self, view):
# If the annotations are already running, we dont have to create a new
# tmpfile
if not hasattr(self, "git_tmp"):
self.git_tmp = temp_file(self.active_view(), 'head')
self.buffer_tmp = temp_file(self.active_view(), 'buffer')
self.active_view().settings().set('live_git_annotations', True)
root = git_root(self.get_working_dir())
repo_file = os.path.relpath(self.view.file_name(), root).replace('\\', '/') # always unix
self.run_command(['git', 'show', 'HEAD:{0}'.format(repo_file)], show_status=False, no_save=True, callback=self.compare_tmp)
def compare_tmp(self, result, stdout=None):
with open(self.buffer_tmp, 'wb') as f:
contents = self.get_view_contents()
if self.view.encoding() == "UTF-8 with BOM":
f.write(codecs.BOM_UTF8)
f.write(contents)
with open(self.git_tmp, 'wb') as f:
f.write(result.encode())
self.run_command(['git', 'diff', '-u', '--', self.git_tmp, self.buffer_tmp], no_save=True, show_status=False, callback=self.parse_diff)
# This is where the magic happens. At the moment, only one chunk format is supported. While
# the unified diff format theoritaclly supports more, I don't think git diff creates them.
def parse_diff(self, result, stdin=None):
if result.startswith('error:'):
print('Aborted annotations:', result)
return
lines = result.splitlines()
matcher = re.compile(r'^@@ -([0-9]*),([0-9]*) \+([0-9]*),([0-9]*) @@')
diff = []
for line_index in range(0, len(lines)):
line = lines[line_index]
if not line.startswith('@'):
continue
match = matcher.match(line)
if not match:
continue
line_before, len_before, line_after, len_after = [int(match.group(x)) for x in [1, 2, 3, 4]]
chunk_index = line_index + 1
tracked_line_index = line_after - 1
deletion = False
insertion = False
while True:
line = lines[chunk_index]
if line.startswith('@'):
break
elif line.startswith('-'):
if not line.strip() == '-':
deletion = True
tracked_line_index -= 1
elif line.startswith('+'):
if deletion and not line.strip() == '+':
diff.append(['x', tracked_line_index])
insertion = True
elif not deletion:
insertion = True
diff.append(['+', tracked_line_index])
else:
if not insertion and deletion:
diff.append(['-', tracked_line_index])
insertion = deletion = False
tracked_line_index += 1
chunk_index += 1
if chunk_index >= len(lines):
break
self.annotate(diff)
# Once we got all lines with their specific change types (either x, +, or - for
# modified, added, or removed) we can create our regions and do the actual annotation.
def annotate(self, diff):
self.view.erase_regions('git.changes.x')
self.view.erase_regions('git.changes.+')
self.view.erase_regions('git.changes.-')
typed_diff = {'x': [], '+': [], '-': []}
for change_type, line in diff:
if change_type == '-':
full_region = self.view.full_line(self.view.text_point(line - 1, 0))
position = full_region.begin()
for i in range(full_region.size()):
typed_diff[change_type].append(sublime.Region(position + i))
else:
point = self.view.text_point(line, 0)
region = self.view.full_line(point)
if change_type == '-':
region = sublime.Region(point, point + 5)
typed_diff[change_type].append(region)
for change in ['x', '+']:
self.view.add_regions("git.changes.{0}".format(change), typed_diff[change], 'git.changes.{0}'.format(change), 'dot', sublime.HIDDEN)
self.view.add_regions("git.changes.-", typed_diff['-'], 'git.changes.-', 'dot', sublime.DRAW_EMPTY_AS_OVERWRITE)
def get_view_contents(self):
region = sublime.Region(0, self.view.size())
try:
contents = self.view.substr(region).encode(self._get_view_encoding())
except UnicodeError:
# Fallback to utf8-encoding
contents = self.view.substr(region).encode('utf-8')
except LookupError:
# May encounter an encoding we don't have a codec for
contents = self.view.substr(region).encode('utf-8')
return contents
# Copied from GitGutter
def _get_view_encoding(self):
# get encoding and clean it for python ex: "Western (ISO 8859-1)"
# NOTE(maelnor): are we need regex here?
pattern = re.compile(r'.+\((.*)\)')
encoding = self.view.encoding()
if encoding == "Undefined":
encoding = self.view.settings().get('default_encoding')
if pattern.match(encoding):
encoding = pattern.sub(r'\1', encoding)
encoding = encoding.replace('with BOM', '')
encoding = encoding.replace('Windows', 'cp')
encoding = encoding.replace('-', '_')
encoding = encoding.replace(' ', '')
# work around with ConvertToUTF8 plugin
origin_encoding = self.view.settings().get('origin_encoding')
return origin_encoding or encoding
|
kemayo/sublime-text-git
|
git/annotate.py
|
Python
|
mit
| 7,837 | 0.001786 |
import numpy as np
from spins import goos
from spins.goos import material
from spins.goos import shapes
def test_pixelated_cont_shape():
def init(size):
return np.ones(size)
var, shape = shapes.pixelated_cont_shape(
init, [100, 100, 10], [20, 30, 10],
var_name="var_name",
name="shape_name",
pos=goos.Constant([1, 2, 3]),
material=material.Material(index=1),
material2=material.Material(index=2))
assert var._goos_name == "var_name"
assert shape._goos_name == "shape_name"
def test_pixelated_cont_shape_flow_get_relative_cell_coords():
coords = shapes.PixelatedContShapeFlow.get_relative_cell_coords(
[100, 100, 10], [20, 40, 10])
np.testing.assert_array_equal(coords[0], [-40, -20, 0, 20, 40])
np.testing.assert_array_equal(coords[1], [-35, 0, 35])
assert coords[2] == 0
def test_pixelated_cont_shape_flow_get_relative_cell_coords_decimal():
factor = 2.25
coords = shapes.PixelatedContShapeFlow.get_relative_cell_coords(
np.array([100, 100, 10]) * factor,
np.array([20, 40, 10]) * factor)
np.testing.assert_array_equal(coords[0],
np.array([-40, -20, 0, 20, 40]) * factor)
np.testing.assert_array_equal(coords[1], np.array([-35, 0, 35]) * factor)
assert coords[2] == 0
def test_pixelated_cont_shape_flow_get_relative_edge_coords():
coords = shapes.PixelatedContShapeFlow.get_relative_edge_coords(
[100, 100, 10], [20, 40, 10])
np.testing.assert_array_equal(coords[0], [-50, -30, -10, 10, 30, 50])
np.testing.assert_array_equal(coords[1], [-50, -20, 20, 50])
np.testing.assert_array_equal(coords[2], [-5, 5])
def test_pixelated_cont_shape_flow_get_shape():
extents = [100, 110, 10]
pixel_size = [20, 40, 10]
coords = shapes.PixelatedContShapeFlow.get_relative_cell_coords(
extents, pixel_size)
shape = shapes.PixelatedContShapeFlow.get_shape(extents, pixel_size)
assert shape == [len(coords[0]), len(coords[1]), len(coords[2])]
def make_cuboid_flow_grad(index, priority=0):
extents = [0, 0, 0]
pos = [index, 0, 0]
shape = goos.cuboid(extents=extents, pos=pos, priority=priority)
flow = goos.CuboidFlow(extents=extents, pos=pos, priority=priority)
grad = goos.CuboidFlow.Grad(pos_grad=[index, 0, 0])
return shape, flow, grad
def test_group_shape_1_shape():
with goos.OptimizationPlan() as plan:
shape, shape_flow, shape_grad = make_cuboid_flow_grad(1)
group = goos.GroupShape([shape])
inputs = [shape_flow]
assert group.eval(inputs) == goos.ArrayFlow([shape_flow])
assert group.grad(inputs,
goos.ArrayFlow.Grad([shape_grad])) == [shape_grad]
def test_group_shape_2_shape():
with goos.OptimizationPlan() as plan:
shape1, flow1, grad1 = make_cuboid_flow_grad(1)
shape2, flow2, grad2 = make_cuboid_flow_grad(2)
group = goos.GroupShape([shape1, shape2])
inputs = [flow1, flow2]
assert group.eval(inputs) == goos.ArrayFlow([flow1, flow2])
assert group.grad(inputs,
goos.ArrayFlow.Grad([grad1,
grad2])) == [grad1, grad2]
def test_group_shape_2_shape_priority():
with goos.OptimizationPlan() as plan:
shape1, flow1, grad1 = make_cuboid_flow_grad(1, priority=1)
shape2, flow2, grad2 = make_cuboid_flow_grad(2)
group = goos.GroupShape([shape1, shape2])
inputs = [flow1, flow2]
assert group.eval(inputs) == goos.ArrayFlow([flow2, flow1])
assert group.grad(inputs,
goos.ArrayFlow.Grad([grad2,
grad1])) == [grad1, grad2]
def test_group_shape_3_shape_priority():
with goos.OptimizationPlan() as plan:
shape1, flow1, grad1 = make_cuboid_flow_grad(1, priority=2)
shape2, flow2, grad2 = make_cuboid_flow_grad(2)
shape3, flow3, grad3 = make_cuboid_flow_grad(3, priority=1)
group = goos.GroupShape([shape1, shape2, shape3])
inputs = [flow1, flow2, flow3]
assert group.eval(inputs) == goos.ArrayFlow([flow2, flow3, flow1])
assert group.grad(inputs,
goos.ArrayFlow.Grad([grad2, grad3, grad1
])) == [grad1, grad2, grad3]
def test_group_shape_3_shape_priority_stable_sort():
with goos.OptimizationPlan() as plan:
shape1, flow1, grad1 = make_cuboid_flow_grad(1, priority=2)
shape2, flow2, grad2 = make_cuboid_flow_grad(2, priority=1)
shape3, flow3, grad3 = make_cuboid_flow_grad(3, priority=1)
group = goos.GroupShape([shape1, shape2, shape3])
inputs = [flow1, flow2, flow3]
assert group.eval(inputs) == goos.ArrayFlow([flow2, flow3, flow1])
assert group.grad(inputs,
goos.ArrayFlow.Grad([grad2, grad3, grad1
])) == [grad1, grad2, grad3]
def test_group_shape_array():
with goos.OptimizationPlan() as plan:
shape1, flow1, grad1 = make_cuboid_flow_grad(1)
shape2, flow2, grad2 = make_cuboid_flow_grad(2)
shape3, flow3, grad3 = make_cuboid_flow_grad(3)
group = goos.GroupShape([shape1, goos.GroupShape([shape2, shape3])])
inputs = [flow1, goos.ArrayFlow([flow2, flow3])]
assert group.eval(inputs) == goos.ArrayFlow([flow1, flow2, flow3])
assert (group.grad(inputs, goos.ArrayFlow.Grad(
[grad1, grad2,
grad3])) == [grad1, goos.ArrayFlow.Grad([grad2, grad3])])
def test_group_shape_array_priority():
with goos.OptimizationPlan() as plan:
shape1, flow1, grad1 = make_cuboid_flow_grad(1, priority=2)
shape2, flow2, grad2 = make_cuboid_flow_grad(2)
shape3, flow3, grad3 = make_cuboid_flow_grad(3, priority=1)
shape4, flow4, grad4 = make_cuboid_flow_grad(4)
group = goos.GroupShape([
goos.GroupShape([shape1, shape2]), shape3,
goos.GroupShape([shape4])
])
inputs = [
goos.ArrayFlow([flow1, flow2]), flow3,
goos.ArrayFlow([flow4])
]
assert group.eval(inputs) == goos.ArrayFlow(
[flow2, flow4, flow3, flow1])
assert (group.grad(inputs,
goos.ArrayFlow.Grad(
[grad2, grad4, grad3, grad1])) == [
goos.ArrayFlow.Grad([grad1, grad2]), grad3,
goos.ArrayFlow.Grad([grad4])
])
|
stanfordnqp/spins-b
|
spins/goos/test_shapes.py
|
Python
|
gpl-3.0
| 6,692 | 0.000299 |
from setuptools import setup, find_packages
import os
with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as readme:
README = readme.read()
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
CLASSIFIERS = [
#'Development Status :: 1 - ',
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: All',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Application Frameworks',
'Topic :: Open Data',
'Topic :: Elections',
'Programming Language :: Python :: 3.5',
'Framework :: Django',
'Framework :: Django :: 1.11',
]
INSTALL_REQUIREMENTS = [
'Django==1.11.3'
]
setup(
author='Stefan Kasberger',
author_email='info@offenewahlen.at',
name='offenewahlen_api',
version='0.1',
#version=cms.__version__,
description='Open Election Data API from Austria.',
long_description=README,
url='https://offenewahlen.at/',
license='MIT License',
platforms=['OS Independent'],
classifiers=CLASSIFIERS,
install_requires=INSTALL_REQUIREMENTS,
packages=find_packages(exclude=['project', 'project.*']),
include_package_data=True,
zip_safe=False,
#test_suite='runtests.main',
)
|
OKFNat/offenewahlen-nrw17
|
setup.py
|
Python
|
mit
| 1,452 | 0.002066 |
# -*- coding: utf-8 -*-
import factory
from data.tests.factories import DepartmentFactory
from ..models import Tourist, TouristCard
class TouristFactory(factory.DjangoModelFactory):
class Meta:
model = Tourist
first_name = 'Dave'
last_name = 'Greel'
email = 'greel@musicians.com'
class TouristCardFactory(factory.DjangoModelFactory):
class Meta:
model = TouristCard
tourist = factory.SubFactory(TouristFactory)
current_department = factory.SubFactory(DepartmentFactory)
|
notfier/touristique
|
tourists/tests/factories.py
|
Python
|
mit
| 524 | 0 |
# -*- coding: utf-8 -*-
"""
Plugin that logs the current optimum to standard output.
"""
# Future
from __future__ import absolute_import, division, print_function, \
unicode_literals, with_statement
# First Party
from metaopt.plugin.plugin import Plugin
class OptimumPrintPlugin(Plugin):
"""
Logs new optima for all return values to the standard output on result.
For example::
Minimum for value: f(a=0.1, b=0.2) = 0.7
"""
def __init__(self):
self._optima = dict() # holds a tuple of args and result for each name
def on_invoke(self, invocation):
# There are no new optima in invokes, so do nothing.
pass
def on_result(self, invocation):
"""
Logs new optima to the standard output.
"""
for return_value in invocation.function.return_spec.return_values:
name = return_value['name']
if name not in self._optima.keys() or \
self._optima[name][1] > invocation.current_result:
self._optima[name] = (tuple(invocation.fargs),
invocation.current_result)
print("%s for %s: f%s = %s" % \
("Minimum" if return_value['minimize'] else "Maximum",
name,
self._optima[name][0], self._optima[name][1]))
def on_error(self, invocation):
# There are no new optima in errors, so do nothing.
pass
|
cigroup-ol/metaopt
|
metaopt/plugin/print/optimum.py
|
Python
|
bsd-3-clause
| 1,486 | 0.000673 |
import argparse
import subprocess
import struct
import json
import shutil
import os
import collections
argparser = argparse.ArgumentParser(description='Reduce the logfile to make suitable for online destribution.')
argparser.add_argument('js_file', help='the js file to parse')
argparser.add_argument('output_name', help='the name of the output (without the .js)')
argparser.add_argument('--no-corrections', action='store_true', help='don\'t compute the corrections files')
args = argparser.parse_args()
corrections = not args.no_corrections
jsfile = args.js_file;
if jsfile[0] != "/":
jsfile = os.getcwd() + "/" + jsfile;
output = args.output_name;
pwd = os.path.dirname(os.path.realpath(__file__))
datapwd = os.path.dirname(jsfile)
print "Get data information"
fp = open(jsfile, "r")
data = json.load(fp)
fp.close()
TreeItem = collections.namedtuple('TreeItem', ['id', 'start', 'stop', 'textId', 'children', 'nextId'])
class TreeReader(object):
def __init__(self, fp):
self.fp = fp
def readItem(self, offset):
struct_fmt = '!QQII'
struct_len = struct.calcsize(struct_fmt)
struct_unpack = struct.Struct(struct_fmt).unpack_from
self.fp.seek(offset * struct_len)
s = self.fp.read(struct_len)
if not s:
return
s = struct_unpack(s)
return TreeItem(offset, s[0], s[1], s[2] >> 1, s[2] & 0x1, s[3])
def writeItem(self, item):
struct_fmt = '!QQII'
struct_len = struct.calcsize(struct_fmt)
struct_pack = struct.Struct(struct_fmt).pack
self.fp.seek(item.id * struct_len)
s = struct_pack(item.start, item.stop, item.textId * 2 + item.children, item.nextId)
self.fp.write(s)
def getStop(self):
parentItem = self.readItem(0)
if parentItem.stop is not 0:
return parentItem.stop
# If there are no children. Still use parentItem.stop
if parentItem.children is 0:
return parentItem.stop
# The parent item doesn't contain the stop information.
# Get the last tree item for the stop information.
itemId = 1
while True:
item = self.readItem(itemId)
if item.nextId is 0:
return item.stop
itemId = item.nextId
class CreateDataTree(TreeReader):
def __init__(self, fp, start, stop):
TreeReader.__init__(self, fp)
self.writeItem(TreeItem(0, start, stop, 0, 0, 0))
self.newId = 1
def addChild(self, parent, oldItem):
parentItem = self.readItem(parent)
if parentItem.children is 1:
lastChildItem = self.readItem(parent + 1)
while lastChildItem.nextId is not 0:
lastChildItem = self.readItem(lastChildItem.nextId)
self.writeItem(lastChildItem._replace(nextId = self.newId))
else:
assert self.newId == parent + 1
self.writeItem(parentItem._replace(children = 1))
self.writeItem(TreeItem(self.newId, oldItem.start, oldItem.stop, oldItem.textId, 0, 0))
newId = self.newId
self.newId += 1
return newId
class Overview:
def __init__(self, tree, dic):
self.tree = tree
self.dic = dic
self.engineOverview = {}
self.scriptOverview = {}
self.scriptTimes = {}
def isScriptInfo(self, tag):
return tag[0:6] == "script";
def clearScriptInfo(self, tag):
return tag == "G" or tag == "g";
def calc(self):
self.processTreeItem("", self.tree.readItem(0))
def processTreeItem(self, script, item):
time = item.stop - item.start
info = self.dic[item.textId]
if self.clearScriptInfo(info):
script = ""
elif self.isScriptInfo(info):
script = info
if item.children is 1:
childItem = self.tree.readItem(item.id + 1)
while childItem:
time -= childItem.stop - childItem.start
self.processTreeItem(script, childItem)
if childItem.nextId is 0:
break
childItem = self.tree.readItem(childItem.nextId)
if item.id == 0:
return
if script is "":
return
if time > 0 and not self.isScriptInfo(info):
if info not in self.engineOverview:
self.engineOverview[info] = 0
self.engineOverview[info] += time
if script is not "":
if script not in self.scriptTimes:
self.scriptTimes[script] = {}
if info not in self.scriptTimes[script]:
self.scriptTimes[script][info] = 0;
self.scriptTimes[script][info] += 1;
if script not in self.scriptOverview:
self.scriptOverview[script] = {}
if info not in self.scriptOverview[script]:
self.scriptOverview[script][info] = 0
self.scriptOverview[script][info] += time;
def visitItem(oldTree, newTree, parent, oldItem):
if oldItem.stop - oldItem.start >= threshold:
newId = newTree.addChild(parent, oldItem)
if oldItem.children is 0:
return
childItem = oldTree.readItem(oldItem.id + 1)
while childItem:
visitItem(oldTree, newTree, newId, childItem)
if childItem.nextId is 0:
break
childItem = oldTree.readItem(childItem.nextId)
ndata = []
for j in range(len(data)):
fp = open(datapwd+"/"+data[j]["tree"], "rb")
wp = open(output+'.tree.'+str(j)+'.tl', 'w+b')
oldTree = TreeReader(fp)
parentItem = oldTree.readItem(0)
start = parentItem.start
stop = oldTree.getStop()
newTree = CreateDataTree(wp, start, stop)
# accurency of 0.1px when graph shown on 1600 width display (1600*400)
threshold = (stop - start) / 640000
if parentItem.children is 1:
childItem = oldTree.readItem(1)
while childItem:
visitItem(oldTree, newTree, 0, childItem)
if childItem.nextId is 0:
break
childItem = oldTree.readItem(childItem.nextId)
if corrections:
fp = open(datapwd+"/"+data[j]["dict"], "r")
dic = json.load(fp)
fp.close()
fullOverview = Overview(oldTree, dic)
fullOverview.calc()
partOverview = Overview(newTree, dic)
partOverview.calc()
correction = {
"engineOverview": {},
"scriptTimes": {},
"scriptOverview": {}
}
for i in fullOverview.engineOverview:
correction["engineOverview"][i] = fullOverview.engineOverview[i]
if i in partOverview.engineOverview:
correction["engineOverview"][i] -= partOverview.engineOverview[i]
for script in fullOverview.scriptTimes:
correction["scriptTimes"][script] = {}
for part in fullOverview.scriptTimes[script]:
correction["scriptTimes"][script][part] = fullOverview.scriptTimes[script][part]
if script in partOverview.scriptTimes and part in partOverview.scriptTimes[script]:
correction["scriptTimes"][script][part] -= partOverview.scriptTimes[script][part]
for script in fullOverview.scriptOverview:
correction["scriptOverview"][script] = {}
for part in fullOverview.scriptOverview[script]:
correction["scriptOverview"][script][part] = fullOverview.scriptOverview[script][part]
if script in partOverview.scriptOverview and part in partOverview.scriptOverview[script]:
correction["scriptOverview"][script][part] -= partOverview.scriptOverview[script][part]
corrFile = open(output+'.corrections.'+str(j)+'.js', 'wb')
json.dump(correction, corrFile)
corrFile.close()
print "copy textmap"
shutil.copyfile(datapwd+"/"+data[j]["dict"], output+".dict."+str(j)+".js")
ndata.append({
"tree": os.path.basename(output)+'.tree.'+str(j)+'.tl',
"dict": os.path.basename(output)+'.dict.'+str(j)+'.js'
})
if corrections:
ndata[-1]["corrections"] = os.path.basename(output)+'.corrections.'+str(j)+'.js'
print "writing js file"
fp = open(output+".json", "w")
json.dump(ndata, fp);
fp.close()
|
tschneidereit/shumway
|
traceLogging/reduce.py
|
Python
|
apache-2.0
| 8,311 | 0.006858 |
from urlparse import urljoin
from django import template
from django.template.base import Node
from django.utils.encoding import iri_to_uri
register = template.Library()
class PrefixNode(template.Node):
def __repr__(self):
return "<PrefixNode for %r>" % self.name
def __init__(self, varname=None, name=None):
if name is None:
raise template.TemplateSyntaxError(
"Prefix nodes must be given a name to return.")
self.varname = varname
self.name = name
@classmethod
def handle_token(cls, parser, token, name):
"""
Class method to parse prefix node and return a Node.
"""
tokens = token.contents.split()
if len(tokens) > 1 and tokens[1] != 'as':
raise template.TemplateSyntaxError(
"First argument in '%s' must be 'as'" % tokens[0])
if len(tokens) > 1:
varname = tokens[2]
else:
varname = None
return cls(varname, name)
@classmethod
def handle_simple(cls, name):
try:
from django.conf import settings
except ImportError:
prefix = ''
else:
prefix = iri_to_uri(getattr(settings, name, ''))
return prefix
def render(self, context):
prefix = self.handle_simple(self.name)
if self.varname is None:
return prefix
context[self.varname] = prefix
return ''
@register.tag
def get_static_prefix(parser, token):
"""
Populates a template variable with the static prefix,
``settings.STATIC_URL``.
Usage::
{% get_static_prefix [as varname] %}
Examples::
{% get_static_prefix %}
{% get_static_prefix as static_prefix %}
"""
return PrefixNode.handle_token(parser, token, "STATIC_URL")
@register.tag
def get_media_prefix(parser, token):
"""
Populates a template variable with the media prefix,
``settings.MEDIA_URL``.
Usage::
{% get_media_prefix [as varname] %}
Examples::
{% get_media_prefix %}
{% get_media_prefix as media_prefix %}
"""
return PrefixNode.handle_token(parser, token, "MEDIA_URL")
class StaticNode(Node):
def __init__(self, varname=None, path=None):
if path is None:
raise template.TemplateSyntaxError(
"Static template nodes must be given a path to return.")
self.path = path
self.varname = varname
def url(self, context):
path = self.path.resolve(context)
return self.handle_simple(path)
def render(self, context):
url = self.url(context)
if self.varname is None:
return url
context[self.varname] = url
return ''
@classmethod
def handle_simple(cls, path):
return urljoin(PrefixNode.handle_simple("STATIC_URL"), path)
@classmethod
def handle_token(cls, parser, token):
"""
Class method to parse prefix node and return a Node.
"""
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError(
"'%s' takes at least one argument (path to file)" % bits[0])
path = parser.compile_filter(bits[1])
if len(bits) >= 2 and bits[-2] == 'as':
varname = bits[3]
else:
varname = None
return cls(varname, path)
@register.tag('static')
def do_static(parser, token):
"""
Joins the given path with the STATIC_URL setting.
Usage::
{% static path [as varname] %}
Examples::
{% static "myapp/css/base.css" %}
{% static variable_with_path %}
{% static "myapp/css/base.css" as admin_base_css %}
{% static variable_with_path as varname %}
"""
return StaticNode.handle_token(parser, token)
def static(path):
return StaticNode.handle_simple(path)
|
rebost/django
|
django/templatetags/static.py
|
Python
|
bsd-3-clause
| 3,940 | 0 |
# -*- 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.
#
from typing import (
Any,
AsyncIterator,
Awaitable,
Callable,
Sequence,
Tuple,
Optional,
Iterator,
)
from google.cloud.compute_v1.types import compute
class AggregatedListPager:
"""A pager for iterating through ``aggregated_list`` requests.
This class thinly wraps an initial
:class:`google.cloud.compute_v1.types.CommitmentAggregatedList` object, and
provides an ``__iter__`` method to iterate through its
``items`` field.
If there are more pages, the ``__iter__`` method will make additional
``AggregatedList`` requests and continue to iterate
through the ``items`` field on the
corresponding responses.
All the usual :class:`google.cloud.compute_v1.types.CommitmentAggregatedList`
attributes are available on the pager. If multiple requests are made, only
the most recent response is retained, and thus used for attribute lookup.
"""
def __init__(
self,
method: Callable[..., compute.CommitmentAggregatedList],
request: compute.AggregatedListRegionCommitmentsRequest,
response: compute.CommitmentAggregatedList,
*,
metadata: Sequence[Tuple[str, str]] = ()
):
"""Instantiate the pager.
Args:
method (Callable): The method that was originally called, and
which instantiated this pager.
request (google.cloud.compute_v1.types.AggregatedListRegionCommitmentsRequest):
The initial request object.
response (google.cloud.compute_v1.types.CommitmentAggregatedList):
The initial response object.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
"""
self._method = method
self._request = compute.AggregatedListRegionCommitmentsRequest(request)
self._response = response
self._metadata = metadata
def __getattr__(self, name: str) -> Any:
return getattr(self._response, name)
@property
def pages(self) -> Iterator[compute.CommitmentAggregatedList]:
yield self._response
while self._response.next_page_token:
self._request.page_token = self._response.next_page_token
self._response = self._method(self._request, metadata=self._metadata)
yield self._response
def __iter__(self) -> Iterator[Tuple[str, compute.CommitmentsScopedList]]:
for page in self.pages:
yield from page.items.items()
def get(self, key: str) -> Optional[compute.CommitmentsScopedList]:
return self._response.items.get(key)
def __repr__(self) -> str:
return "{0}<{1!r}>".format(self.__class__.__name__, self._response)
class ListPager:
"""A pager for iterating through ``list`` requests.
This class thinly wraps an initial
:class:`google.cloud.compute_v1.types.CommitmentList` object, and
provides an ``__iter__`` method to iterate through its
``items`` field.
If there are more pages, the ``__iter__`` method will make additional
``List`` requests and continue to iterate
through the ``items`` field on the
corresponding responses.
All the usual :class:`google.cloud.compute_v1.types.CommitmentList`
attributes are available on the pager. If multiple requests are made, only
the most recent response is retained, and thus used for attribute lookup.
"""
def __init__(
self,
method: Callable[..., compute.CommitmentList],
request: compute.ListRegionCommitmentsRequest,
response: compute.CommitmentList,
*,
metadata: Sequence[Tuple[str, str]] = ()
):
"""Instantiate the pager.
Args:
method (Callable): The method that was originally called, and
which instantiated this pager.
request (google.cloud.compute_v1.types.ListRegionCommitmentsRequest):
The initial request object.
response (google.cloud.compute_v1.types.CommitmentList):
The initial response object.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
"""
self._method = method
self._request = compute.ListRegionCommitmentsRequest(request)
self._response = response
self._metadata = metadata
def __getattr__(self, name: str) -> Any:
return getattr(self._response, name)
@property
def pages(self) -> Iterator[compute.CommitmentList]:
yield self._response
while self._response.next_page_token:
self._request.page_token = self._response.next_page_token
self._response = self._method(self._request, metadata=self._metadata)
yield self._response
def __iter__(self) -> Iterator[compute.Commitment]:
for page in self.pages:
yield from page.items
def __repr__(self) -> str:
return "{0}<{1!r}>".format(self.__class__.__name__, self._response)
|
googleapis/python-compute
|
google/cloud/compute_v1/services/region_commitments/pagers.py
|
Python
|
apache-2.0
| 5,692 | 0.000878 |
#!/usr/bin/env python
# ----------------------------------------------------------------------
# Numenta Platform for Intelligent Computing (NuPIC)
# Copyright (C) 2013, Numenta, Inc. Unless you have an agreement
# with Numenta, Inc., for a separate license for this software code, the
# following terms and conditions apply:
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 3 as
# published by the Free Software Foundation.
#
# 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.
#
# http://numenta.org/licenses/
# ----------------------------------------------------------------------
"""Unit tests for aggregator module."""
import unittest2 as unittest
from nupic.data import aggregator
class AggregatorTest(unittest.TestCase):
"""Unit tests for misc. aggregator functions."""
def testFixAggregationDict(self):
# Simplest case.
result = aggregator._aggr_weighted_mean((1.0, 1.0), (1, 1))
self.assertAlmostEqual(result, 1.0, places=7)
# Simple non-uniform case.
result = aggregator._aggr_weighted_mean((1.0, 2.0), (1, 2))
self.assertAlmostEqual(result, 5.0/3.0, places=7)
# Make sure it handles integer values as integers.
result = aggregator._aggr_weighted_mean((1, 2), (1, 2))
self.assertAlmostEqual(result, 1, places=7)
# More-than-two case.
result = aggregator._aggr_weighted_mean((1.0, 2.0, 3.0), (1, 2, 3))
self.assertAlmostEqual(result, 14.0/6.0, places=7)
# Handle zeros.
result = aggregator._aggr_weighted_mean((1.0, 0.0, 3.0), (1, 2, 3))
self.assertAlmostEqual(result, 10.0/6.0, places=7)
# Handle negative numbers.
result = aggregator._aggr_weighted_mean((1.0, -2.0, 3.0), (1, 2, 3))
self.assertAlmostEqual(result, 1.0, places=7)
if __name__ == '__main__':
unittest.main()
|
0x0all/nupic
|
tests/unit/py2/nupic/data/aggregator_test.py
|
Python
|
gpl-3.0
| 2,186 | 0.001372 |
# Copyright 2015 PerfKitBenchmarker Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Run YCSB against MongoDB.
YCSB is a load generator for many 'cloud' databases. MongoDB is a NoSQL
database.
MongoDB homepage: http://www.mongodb.org/
YCSB homepage: https://github.com/brianfrankcooper/YCSB/wiki
"""
import functools
import random
import string
import time
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_benchmarks import mongodb_ycsb_benchmark
from perfkitbenchmarker.linux_packages import ycsb
FLAGS = flags.FLAGS
flags.DEFINE_string('kubernetes_mongodb_cpu_request', '7.1',
'CPU request of mongodb.')
flags.DEFINE_string('kubernetes_mongodb_memory_request', '16Gi',
'Memory request of mongodb.')
flags.DEFINE_string('kubernetes_mongodb_cpu_limit', '7.6',
'CPU limit of mongodb, should be bigger than CPU request')
flags.DEFINE_string(
'kubernetes_mongodb_memory_limit', '32Gi',
'Memory limit of mongodb, should be bigger than memory request')
flags.DEFINE_string('kubernetes_mongodb_disk_size', '200Gi',
'Disk size used by mongodb')
# TODO(user): Use GetStorageClass function, once available.
STORAGE_CLASS = flags.DEFINE_string(
'kubernetes_mongodb_storage_class',
None,
'storageClassType of data disk. Defaults to provider specific storage '
'class.')
BENCHMARK_NAME = 'kubernetes_mongodb'
BENCHMARK_CONFIG = """
kubernetes_mongodb:
description: Benchmarks MongoDB server performance.
container_cluster:
cloud: GCP
type: Kubernetes
vm_count: 1
vm_spec: *default_single_core
nodepools:
mongodb:
vm_count: 1
vm_spec:
GCP:
machine_type: n2-standard-8
zone: us-central1-a
Azure:
zone: westus
machine_type: Standard_D3_v2
AWS:
zone: us-east-1a
machine_type: c5.xlarge
clients:
vm_count: 1
vm_spec: *default_single_core
vm_groups:
clients:
vm_spec: *default_single_core
vm_count: null
"""
def GetConfig(user_config):
"""Load and return benchmark config.
Args:
user_config: user supplied configuration (flags and config file)
Returns:
loaded benchmark configuration
"""
config = configs.LoadConfig(BENCHMARK_CONFIG, user_config, BENCHMARK_NAME)
if FLAGS['ycsb_client_vms'].present:
config['container_cluster']['nodepools']['mongodb']['vm_count'] = (
FLAGS.ycsb_client_vms)
return config
def _PrepareClient(vm):
"""Install YCSB on the client VM."""
vm.Install('ycsb')
# Disable logging for MongoDB driver, which is otherwise quite verbose.
log_config = """<configuration><root level="WARN"/></configuration>"""
vm.RemoteCommand("echo '{0}' > {1}/logback.xml".format(
log_config, ycsb.YCSB_DIR))
def _PrepareDeployment(benchmark_spec):
"""Deploys MongoDB Operator and instance on the cluster."""
cluster = benchmark_spec.container_cluster
admin_password = ''.join(
random.choice(string.ascii_letters + string.digits) for _ in range(20))
storage_class = STORAGE_CLASS.value or cluster.GetDefaultStorageClass()
cluster.ApplyManifest(
'container/kubernetes_mongodb/kubernetes_mongodb_crd.yaml')
cluster.ApplyManifest(
'container/kubernetes_mongodb/kubernetes_mongodb_operator.yaml.j2',
cpu_request=FLAGS.kubernetes_mongodb_cpu_request,
cpu_limit=FLAGS.kubernetes_mongodb_cpu_limit,
memory_request=FLAGS.kubernetes_mongodb_memory_request,
memory_limit=FLAGS.kubernetes_mongodb_memory_limit,
disk_size=FLAGS.kubernetes_mongodb_disk_size,
storage_class=storage_class,
admin_password=admin_password)
time.sleep(60)
benchmark_spec.container_cluster.WaitForResource('pod/mongodb-0', 'Ready')
mongodb_cluster_ip = benchmark_spec.container_cluster.GetClusterIP(
'mongodb-service')
benchmark_spec.mongodb_url = 'mongodb://ycsb:{password}@{ip_address}:27017/ycsb?authSource=ycsb'.format(
password=admin_password, ip_address=mongodb_cluster_ip)
def Prepare(benchmark_spec):
"""Install MongoDB on one VM and YCSB on another.
Args:
benchmark_spec: The benchmark specification. Contains all data that is
required to run the benchmark.
"""
server_partials = [functools.partial(_PrepareDeployment, benchmark_spec)]
client_partials = [
functools.partial(_PrepareClient, client)
for client in benchmark_spec.vm_groups['clients']
]
vm_util.RunThreaded((lambda f: f()), server_partials + client_partials)
benchmark_spec.executor = ycsb.YCSBExecutor('mongodb', cp=ycsb.YCSB_DIR)
def Run(benchmark_spec):
return mongodb_ycsb_benchmark.Run(benchmark_spec)
def Cleanup(benchmark_spec):
"""Remove MongoDB and YCSB.
Args:
benchmark_spec: The benchmark specification. Contains all data that is
required to run the benchmark.
"""
del benchmark_spec
|
GoogleCloudPlatform/PerfKitBenchmarker
|
perfkitbenchmarker/linux_benchmarks/kubernetes_mongodb_ycsb_benchmark.py
|
Python
|
apache-2.0
| 5,544 | 0.005051 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.