repo_name
stringlengths 5
92
| path
stringlengths 4
232
| copies
stringclasses 19
values | size
stringlengths 4
7
| content
stringlengths 721
1.04M
| license
stringclasses 15
values | hash
int64 -9,223,277,421,539,062,000
9,223,102,107B
| line_mean
float64 6.51
99.9
| line_max
int64 15
997
| alpha_frac
float64 0.25
0.97
| autogenerated
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|
e-democracy/edem.profile.base | setup.py | 1 | 1428 | # -*- coding=utf-8 -*-
import os
from setuptools import setup, find_packages
from version import get_version
version = get_version()
setup(name='edem.profile.base',
version=version,
description="Customization of the core profile system",
long_description=open("README.txt").read() + "\n" +
open(os.path.join("docs", "HISTORY.txt")).read(),
# See https://pypi.python.org/pypi?%3Aaction=list_classifiers for values
classifiers=[
"Development Status :: 1 - Planning",
"Environment :: Web Environment",
"Framework :: Zope2",
"Intended Audience :: Developers",
"License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
"Natural Language :: English",
"Operating System :: POSIX :: Linux"
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
],
keywords='edem profile',
author='Bill Bushey',
author_email='[email protected]',
url='http://www.e-democracy.org/',
license='GPL 3',
packages=find_packages(exclude=['ez_setup']),
namespace_packages=['edem', 'edem.profile'],
include_package_data=True,
zip_safe=False,
install_requires=[
'setuptools',
'gs.skin.ogn.edem',
'gs.profile.base',
# -*- Extra requirements: -*-
],
entry_points="""
# -*- Entry points: -*-
""",)
| gpl-3.0 | -9,073,239,956,995,717,000 | 31.454545 | 83 | 0.611345 | false |
SandStormHoldings/libvirt-fabric-restapi | macgen.py | 1 | 1414 | #!/usr/bin/python
# macgen.py script to generate a MAC address for virtualized guests
#
from __future__ import print_function
from builtins import map
from builtins import range
import random
import sys
import re
import hashlib
from config import HOSTS,HOST_IDX, main_network
#
def randomMAC(host,counters):
if host not in counters: counters[host]=0
respl = re.compile('(..)')
hsh = hashlib.md5(host.encode('utf-8'))
host_suffix = hsh.hexdigest()[0:4]
mac = [ 0x00, 0x16, 0x3e,
random.randint(0x00, 0x7f),
random.randint(0x00, 0xff),
random.randint(0x00, 0xff) ]
mapped = list(map(lambda x: "%02x" % x, mac))[0:3]
host_suffix_spl = (respl.findall(host_suffix))
rt= ':'.join(mapped+['%02x'%counters[host]]+host_suffix_spl)
counters[host]+=1
return rt
def genmacs(only_host=None):
rt=''
ipcounter=0
dom_counters = {}
for host,ip in list(HOSTS.items()):
if only_host and host!=only_host: continue
rt+='# %s (%s)\n'%(host,ip)
for i in range(10,255):
vhostaddr = '%s.%s.%s'%(main_network, HOST_IDX[host],i)
rt+= "host virt-%s-%s { hardware ethernet %s; fixed-address %s; }\n"%(host,ipcounter,randomMAC(host,dom_counters),vhostaddr)
ipcounter+=1
rt+="\n"
return rt
if 'range' in sys.argv:
print(genmacs())
elif __name__=='__main__':
print(randomMAC())
| mit | 5,409,914,169,610,697,000 | 26.72549 | 136 | 0.618105 | false |
csbrandt/JSBSim.js | JSBSim/tests/TestICOverride.py | 1 | 4338 | # TestICOverride.py
#
# A regression test that checks that IC loaded from a file by a script can be
# overridden.
#
# Copyright (c) 2014 Bertrand Coconnier
#
# 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 sys, unittest
import xml.etree.ElementTree as et
from JSBSim_utils import Table, CreateFDM, ExecuteUntil, SandBox
fpstokts = 0.592484
class TestICOverride(unittest.TestCase):
def setUp(self):
self.sandbox = SandBox()
def tearDown(self):
self.sandbox.erase()
def test_IC_override(self):
# Run the script c1724.xml
script_path = self.sandbox.path_to_jsbsim_file('scripts', 'c1724.xml')
fdm = CreateFDM(self.sandbox)
fdm.load_script(script_path)
vt0 = fdm.get_property_value('ic/vt-kts')
fdm.run_ic()
ExecuteUntil(fdm, 1.0)
# Check that the total velocity exported in the output file matches the IC
# defined in the initialization file
ref = Table()
ref.ReadCSV(self.sandbox('JSBout172B.csv'))
for col, title in enumerate(ref._lines[0]):
if title == 'V_{Total} (ft/s)':
self.assertTrue(abs(ref._lines[1][col] - (vt0 / fpstokts)) < 1E-5,
msg="Original script %s\nThe total velocity is %f. The value %f was expected" % (script_path, ref._lines[1][col], vt0 / fpstokts))
break
else:
self.fail("The total velocity is not exported in %s" % (script_path,))
# Now, we will re-run the same test but the IC will be overridden in the scripts
# The initial total velocity is increased by 1 ft/s
vt0 += 1.0
# The script c1724.xml is loaded and the following line is added in it:
# <property value="..."> ic/vt-kts </property>
# The modified script is then saved with the named 'c1724_0.xml'
tree = et.parse(self.sandbox.elude(script_path))
run_tag = tree.getroot().find("./run")
property = et.SubElement(run_tag, 'property')
property.text = 'ic/vt-kts'
property.attrib['value'] = str(vt0)
tree.write(self.sandbox('c1724_0.xml'))
# Re-run the same check than above. This time we are making sure than the total
# initial velocity is increased by 1 ft/s
self.sandbox.delete_csv_files()
# Because JSBSim internals use static pointers, we cannot rely on Python
# garbage collector to decide when the FDM is destroyed otherwise we can
# get dangling pointers.
del fdm
fdm = CreateFDM(self.sandbox)
fdm.load_script('c1724_0.xml')
self.assertTrue(abs(fdm.get_property_value('ic/vt-kts') - vt0) < 1E-5,
msg="Modified script %s\nThe total velocity in the IC (%f) is different from %f" % (self.sandbox('JSBout172B.csv'), fdm.get_property_value('ic/vt-kts'), vt0))
fdm.run_ic()
ExecuteUntil(fdm, 1.0)
mod = Table()
mod.ReadCSV(self.sandbox('JSBout172B.csv'))
for col, title in enumerate(mod._lines[0]):
if title == 'V_{Total} (ft/s)':
self.assertTrue(abs(mod._lines[1][col] - (vt0 / fpstokts)) < 1E-5,
msg="Modified script %s\nThe total velocity is %f. The value %f was expected" % (self.sandbox('JSBout172B.csv'), mod._lines[1][col], vt0 / fpstokts))
break
else:
self.fail("The total velocity is not exported in %s" % (sandbox('JSBout172B.csv'),))
suite = unittest.TestLoader().loadTestsFromTestCase(TestICOverride)
test_result = unittest.TextTestRunner(verbosity=2).run(suite)
if test_result.failures or test_result.errors:
sys.exit(-1) # 'make test' will report the test failed.
| lgpl-2.1 | -4,971,547,662,809,787,000 | 39.542056 | 182 | 0.638082 | false |
Yordan92/Pac-man-multiplayer | Ghosts.py | 1 | 5718 | from MakeGraph import MakeGraph
from Moving_pacman import PacMan
import pygame
class Ghost(MakeGraph):
index = 0
def __init__(self,class_graph,x,y):
Ghost.index = Ghost.index + 1
self.all_nodes = class_graph.get_nodes()
self.paths_to_all_nodes = class_graph.get_shortest_path()
self.path = []
self.hunting = False
self.name_image_u = "Ghost_red_up"
self.name_image_d = "Ghost_red_down"
self.name_image_l = "Ghost_red_left"
self.name_image_r = "Ghost_red_right"
self.name_image = self.name_image_u
self.cords={'x': x, 'y': y}
# {'x': 92, 'y': 161}
self.index = Ghost.index
def next_hop(self):
if self.path:
return self.path[0]
return []
def find_ghost_cords(self):
ghost_x = int(self.cords['y']/23)
ghost_y = int(self.cords['x']/23)
return (ghost_x,ghost_y)
def get_pictures(self):
if self.index == 0 :
self.name_image_u = "Ghost_red_up"
self.name_image_d = "Ghost_red_down"
self.name_image_l = "Ghost_red_left"
self.name_image_r = "Ghost_red_right"
if self.index == 1:
self.name_image_u = "Ghost_orange_up"
self.name_image_d = "Ghost_orange_down"
self.name_image_l = "Ghost_orange_left"
self.name_image_r = "Ghost_orange_right"
if self.index == 2:
self.name_image_u = "Ghost_pink_up"
self.name_image_d = "Ghost_pink_down"
self.name_image_l = "Ghost_pink_left"
self.name_image_r = "Ghost_pink_right"
if self.index == 3:
self.name_image_u = "Ghost_cyan_up"
self.name_image_d = "Ghost_cyan_down"
self.name_image_l = "Ghost_cyan_left"
self.name_image_r = "Ghost_cyan_right"
def find_closest_nodes(self):
closest_nodes =[]
ghost_x = int(self.cords['x']/23)
ghost_y = int(self.cords['y']/23)
vertex = (ghost_y,ghost_x)
queue = [vertex]
Visited = [vertex]
# if vertex in all_Nodes:
# all_Nodes.remove(vertex)
while queue != []:
new_v = queue.pop(0)
new_v_adj = [(new_v[0] - 1, new_v[1]),
(new_v[0] + 1, new_v[1]),
(new_v[0], new_v[1] - 1),
(new_v[0], new_v[1] + 1)]
for v_adj in new_v_adj:
if self.is_p_vertex(v_adj) and v_adj not in Visited:
if v_adj in self.all_nodes:
closest_nodes.append((v_adj[1],v_adj[0]))
else:
queue.append(v_adj)
Visited.append(v_adj)
return closest_nodes
def find_closest_vertex(self):
closest_nodes =[]
ghost_x = int(self.cords['x']/23)
ghost_y = int(self.cords['y']/23)
vertex = (ghost_y,ghost_x)
queue = [vertex]
map_to_a_vertex = {}
visited_n = [vertex]
# print (self.all_nodes)
if vertex in self.all_nodes:
return []
while queue != []:
new_v = queue.pop(0)
new_v_adj = [(new_v[0] - 1, new_v[1]),
(new_v[0] + 1, new_v[1]),
(new_v[0], new_v[1] - 1),
(new_v[0], new_v[1] + 1)]
for v_adj in new_v_adj:
map_to_a_vertex[v_adj] = new_v
if v_adj in self.all_nodes:
full_path = [v_adj]
while map_to_a_vertex[v_adj] != vertex:
v_adj = map_to_a_vertex[v_adj]
full_path.insert(0,v_adj)
return full_path
if MakeGraph.is_p_vertex(self,v_adj) and v_adj not in visited_n:
queue.append(v_adj)
visited_n.append(v_adj)
def ghost_move(self, pacman_vertex, pacman_cords):
my_cords = (int(self.cords['y']/23),int(self.cords['x']/23))
if my_cords == pacman_vertex:
self.hunting = True
if self.hunting == True:
self.path = self.search_eat(pacman_cords)
if not self.path:
if self.hunting == True:
self.hunting = False
if self.find_closest_vertex() != []:
self.path = self.find_closest_vertex()
else:
for i in self.paths_to_all_nodes[my_cords][pacman_vertex]:
self.path.extend(2*[i])
def ghost_make_move(self):
# if not self.path:
# self.ghost_move(screen,pacman_vertex,pacman_cords)
new_step = self.path.pop(0)
old_step = (int(self.cords['y'] / 23),int(self.cords['x'])/23)
if old_step[0] == new_step[0] and old_step[1]<new_step[1]:
self.name_image = self.name_image_r
if old_step[0] == new_step[0] and old_step[1]>new_step[1]:
self.name_image = self.name_image_l
if old_step[0] < new_step[0] and old_step[1]==new_step[1]:
self.name_image = self.name_image_d
if old_step[0] > new_step[0] and old_step[1]==new_step[1]:
self.name_image = self.name_image_u
self.cords['y'] = new_step[0]*23
self.cords['x'] = new_step[1]*23
def search_eat(self,pacman_cords):
closest_nodes =[]
# pacman_x = int(pacman_cords['x']/23)
# pacman_y = int(pacman_cords['y']/23)
ghost_x = int(self.cords['x']/23)
ghost_y = int(self.cords['y']/23)
vertex = (ghost_y,ghost_x)
queue = [vertex]
map_to_a_vertex = {}
visited_n = [vertex]
if vertex == pacman_cords:
return []
while queue != []:
new_v = queue.pop(0)
new_v_adj = [(new_v[0] - 1, new_v[1]),
(new_v[0] + 1, new_v[1]),
(new_v[0], new_v[1] - 1),
(new_v[0], new_v[1] + 1)]
for v_adj in new_v_adj:
if self.is_p_vertex(v_adj) and v_adj not in visited_n:
queue.append(v_adj)
visited_n.append(v_adj)
map_to_a_vertex[v_adj] = new_v
if v_adj == pacman_cords:
# map_to_a_vertex[v_adj] = new_v
# print(map_to_a_vertex)
# print("abc",v_adj,new_v)
while map_to_a_vertex[v_adj] != vertex:
# print("abc",v_adj)
v_adj = map_to_a_vertex[v_adj]
return [v_adj]
return []
def draw_ghost(self,screen):
ghost = pygame.image.load("Ghosts/Ghost_cyan_down.png")
# print(self.find_closest_vertex())
self.ghost_move(screen,(14,13),(16,14))
# p = self.path[-1]
# pygame.draw.rect(screen, (124, 124, 0),
# (p[1]* 23, p[0] * 23, 23, 23))
screen.blit(ghost,(self.cords['x'], self.cords['y']))
| gpl-3.0 | 8,085,236,753,210,260,000 | 25.719626 | 68 | 0.59164 | false |
digidotcom/epoxy | setup.py | 1 | 1990 | # This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# Copyright (c) 2014 Etherios, Inc. All rights reserved.
# Etherios, Inc. is a Division of Digi International.
from setuptools import setup, find_packages
def get_long_description():
long_description = open('README.md').read()
try:
import subprocess
import pandoc
process = subprocess.Popen(
['which pandoc'],
shell=True,
stdout=subprocess.PIPE,
universal_newlines=True)
pandoc_path = process.communicate()[0]
pandoc_path = pandoc_path.strip('\n')
pandoc.core.PANDOC_PATH = pandoc_path
doc = pandoc.Document()
doc.markdown = long_description
long_description = doc.rst
except:
print("Could not find pandoc or convert properly")
print(" make sure you have pandoc (system) and pyandoc (python module) installed")
return long_description
setup(
name='epoxy',
version='1.0',
description='Inversion of Control Framework for Python',
long_description=get_long_description(),
url='https://github.com/etherios/epoxy',
author="Paul Osborne",
author_email="[email protected]",
packages=find_packages(),
install_requires=open('requirements.txt').read().split(),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Application Frameworks",
"Operating System :: OS Independent",
],
)
| mpl-2.0 | -2,129,511,811,997,380,000 | 32.728814 | 91 | 0.650251 | false |
DBuildService/atomic-reactor | atomic_reactor/api.py | 1 | 5538 | """
Copyright (c) 2015 Red Hat, Inc
All rights reserved.
This software may be modified and distributed under the terms
of the BSD license. See the LICENSE file for details.
Python API for atomic-reactor. This is the official way of interacting with atomic-reactor.
"""
from atomic_reactor.inner import DockerBuildWorkflow
from atomic_reactor.outer import PrivilegedBuildManager, DockerhostBuildManager
from atomic_reactor.plugins.pre_pull_base_image import PullBaseImagePlugin
from atomic_reactor.plugins.post_tag_and_push import TagAndPushPlugin
__all__ = (
'build_image_in_privileged_container',
'build_image_using_hosts_docker',
'build_image_here',
)
def _prepare_build_json(image, source, target_registries, target_registries_insecure,
dont_pull_base_image, **kwargs):
target_registries = target_registries or []
registries = dict([(registry, {"insecure": target_registries_insecure})
for registry in target_registries])
build_json = {
"image": image,
"source": source,
"postbuild_plugins": [{
"name": TagAndPushPlugin.key,
"args": {
"registries": registries
}
}]
}
if not dont_pull_base_image:
build_json["prebuild_plugins"] = [{
"name": PullBaseImagePlugin.key,
"args": {}
}]
build_json.update(kwargs)
return build_json
def build_image_in_privileged_container(build_image, source, image, target_registries=None,
push_buildroot_to=None,
target_registries_insecure=False,
dont_pull_base_image=False, **kwargs):
"""
build image from provided dockerfile (specified by `source`) in privileged container by
running another docker instance inside the container
:param build_image: str, image where target image should be built
:param source: dict, where/how to get source code to put in image
:param image: str, tag for built image ([registry/]image_name[:tag])
:param target_registries: list of str, list of registries to push image to (might change in
future)
:param push_buildroot_to: str, repository where buildroot should be pushed
:param target_registries_insecure: bool, allow connecting to target registries over plain http
:param dont_pull_base_image: bool, don't pull or update base image specified in dockerfile
:return: BuildResults
"""
build_json = _prepare_build_json(image, source, target_registries, target_registries_insecure,
dont_pull_base_image, **kwargs)
m = PrivilegedBuildManager(build_image, build_json)
build_response = m.build()
if push_buildroot_to:
m.commit_buildroot()
m.push_buildroot(push_buildroot_to)
return build_response
def build_image_using_hosts_docker(build_image, source, image, target_registries=None,
push_buildroot_to=None,
target_registries_insecure=False, dont_pull_base_image=False,
**kwargs):
"""
build image from provided dockerfile (specified by `source`) in privileged container
using docker from host
:param build_image: str, image where target image should be built
:param source: dict, where/how to get source code to put in image
:param image: str, tag for built image ([registry/]image_name[:tag])
:param target_registries: list of str, list of registries to push image to (might change in
future)
:param push_buildroot_to: str, repository where buildroot should be pushed
:param target_registries_insecure: bool, allow connecting to target registries over plain http
:param dont_pull_base_image: bool, don't pull or update base image specified in dockerfile
:return: BuildResults
"""
build_json = _prepare_build_json(image, source, target_registries, target_registries_insecure,
dont_pull_base_image, **kwargs)
m = DockerhostBuildManager(build_image, build_json)
build_response = m.build()
if push_buildroot_to:
m.commit_buildroot()
m.push_buildroot(push_buildroot_to)
return build_response
def build_image_here(source, image, target_registries=None, target_registries_insecure=False,
dont_pull_base_image=False, **kwargs):
"""
build image from provided dockerfile (specified by `source`) in current environment
:param source: dict, where/how to get source code to put in image
:param image: str, tag for built image ([registry/]image_name[:tag])
:param target_registries: list of str, list of registries to push image to (might change in
future)
:param target_registries_insecure: bool, allow connecting to target registries over plain http
:param dont_pull_base_image: bool, don't pull or update base image specified in dockerfile
:return: BuildResults
"""
build_json = _prepare_build_json(image, source, target_registries, target_registries_insecure,
dont_pull_base_image, **kwargs)
m = DockerBuildWorkflow(**build_json)
return m.build_docker_image()
def list_dockerfiles_in_git():
"""
clone provided repo and return all dockerfiles found in the repo
:return:
"""
| bsd-3-clause | 5,659,945,660,937,605,000 | 40.022222 | 98 | 0.650235 | false |
rainest/dance-partner-matching | networkx/generators/tests/test_degree_seq.py | 1 | 7378 | #!/usr/bin/env python
from nose.tools import *
import networkx
from networkx import *
from networkx.generators.degree_seq import *
from networkx.algorithms.isomorphism.isomorph import graph_could_be_isomorphic
from networkx.utils import uniform_sequence,powerlaw_sequence
"""Generators - Degree Sequence
----------------------
"""
class TestGeneratorsDegreeSequence():
def test_configuration_model(self):
# empty graph has empty degree sequence
deg_seq=[]
G=configuration_model(deg_seq)
assert_equal(G.degree(), {})
deg_seq=[5,3,3,3,3,2,2,2,1,1,1]
G=configuration_model(deg_seq,seed=12345678)
assert_equal(sorted(G.degree().values(),reverse=True),
[5, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1])
assert_equal(sorted(G.degree(range(len(deg_seq))).values(),
reverse=True),
[5, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1])
# test that fixed seed delivers the same graph
deg_seq=[3,3,3,3,3,3,3,3,3,3,3,3]
G1=configuration_model(deg_seq,seed=1000)
G2=configuration_model(deg_seq,seed=1000)
assert_true(is_isomorphic(G1,G2))
G1=configuration_model(deg_seq,seed=10)
G2=configuration_model(deg_seq,seed=10)
assert_true(is_isomorphic(G1,G2))
z=[5,3,3,3,3,2,2,2,1,1,1]
assert_true(is_valid_degree_sequence(z))
assert_raises(networkx.exception.NetworkXError,
configuration_model, z, create_using=DiGraph())
G=havel_hakimi_graph(z)
G=configuration_model(z)
z=[1000,3,3,3,3,2,2,2,1,1,1]
assert_false(is_valid_degree_sequence(z))
def test_expected_degree_graph(self):
# empty graph has empty degree sequence
deg_seq=[]
G=expected_degree_graph(deg_seq)
assert_equal(G.degree(), {})
# test that fixed seed delivers the same graph
deg_seq=[3,3,3,3,3,3,3,3,3,3,3,3]
G1=expected_degree_graph(deg_seq,seed=1000)
G2=expected_degree_graph(deg_seq,seed=1000)
assert_true(is_isomorphic(G1,G2))
G1=expected_degree_graph(deg_seq,seed=10)
G2=expected_degree_graph(deg_seq,seed=10)
assert_true(is_isomorphic(G1,G2))
assert_raises(networkx.exception.NetworkXError,
expected_degree_graph, deg_seq,
create_using=DiGraph())
def test_havel_hakimi_construction(self):
z=[1000,3,3,3,3,2,2,2,1,1,1]
assert_raises(networkx.exception.NetworkXError,
havel_hakimi_graph, z)
z=["A",3,3,3,3,2,2,2,1,1,1]
assert_raises(networkx.exception.NetworkXError,
havel_hakimi_graph, z)
z=[5,4,3,3,3,2,2,2]
G=havel_hakimi_graph(z)
G=configuration_model(z)
z=[6,5,4,4,2,1,1,1]
assert_false(is_valid_degree_sequence(z))
assert_raises(networkx.exception.NetworkXError,
havel_hakimi_graph, z)
z=[10,3,3,3,3,2,2,2,2,2,2]
assert_true(is_valid_degree_sequence(z))
G=havel_hakimi_graph(z)
assert_raises(networkx.exception.NetworkXError,
havel_hakimi_graph, z, create_using=DiGraph())
assert_raises(networkx.exception.NetworkXError,
havel_hakimi_graph, z, create_using=MultiGraph())
def test_degree_sequence_tree(self):
z=[1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
assert_true(is_valid_degree_sequence(z))
G=degree_sequence_tree(z)
assert_true(len(G.nodes())==len(z))
assert_true(len(G.edges())==sum(z)/2)
assert_raises(networkx.exception.NetworkXError,
degree_sequence_tree, z, create_using=DiGraph())
z=[1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
assert_false(is_valid_degree_sequence(z))
assert_raises(networkx.exception.NetworkXError,
degree_sequence_tree, z)
def test_degree_sequences(self):
seq=create_degree_sequence(10,uniform_sequence)
assert_equal(len(seq), 10)
seq=create_degree_sequence(10,powerlaw_sequence)
assert_equal(len(seq), 10)
def test_double_edge_swap(self):
graph = barabasi_albert_graph(200,1)
degreeStart = sorted(graph.degree().values())
G = connected_double_edge_swap(graph, 40)
assert_true(is_connected(graph))
degseq = sorted(graph.degree().values())
assert_true(degreeStart == degseq)
G = double_edge_swap(graph, 40)
degseq2 = sorted(graph.degree().values())
assert_true(degreeStart == degseq2)
def test_degree_seq_c4(self):
G = networkx.cycle_graph(4)
degree_start = sorted(G.degree().values())
G = double_edge_swap(G,1,100)
degseq = sorted(G.degree().values())
assert_true(degree_start == degseq)
def test_construction_smax_graph0(self):
z=["A",3,3,3,3,2,2,2,1,1,1]
assert_raises(networkx.exception.NetworkXError,
li_smax_graph, z)
def test_construction_smax_graph1(self):
z=[5,4,3,3,3,2,2,2]
G=li_smax_graph(z)
degs = sorted(degree(G).values(),reverse=True)
assert_equal(degs, z)
def test_construction_smax_graph2(self):
z=[6,5,4,4,2,1,1,1]
assert_false(is_valid_degree_sequence(z))
assert_raises(networkx.exception.NetworkXError,
li_smax_graph, z)
def test_construction_smax_graph3(self):
z=[10,3,3,3,3,2,2,2,2,2,2]
assert_true(is_valid_degree_sequence(z))
G=li_smax_graph(z)
degs = sorted(degree(G).values(),reverse=True)
assert_equal(degs, z)
assert_raises(networkx.exception.NetworkXError,
li_smax_graph, z, create_using=DiGraph())
class TestRandomClusteredGraph:
def test_valid(self):
node=[1,1,1,2,1,2,0,0]
tri=[0,0,0,0,0,1,1,1]
joint_degree_sequence=zip(node,tri)
G = networkx.random_clustered_graph(joint_degree_sequence)
assert_equal(G.number_of_nodes(),8)
assert_equal(G.number_of_edges(),7)
def test_valid2(self):
G = networkx.random_clustered_graph(\
[(1,2),(2,1),(1,1),(1,1),(1,1),(2,0)])
assert_equal(G.number_of_nodes(),6)
assert_equal(G.number_of_edges(),10)
def test_invalid1(self):
assert_raises((TypeError,networkx.NetworkXError),
networkx.random_clustered_graph,[[1,1],[2,1],[0,1]])
def test_invalid2(self):
assert_raises((TypeError,networkx.NetworkXError),
networkx.random_clustered_graph,[[1,1],[1,2],[0,1]])
def test_li_smax():
G = networkx.barabasi_albert_graph(25,1) #Any old graph
Gdegseq = list(G.degree().values()) #degree sequence
Gdegseq.sort(reverse=True)
# Tests the 'unconstrained version'
assert_true(not (sum(Gdegseq)%2))
Gmax = networkx.li_smax_graph(Gdegseq)
Gmaxdegseq = list(Gmax.degree().values())
Gmaxdegseq.sort(reverse=True)
assert_equal(G.order(),Gmax.order()) #Sanity Check on the nodes
# make sure both graphs have the same degree sequence
assert_equal(Gdegseq,Gmaxdegseq)
# make sure the smax graph is actually bigger
assert_true(networkx.s_metric(G) <= networkx.s_metric(Gmax))
| bsd-2-clause | -4,364,301,775,330,757,000 | 34.471154 | 78 | 0.594741 | false |
padmec-reservoir/ELLIPTIc | elliptic/Kernel/DSL.py | 1 | 3082 | from abc import ABC, abstractmethod
from contextlib import contextmanager
from types import ModuleType
from typing import List, Iterator
from elliptic.Kernel.Expression import Expression
from .Contract import DSLContract
from .TemplateManager import TemplateManagerBase
from .TreeBuilder import TreeBuild
class DSLMeta(ABC):
"""Class which stores information regarding the DSL compilation.
"""
@abstractmethod
def libs(self) -> List[str]:
"""Returns the list of libraries that should be linked against.
Example:
['MOAB', 'Trilinos']
"""
raise NotImplementedError
@abstractmethod
def include_dirs(self) -> List[str]:
"""Returns the list of include directories that should be used when compiling.
Cypyler adds the numpy includes by default. Any extra include paths should be returned here.
Example:
['/usr/local/include/moab']
"""
raise NotImplementedError
class DSLException(Exception):
pass
class DSLBuildError(DSLException):
"""Exception raised when an error related to a DSL build process happens.
"""
class DSL:
"""Defines the interface for interacting with a DSL.
Parameters:
template_manager: A `TemplateManagerBase` subinstance.
dsl_contract: A DSL Contract.
dsl_meta: A `DSLMeta` instance.
"""
def __init__(self,
template_manager: TemplateManagerBase,
dsl_contract: DSLContract,
dsl_meta: DSLMeta) -> None:
self.template_manager = template_manager
self.dsl_contract = dsl_contract
self.dsl_meta = dsl_meta
self.built = False
self.building = False
self.built_module: ModuleType = None
@contextmanager
def root(self) -> Iterator[DSLContract]:
"""Entry point for building expressions.
Should be used as a context manager, using the `with` statement.
"""
if not self.built and not self.building:
self.building = True
root_ = self.dsl_contract.Base()
yield root_
self._build(root_.expr)
else:
raise DSLBuildError("Can't get root while or after building a DSL tree.")
def get_built_module(self) -> ModuleType:
"""Returns the compiled module that holds the generated code.
"""
if not self.built:
raise DSLBuildError("Can't get the built module before finishing building the DSL tree.")
return self.built_module
def _build(self, root: Expression):
"""Builds a DSL tree, generating the corresponding code, given the DSL tree root.
The DSL tree root should always be a StatementRoot instance.
Parameters:
root: The DSL tree root.
"""
tree_builder = TreeBuild(self.template_manager,
self.dsl_meta.libs(), self.dsl_meta.include_dirs())
self.built_module = tree_builder.build(root)
self.building = False
self.built = True
| mit | 7,916,992,614,376,502,000 | 28.92233 | 101 | 0.634653 | false |
coxmediagroup/django-socialregistration | socialregistration/views.py | 1 | 14068 | import uuid
from django.conf import settings
from django.template import RequestContext
from django.core.urlresolvers import reverse
from django.shortcuts import render_to_response
from django.utils.translation import gettext as _
from django.http import HttpResponseRedirect
try:
from django.views.decorators.csrf import csrf_protect
has_csrf = True
except ImportError:
has_csrf = False
from django.contrib.auth.models import User
from django.contrib.auth import login, authenticate, logout as auth_logout
from django.contrib.sites.models import Site
from socialregistration.forms import UserForm, ClaimForm, ExistingUser
from socialregistration.utils import (OAuthClient, OAuthTwitter,
OpenID, _https, DiscoveryFailure, GoogleOpenIDSchemas, YahooOpenIDSchemas, MyOpenIDSchemas)
from socialregistration.models import FacebookProfile, TwitterProfile, OpenIDProfile
from openid.extensions import ax, pape, sreg
from urlparse import urljoin
from django.db import connection
from django.core.urlresolvers import reverse as reverseURL
from socialregistration import util
from openid.consumer import consumer
FB_ERROR = _('We couldn\'t validate your Facebook credentials')
GENERATE_USERNAME = bool(getattr(settings, 'SOCIALREGISTRATION_GENERATE_USERNAME', False))
def _get_next(request):
"""
Returns a url to redirect to after the login
"""
if 'next' in request.session:
next = request.session['next']
del request.session['next']
return next
elif 'next' in request.GET:
return request.GET.get('next')
elif 'next' in request.POST:
return request.POST.get('next')
else:
return getattr(settings, 'LOGIN_REDIRECT_URL', '/')
def setup(request, template='socialregistration/setup.html',
form_class=UserForm, extra_context=dict(), claim_form_class=ClaimForm):
"""
Setup view to create a username & set email address after authentication
"""
try:
social_user = request.session['socialregistration_user']
social_profile = request.session['socialregistration_profile']
except KeyError:
return render_to_response(
template, dict(error=True), context_instance=RequestContext(request))
if not GENERATE_USERNAME:
# User can pick own username
if not request.method == "POST":
form = form_class(social_user, social_profile,)
else:
form = form_class(social_user, social_profile, request.POST)
try:
if form.is_valid():
form.save()
user = form.profile.authenticate()
login(request, user)
del request.session['socialregistration_user']
del request.session['socialregistration_profile']
return HttpResponseRedirect(_get_next(request))
except ExistingUser:
# see what the error is. if it's just an existing user, we want to let them claim it.
if 'submitted' in request.POST:
form = claim_form_class(
request.session['socialregistration_user'],
request.session['socialregistration_profile'],
request.POST
)
else:
form = claim_form_class(
request.session['socialregistration_user'],
request.session['socialregistration_profile'],
initial=request.POST
)
if form.is_valid():
form.save()
user = form.profile.authenticate()
login(request, user)
del request.session['socialregistration_user']
del request.session['socialregistration_profile']
return HttpResponseRedirect(_get_next(request))
extra_context['claim_account'] = True
extra_context.update(dict(form=form))
return render_to_response(template, extra_context,
context_instance=RequestContext(request))
else:
# Generate user and profile
social_user.username = str(uuid.uuid4())[:30]
social_user.save()
social_profile.user = social_user
social_profile.save()
# Authenticate and login
user = social_profile.authenticate()
login(request, user)
# Clear & Redirect
del request.session['socialregistration_user']
del request.session['socialregistration_profile']
return HttpResponseRedirect(_get_next(request))
if has_csrf:
setup = csrf_protect(setup)
def facebook_login(request, template='socialregistration/facebook.html',
extra_context=dict(), account_inactive_template='socialregistration/account_inactive.html'):
"""
View to handle the Facebook login
"""
if request.facebook.uid is None:
extra_context.update(dict(error=FB_ERROR))
return HttpResponseRedirect(reverse('login'))
user = authenticate(uid=request.facebook.uid)
if user is None:
request.session['socialregistration_user'] = User()
request.session['socialregistration_profile'] = FacebookProfile(uid=request.facebook.uid)
request.session['next'] = _get_next(request)
return HttpResponseRedirect(reverse('socialregistration_setup'))
if not user.is_active:
return render_to_response(account_inactive_template, extra_context,
context_instance=RequestContext(request))
login(request, user)
return HttpResponseRedirect(_get_next(request))
def facebook_connect(request, template='socialregistration/facebook.html',
extra_context=dict()):
"""
View to handle connecting existing django accounts with facebook
"""
if request.facebook.uid is None or request.user.is_authenticated() is False:
extra_context.update(dict(error=FB_ERROR))
return render_to_response(template, extra_context,
context_instance=RequestContext(request))
try:
profile = FacebookProfile.objects.get(uid=request.facebook.uid)
except FacebookProfile.DoesNotExist:
profile = FacebookProfile.objects.create(user=request.user,
uid=request.facebook.uid)
return HttpResponseRedirect(_get_next(request))
def logout(request, redirect_url=None):
"""
Logs the user out of django. This is only a wrapper around
django.contrib.auth.logout. Logging users out of Facebook for instance
should be done like described in the developer wiki on facebook.
http://wiki.developers.facebook.com/index.php/Connect/Authorization_Websites#Logging_Out_Users
"""
auth_logout(request)
url = redirect_url or getattr(settings, 'LOGOUT_REDIRECT_URL', '/')
return HttpResponseRedirect(url)
def twitter(request, account_inactive_template='socialregistration/account_inactive.html',
extra_context=dict()):
"""
Actually setup/login an account relating to a twitter user after the oauth
process is finished successfully
"""
client = OAuthTwitter(
request, settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET_KEY,
settings.TWITTER_REQUEST_TOKEN_URL,
)
user_info = client.get_user_info()
if request.user.is_authenticated():
# Handling already logged in users connecting their accounts
try:
profile = TwitterProfile.objects.get(twitter_id=user_info['id'])
except TwitterProfile.DoesNotExist: # There can only be one profile!
profile = TwitterProfile.objects.create(user=request.user, twitter_id=user_info['id'])
return HttpResponseRedirect(_get_next(request))
user = authenticate(twitter_id=user_info['id'])
if user is None:
profile = TwitterProfile(twitter_id=user_info['id'])
user = User()
request.session['socialregistration_profile'] = profile
request.session['socialregistration_user'] = user
request.session['next'] = _get_next(request)
return HttpResponseRedirect(reverse('socialregistration_setup'))
if not user.is_active:
return render_to_response(
account_inactive_template,
extra_context,
context_instance=RequestContext(request)
)
login(request, user)
return HttpResponseRedirect(_get_next(request))
def oauth_redirect(request, consumer_key=None, secret_key=None,
request_token_url=None, access_token_url=None, authorization_url=None,
callback_url=None, parameters=None):
"""
View to handle the OAuth based authentication redirect to the service provider
"""
request.session['next'] = _get_next(request)
client = OAuthClient(request, consumer_key, secret_key,
request_token_url, access_token_url, authorization_url, callback_url, parameters)
return client.get_redirect()
def oauth_callback(request, consumer_key=None, secret_key=None,
request_token_url=None, access_token_url=None, authorization_url=None,
callback_url=None, template='socialregistration/oauthcallback.html',
extra_context=dict(), parameters=None):
"""
View to handle final steps of OAuth based authentication where the user
gets redirected back to from the service provider
"""
client = OAuthClient(request, consumer_key, secret_key, request_token_url,
access_token_url, authorization_url, callback_url, parameters)
extra_context.update(dict(oauth_client=client))
if not client.is_valid():
return HttpResponseRedirect(reverse('login'))
# We're redirecting to the setup view for this oauth service
return HttpResponseRedirect(reverse(client.callback_url))
def openid_redirect(request):
"""
Redirect the user to the openid provider
"""
request.session['next'] = _get_next(request)
openid_provider = request.GET.get('openid_provider', '').strip()
request.session['openid_provider'] = openid_provider
client = OpenID(
request,
'http%s://%s%s' % (
_https(),
Site.objects.get_current().domain,
reverse('openid_callback')
),
openid_provider
)
try:
return client.get_redirect()
except DiscoveryFailure:
request.session['openid_error'] = True
return HttpResponseRedirect(settings.LOGIN_URL)
def openid_callback(request, template='socialregistration/openid.html',
extra_context=dict(), account_inactive_template='socialregistration/account_inactive.html'):
"""
Catches the user when he's redirected back from the provider to our site
"""
client = OpenID(
request,
'http%s://%s%s' % (
_https(),
Site.objects.get_current().domain,
reverse('openid_callback')
),
request.session.get('openid_provider')
)
try:
request_args = util.normalDict(request.GET)
if request.method == 'POST':
request_args.update(util.normalDict(request.POST))
if request_args:
client.complete()
c = client.consumer
return_to = util.getViewURL(request, openid_callback)
response = client.result
ax_items = {}
if response.status == consumer.SUCCESS:
provider = request.session.get('openid_provider')
# Set the schema uri depending on who the openid provier is:
# request only name and email by default (same as Google schemas):
schemas = GoogleOpenIDSchemas()
if 'yahoo' in provider:
schemas = YahooOpenIDSchemas()
if 'myopenid' in provider:
schemas = MyOpenIDSchemas()
ax_response = {}
ax_response = ax.FetchResponse.fromSuccessResponse(response)
if ax_response:
# Name and email schemas are always set, but not others so check if they are not empty first:
birth_date = zip = gender = []
if schemas.birth_date_schema:
birth_date = ax_response.get(schemas.birth_date_schema)
if schemas.zip_schema:
zip = ax_response.get(schemas.zip_schema)
if schemas.gender_schema:
gender = ax_response.get(schemas.gender_schema)
ax_items = {
'display_name': ax_response.get(schemas.name_schema),
'email': ax_response.get(schemas.email_schema),
'birth_date': birth_date,
'home_zip': zip,
'gender': gender,
}
request.session['ax_items'] = ax_items
except Exception, e:
pass
if client.is_valid():
identity = client.result.identity_url
if request.user.is_authenticated():
# Handling already logged in users just connecting their accounts
try:
profile = OpenIDProfile.objects.get(identity=identity)
except OpenIDProfile.DoesNotExist: # There can only be one profile with the same identity
profile = OpenIDProfile.objects.create(user=request.user,
identity=identity)
return HttpResponseRedirect(_get_next(request))
user = authenticate(identity=identity)
if user is None:
request.session['socialregistration_user'] = User()
request.session['socialregistration_profile'] = OpenIDProfile(
identity=identity
)
return HttpResponseRedirect(reverse('socialregistration_setup'))
if not user.is_active:
return render_to_response(
account_inactive_template,
extra_context,
context_instance=RequestContext(request)
)
login(request, user)
return HttpResponseRedirect(_get_next(request))
return HttpResponseRedirect(reverse('login'))
| mit | 469,264,267,113,633,500 | 35.73107 | 109 | 0.643091 | false |
emulbreh/shrubbery | shrubbery/db/utils.py | 1 | 11220 | import re
from django.db import models
from shrubbery.utils.text import camel_case
def no_related_name(hidden=False):
no_related_name._next += 1
name = "_no_related_name_%%(class)s_%s" % (no_related_name._next)
if hidden:
name += '+'
return name
no_related_name._next = 0
def _remove_related_accessors(sender, **kwargs):
for attr in dir(sender):
if attr.startswith('_no_related_name_'):
# delete() requires related descriptors - stupid multi-manager code
#delattr(sender, attr)
pass
models.signals.class_prepared.connect(_remove_related_accessors)
class ImplicitQMixin(object):
def as_q(self):
return models.Q()
def add_to_query(self, query, aliases=None):
query.add_q(self.as_q())
def __and__(self, other):
return self.as_q() & other
def __or__(self, other):
return self.as_q() | other
def __invert__(self):
return ~self.as_q()
class CompoundQ(object):
def __init__(self, objects, conjunction=True):
self.objects = objects
self.conjunction = conjunction
def __invert__(self):
return self.__class__([~obj for obj in self.objects], not self.conjunction)
def combine(self, other, conjunction):
if self.conjunction == conjunction:
# If the connection type is equal, we can avoid further nesting
objects = None
if isinstance(other, models.Q):
# If we already have a builtin Q, we can just add `other` one to it.
for index, obj in enumerate(self.objects):
if isinstance(obj, models.Q):
objects = self.objects[:]
if self.conjunction:
objects[index] &= other
else:
objects[index] |= other
break
elif isinstance(other, CompoundQ) and other.conjunction == conjunction:
# Two CompoundQ objects may be combined in a single new object without nesting
objects = self.objects + other.objects
if not objects:
objects = self.objects + [other]
return self.__class__(objects, conjunction)
return CompoundQ([self, other], conjunction)
def __and__(self, other):
return self.combine(other, True)
def __or__(self, other):
return self.combine(other, False)
def __rand__(self, other):
# Since '&' is supposed to be commutative
return self & other
def __ror__(self, other):
# Since '|' is supposed to be commutative
return self | other
@property
def connector(self):
return self.conjunction and models.sql.where.AND or models.sql.where.OR
def add_to_query(self, query, aliases):
clones = [query.clone().add_q(obj) for obj in self.objects[1:]]
query.add_q(self.objects[0])
for clone in clones:
query.combine(clone, self.connector)
def get_q(obj):
if isinstance(obj, dict):
return models.Q(**obj)
if hasattr(obj, 'add_to_query') or isinstance(obj, models.Q):
return obj
if hasattr(obj, 'as_q'):
return obj.as_q()
raise ValueError()
def get_model(obj, allow_import=False, proxy=True):
if isinstance(obj, models.base.ModelBase):
model = obj
elif isinstance(obj, models.Model):
model = obj.__class__
elif hasattr(obj, 'model'):
return obj.model
elif allow_import and isinstance(obj, str):
module_name, name = obj.rsplit('.')
module = import_module(module_name)
model = getattr(module, name)
else:
raise ValueError
if not proxy:
while model._meta.proxy:
model = model._meta.proxy_for_model
return model
def get_manager(obj):
if isinstance(obj, models.Manager):
return obj
if isinstance(obj, models.base.ModelBase):
return obj._default_manager
raise ValueError
def get_query_set(obj):
""" Returns a QuerySet for a given QuerySet, Manager, Model, or an object with a get_query_set() method. """
if isinstance(obj, models.query.QuerySet):
return obj
if isinstance(obj, models.Manager):
return obj.all()
if isinstance(obj, models.base.ModelBase):
return obj._default_manager.all()
if hasattr(obj, 'get_query_set'):
return obj.get_query_set()
raise ValueError
def fetch(qs, *args):
qs = get_query_set(qs)
for arg in args:
try:
q = get_q(arg)
except ValueError:
if callable(arg):
try:
arg = arg()
except qs.model.DoesNotExist:
continue
if isinstance(arg, Exception):
raise arg
return arg
try:
return qs.get(q)
except qs.model.DoesNotExist:
pass
raise qs.model.DoesNotExist()
def _collect_sub_models(model, abstract, proxy, virtual, direct, sub_models):
for subclass in model.__subclasses__():
if (abstract or not subclass._meta.abstract) and (proxy or not subclass._meta.proxy) and (virtual or not getattr(subclass._meta, 'virtual', False)):
sub_models.add(subclass)
if direct:
continue
_collect_sub_models(subclass, abstract, proxy, virtual, direct, sub_models)
return sub_models
_sub_models_cache = {}
def get_sub_models(model, abstract=False, proxy=False, virtual=False, direct=False):
cache_key = (model, abstract, proxy, direct)
if cache_key not in _sub_models_cache:
_sub_models_cache[cache_key] = _collect_sub_models(model, abstract, proxy, virtual, direct, set())
return _sub_models_cache[cache_key]
# django.db.models.sql.Query utilities
def force_empty(query):
query.add_extra(None, None, ("1=0",), None, None, None)
def remove_join(query, alias, traceless=False):
"""Removes the join from query.join_map, query.alias_map, and query.rev_join_map.
If `traceless=True`, removes it from query.tables and query.alias_refcount as well."""
t_ident = query.rev_join_map[alias]
jm_list = list(query.join_map[t_ident])
jm_list.remove(alias)
query.join_map[t_ident] = tuple(jm_list)
del query.rev_join_map[alias]
del query.alias_map[alias]
if traceless:
query.tables.remove(alias)
del query.alias_refcount[alias]
def forge_join(query, table, alias, lhs, lhs_alias, lhs_col, col, nullable=False, join_type=None):
"""Updates query.join_map, query.alias_map, and query.rev_join_map.
This can be used to replace an existing join or to create a new join."""
if not join_type:
join_type = query.INNER
query.alias_map[alias] = (table, alias, join_type, lhs_alias, lhs_col, col, nullable)
t_ident = (lhs, table, lhs_col, col)
if t_ident in query.join_map:
query.join_map[t_ident] += (alias,)
else:
query.join_map[t_ident] = (alias,)
query.rev_join_map[alias] = t_ident
# Misc
def replace_text(pattern, replacement, model):
if isinstance(pattern, (unicode, str)):
pattern = re.compile(pattern)
fields = []
for field in model._meta.fields:
if isinstance(field, (models.TextField, models.CharField)):
fields.append(field.name)
for obj in get_query_set(model):
for field in fields:
val = getattr(obj, field)
if val and pattern.search(val):
val = pattern.sub(replacement, val)
setattr(obj, field, val)
obj.save()
def unordered_pairs(qs):
objects = list(qs.order_by())
for a in objects:
for b in objects:
if b.pk > a.pk:
yield a, b
def create_intermediate_model(cls, rel_name, attrs, bases=None, meta=None):
if not meta:
meta = {}
if not bases:
bases = (models.Model,)
meta.setdefault('app_label', cls._meta.app_label)
attrs['Meta'] = type('Meta', (object,), meta)
attrs.setdefault('__module__', cls.__module__)
return type("%s%s" % (cls.__name__, camel_case(rel_name, True)), bases, attrs)
def clean_slice(s, count_func, replace_none=False, allow_step=True):
start, stop, step = s.start, s.stop, s.step
if callable(count_func):
count = None
else:
count = count_func
if start is None:
if replace_none:
start = 0
elif start < 0:
if count is None:
count = count_func()
start = max(count + start, 0)
if stop is None:
if replace_none:
if count is None:
count = count_func()
stop = count
elif stop < 0:
if count is None:
count = count_func()
stop = max(count + stop, 0)
if step is None and replace_none:
step = 1
if step and allow_step is not True and step not in allow_step:
raise ValueError("unsupported slice.step")
return slice(start, stop, step)
def get_model_ref(model):
if isinstance(model, str):
return model
return "%s.%s" % (model._meta.app_label, model.__name__)
def get_app_path(module):
for app in settings.INSTALLED_APPS:
if app.startswith(module):
if app == module or module[len(app)] == '.':
return app
raise ValueError
def get_app_label(module):
return get_app_path(module).rsplit('.', 1)[-1]
_pending_reference_lookups = {}
def get_by_ref(s, callback, module=None, app_label=None, field=None):
if '@' in s:
model, module_name = s.split('@')
if module_name:
app_label = None
module = module_name
if '.' in name:
model, field = name.split('.')
else:
bits = s.rsplit('.', 3)
if len(bits) == 1:
model = bits[0]
elif len(bits) == 2:
app_label, model = bits
else:
app_label, model, field = bits
if module and not app_label:
app_label = get_app_label(module)
if app_label:
from django.db.models.loading import get_model
model = get_model(app_label, model)
else:
from django.db.models.loading import get_models
for m in get_model():
if m.__name__ == model:
model = m
break
if not model:
_pending_reference_lookups.setdefault((app_label, model), []).append((field, callback))
else:
_fire_ref_callback(model, field, callback)
def _fire_ref_callback(model, field, callback):
if field:
callback(model._meta.get_field(field))
else:
callback(model)
def _do_pending_reference_lookups(sender, **kwargs):
field, callback = _pending_reference_lookups.pop((sender._meta.app_label, sender.__name__), (None, None))
if callback:
_fire_ref_callback(sender, field, callback)
models.signals.class_prepared.connect(_do_pending_reference_lookups) | mit | 3,695,699,204,477,365,000 | 30.968661 | 156 | 0.582888 | false |
sql-machine-learning/sqlflow | python/runtime/pai/pai_ml/random_forest.py | 1 | 3027 | # Copyright 2020 The SQLFlow 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.
import six
from runtime import db
def get_train_random_forest_pai_cmd(model_name, data_table, model_attrs,
feature_column_names, label_name):
"""Get a command to submit a KMeans training task to PAI
Args:
model_name: model name on PAI
data_table: input data table name
model_attrs: model attributes for KMeans
feature_column_names: names of feature columns
label_name: name of the label column
Returns:
A string which is a PAI cmd
"""
# default use numTrees = 1
tree_num = model_attrs.get("tree_num", 1)
assert isinstance(tree_num, six.integer_types), \
"tree_num must be an integer"
feature_cols = ",".join(feature_column_names)
return '''pai -name randomforests -DinputTableName="%s" -DmodelName="%s"
-DlabelColName="%s" -DfeatureColNames="%s" -DtreeNum="%d"''' % (
data_table, model_name, label_name, feature_cols, tree_num)
def get_explain_random_forest_pai_cmd(datasource, model_name, data_table,
result_table, label_column):
"""Get a command to submit a PAI RandomForest explain task
Args:
datasource: current datasoruce
model_name: model name on PAI
data_table: input data table name
result_table: name of the result table, PAI will automatically
create this table
label_column: name of the label column
Returns:
A string which is a PAI cmd
"""
# NOTE(typhoonzero): for PAI random forests predicting, we can not load
# the TrainStmt since the model saving is fully done by PAI. We directly
# use the columns in SELECT statement for prediction, error will be
# reported by PAI job if the columns not match.
if not label_column:
return ("must specify WITH label_column when using "
"pai random forest to explain models")
conn = db.connect_with_data_source(datasource)
schema = db.get_table_schema(conn, data_table)
columns = [f[0] for f in schema]
conn.execute("DROP TABLE IF EXISTS %s;" % result_table)
return (
"""pai -name feature_importance -project algo_public """
"""-DmodelName="%s" -DinputTableName="%s" -DoutputTableName="%s" """
"""-DlabelColName="%s" -DfeatureColNames="%s" """
) % (model_name, data_table, result_table, label_column, ",".join(columns))
| apache-2.0 | 8,734,393,181,451,080,000 | 39.905405 | 79 | 0.663693 | false |
pawelmhm/splash | splash/html_element.py | 1 | 12235 | from __future__ import absolute_import
from functools import wraps
from splash.exceptions import DOMError
from splash.jsutils import escape_js
from splash.casperjs_utils import (
VISIBLE_JS_FUNC,
ELEMENT_INFO_JS,
FIELD_VALUE_JS,
FORM_VALUES_JS,
SET_FIELD_VALUE_JS
)
DIMENSIONS_JS_FUNC = """
(function(elem) {
var rect = elem.getClientRects()[0];
return {"x":rect.left, "y": rect.top, "width": rect.width, "height": rect.height}
})(%s)
"""
FETCH_TEXT_JS_FUNC = """
(function(elem) {
return (elem.textContent || elem.innerText || elem.value || '').trim();
})(%s)
"""
FILL_FORM_VALUES_JS = """
function (form, values, setFieldValue) {
Object.keys(values).forEach(function (name) {
var selector = "[name='" + name + "']";
setFieldValue(selector, values[name], form);
});
}
"""
def empty_strings_as_none(meth):
@wraps(meth)
def change_return_value_to_none_for_empty_string(*args, **kwargs):
retval = meth(*args, **kwargs)
return None if retval == '' else retval
return change_return_value_to_none_for_empty_string
def escape_js_args(*args):
return ','.join([
arg.element_js if isinstance(arg, HTMLElement) else escape_js(arg)
for arg in args
])
class HTMLElement(object):
""" Class for manipulating DOM HTML Element """
def __init__(self, tab, storage, event_handlers_storage, events_storage,
node_id):
self.tab = tab
self.storage = storage
self.event_handlers_storage = event_handlers_storage
self.events_storage = events_storage
self.id = node_id
self.element_js = self.get_element_js()
msg = "HTMLElement is created with id=%s in object %s" % (
self.id, self.element_js
)
self.tab.logger.log(msg, min_level=4)
def get_element_js(self):
""" Return JS object to which the element is assigned. """
return 'window["%s"]["%s"]' % (self.storage.name, self.id)
def assert_element_exists(self):
""" Raise exception if the element no longer exists in DOM. """
if not self.exists():
raise DOMError({
'type': DOMError.NOT_IN_DOM_ERROR,
'message': "Element no longer exists in DOM"
})
def assert_node_type(self, node_type):
"""
Raise an exception if the type of the element doesn't match node_type.
"""
actual_type = self.node_property('nodeName').lower()
if actual_type != node_type.lower():
raise DOMError({
'type': DOMError.NOT_COMPATIBLE_NODE_ERROR,
'message': "Node should be {!r}, but got {!r}".format(
node_type, actual_type)
})
def exists(self):
""" Return flag indicating whether element is in DOM """
exists = self.tab.evaljs("document.contains(%s)" % self.element_js)
return bool(exists)
@empty_strings_as_none
def node_property(self, property_name):
""" Return value of the specified property of the element """
return self.tab.evaljs(u"{element}[{property}]".format(
element=self.element_js,
property=escape_js(property_name)
))
@empty_strings_as_none
def set_node_property(self, property_name, property_value):
""" Set value of the specified property of the element """
return self.tab.evaljs(u"{element}[{property}] = {value}".format(
element=self.element_js,
property=escape_js(property_name),
value=escape_js(property_value)
))
def get_node_style(self, property_name):
""" Get value of the style property of the element """
return self.tab.evaljs(u"{element}.style[{property}]".format(
element=self.element_js,
property=escape_js(property_name),
))
def set_node_style(self, property_name, property_value):
""" Set value of the style property of the element """
return self.tab.evaljs(u"{element}.style[{property}] = {value}".format(
element=self.element_js,
property=escape_js(property_name),
value=escape_js(property_value)
))
def node_method(self, method_name):
""" Return function which calls the specified method of the element """
@empty_strings_as_none
def call(*args):
return self.tab.evaljs(u"{element}[{method}]({args})".format(
element=self.element_js,
method=escape_js(method_name),
args=escape_js_args(*args)
))
return call
def mouse_click(self, x=0, y=0, button="left"):
""" Click on the element """
self.assert_element_exists()
dimensions = self._get_dimensions()
self.tab.mouse_click(dimensions["x"] + x, dimensions["y"] + y, button)
def mouse_hover(self, x=0, y=0):
""" Hover over the element """
self.assert_element_exists()
dimensions = self._get_dimensions()
self.tab.mouse_hover(dimensions["x"] + x, dimensions["y"] + y)
def _get_dimensions(self):
return self.tab.evaljs(DIMENSIONS_JS_FUNC % self.element_js)
def styles(self):
""" Return computed styles of the element """
return self.tab.evaljs("getComputedStyle(%s)" % self.element_js)
def bounds(self):
""" Return bounding client rectangle of the element"""
return self.tab.evaljs("%s.getBoundingClientRect()" % self.element_js)
def png(self, width=None, scale_method=None, pad=None):
""" Return screenshot of the element in PNG format.
Optional `pad` can be provided which can be in two formats:
- integer containing amount of pad for all sides
(top, left, bottom, right)
- tuple with `left`, `top`, `right`, `bottom` integer
values for padding
Padding value can be negative which means that the image will be cropped.
"""
if not self.exists() or not self.visible():
return None
region = _bounds_to_region(self.bounds(), pad)
return self.tab.png(width, region=region, scale_method=scale_method)
def jpeg(self, width=None, scale_method=None, quality=None, pad=None):
""" Return screenshot of the element in JPEG format.
Optional `pad` can be provided which can be in two formats:
- integer containing amount of pad for all sides
(top, left, bottom, right)
- tuple with `left`, `top`, `right`, `bottom` integer
values for padding
Padding value can be negative which means that the image will be cropped.
"""
if not self.exists() or not self.visible():
return None
region = _bounds_to_region(self.bounds(), pad)
return self.tab.jpeg(width, region=region, scale_method=scale_method,
quality=quality)
def visible(self):
""" Return flag indicating whether element is visible """
self.assert_element_exists()
return self.tab.evaljs(u"({visible_func})({element})".format(
visible_func=VISIBLE_JS_FUNC,
element=self.element_js
))
def text(self):
""" Return text of the element """
return self.tab.evaljs(FETCH_TEXT_JS_FUNC % self.element_js)
def info(self):
""" Return information about the element """
return self.tab.evaljs(u"({element_info_func})({element}, {visible_func})".format(
element_info_func=ELEMENT_INFO_JS,
element=self.element_js,
visible_func=VISIBLE_JS_FUNC
))
def field_value(self):
""" Return the value of the element if it is a field """
return self.tab.evaljs(u"({field_value_func})({element})".format(
field_value_func=FIELD_VALUE_JS,
element=self.element_js
))
def form_values(self, values='auto'):
""" Return all values of the element if it is a form"""
self.assert_node_type('form')
return self.tab.evaljs(u"({form_values_func})({element}, {values}, {field_value_func})".format(
form_values_func=FORM_VALUES_JS,
field_value_func=FIELD_VALUE_JS,
values=escape_js(values),
element=self.element_js
))
def fill(self, values):
""" Fill the values of the element """
return self.tab.evaljs(u"({fill_form_values_func})({element}, {values}, {set_field_value})".format(
fill_form_values_func=FILL_FORM_VALUES_JS,
element=self.element_js,
values=escape_js(values),
set_field_value=SET_FIELD_VALUE_JS
))
def send_keys(self, text):
""" Send key events to the element separated by whitespaces """
if not self.focused():
self.mouse_click()
self.tab.send_keys(text)
def send_text(self, text):
""" Send text to the element """
if not self.focused():
self.mouse_click()
self.tab.send_text(text)
def focused(self):
""" Return True if the current element is focused """
return self.tab.evaljs(
"{} === document.activeElement".format(self.element_js)
)
def set_event_handler(self, event_name, handler):
""" Set on-event type event listeners to the element """
handler_id = self.event_handlers_storage.add(handler)
func = u"window[{storage_name}][{func_id}]".format(
storage_name=escape_js(self.event_handlers_storage.name),
func_id=escape_js(handler_id),
)
self.tab.evaljs(u"{element}['on' + {event_name}] = {func}".format(
element=self.element_js,
event_name=escape_js(event_name),
func=func
))
return handler_id
def unset_event_handler(self, event_name, handler_id):
""" Remove on-event type event listeners from the element """
self.tab.evaljs(u"{element}['on' + {event_name}] = null".format(
element=self.element_js,
event_name=escape_js(event_name),
))
self.event_handlers_storage.remove(handler_id)
def add_event_handler(self, event_name, handler, options=None):
""" Add event listeners to the element for the specified event """
handler_id = self.event_handlers_storage.add(handler)
func = u"window[{storage_name}][{func_id}]".format(
storage_name=escape_js(self.event_handlers_storage.name),
func_id=escape_js(handler_id),
)
self.tab.evaljs(u"{element}.addEventListener({event_name}, {func}, {options})".format(
element=self.element_js,
event_name=escape_js(event_name),
func=func,
options=escape_js(options)
))
return handler_id
def remove_event_handler(self, event_name, handler_id):
"""
Remove event listeners from the element for the specified event
and handler.
"""
func = u"window[{storage_name}][{func_id}]".format(
storage_name=escape_js(self.event_handlers_storage.name),
func_id=escape_js(handler_id),
)
self.tab.evaljs(u"{element}.removeEventListener({event_name}, {func})".format(
element=self.element_js,
event_name=escape_js(event_name),
func=func
))
self.event_handlers_storage.remove(handler_id)
def submit(self):
""" Submit form element """
self.assert_node_type('form')
self.node_method('submit')()
def _padded(region, pad):
"""
>>> _padded([1, 1, 4, 4], [0, 1, 2 ,3])
(1, 0, 6, 7)
>>> _padded([1, 1, 4, 4], 2)
(-1, -1, 6, 6)
"""
if not pad:
return region
if isinstance(pad, (int, float)):
pad = (pad, pad, pad, pad)
return (
region[0] - pad[0],
region[1] - pad[1],
region[2] + pad[2],
region[3] + pad[3]
)
def _bounds_to_region(bounds, pad):
region = bounds["left"], bounds["top"], bounds["right"], bounds["bottom"]
return _padded(region, pad)
| bsd-3-clause | -242,330,115,481,414,270 | 33.758523 | 107 | 0.586105 | false |
wdecoster/nanoget | nanoget/extraction_functions.py | 1 | 18527 | import logging
from functools import reduce
import nanoget.utils as ut
import pandas as pd
import sys
import pysam
import re
from Bio import SeqIO
import concurrent.futures as cfutures
from itertools import repeat
def process_summary(summaryfile, **kwargs):
"""Extracting information from an albacore summary file.
Only reads which have a >0 length are returned.
The fields below may or may not exist, depending on the type of sequencing performed.
Fields 1-14 are for 1D sequencing.
Fields 1-23 for 2D sequencing.
Fields 24-27, 2-5, 22-23 for 1D^2 (1D2) sequencing
Fields 28-38 for barcoded workflows
1 filename
2 read_id
3 run_id
4 channel
5 start_time
6 duration
7 num_events
8 template_start
9 num_events_template
10 template_duration
11 num_called_template
12 sequence_length_template
13 mean_qscore_template
14 strand_score_template
15 complement_start
16 num_events_complement
17 complement_duration
18 num_called_complement
19 sequence_length_complement
20 mean_qscore_complement
21 strand_score_complement
22 sequence_length_2d
23 mean_qscore_2d
24 filename1
25 filename2
26 read_id1
27 read_id2
28 barcode_arrangement
29 barcode_score
30 barcode_full_arrangement
31 front_score
32 rear_score
33 front_begin_index
34 front_foundseq_length
35 rear_end_index
36 rear_foundseq_length
37 kit
38 variant
"""
logging.info("Nanoget: Collecting metrics from summary file {} for {} sequencing".format(
summaryfile, kwargs["readtype"]))
ut.check_existance(summaryfile)
if kwargs["readtype"] == "1D":
cols = ["channel", "start_time", "duration",
"sequence_length_template", "mean_qscore_template"]
elif kwargs["readtype"] in ["2D", "1D2"]:
cols = ["channel", "start_time", "duration", "sequence_length_2d", "mean_qscore_2d"]
if kwargs["barcoded"]:
cols.append("barcode_arrangement")
logging.info("Nanoget: Extracting metrics per barcode.")
try:
datadf = pd.read_csv(
filepath_or_buffer=summaryfile,
sep="\t",
usecols=cols,
)
except ValueError:
logging.error("Nanoget: did not find expected columns in summary file {}:\n {}".format(
summaryfile, ', '.join(cols)))
sys.exit("ERROR: expected columns in summary file {} not found:\n {}".format(
summaryfile, ', '.join(cols)))
if kwargs["barcoded"]:
datadf.columns = ["channelIDs", "time", "duration", "lengths", "quals", "barcode"]
else:
datadf.columns = ["channelIDs", "time", "duration", "lengths", "quals"]
logging.info("Nanoget: Finished collecting statistics from summary file {}".format(summaryfile))
return ut.reduce_memory_usage(datadf.loc[datadf["lengths"] != 0].copy())
def check_bam(bam, samtype="bam"):
"""Check if bam file is valid.
Bam file should:
- exists
- has an index (create if necessary)
- is sorted by coordinate
- has at least one mapped read
"""
ut.check_existance(bam)
samfile = pysam.AlignmentFile(bam, "rb")
if not samfile.has_index():
pysam.index(bam)
samfile = pysam.AlignmentFile(bam, "rb") # Need to reload the samfile after creating index
logging.info("Nanoget: No index for bam file could be found, created index.")
if not samfile.header['HD']['SO'] == 'coordinate':
logging.error("Nanoget: Bam file {} not sorted by coordinate!.".format(bam))
sys.exit("Please use a bam file sorted by coordinate.")
if samtype == "bam":
logging.info("Nanoget: Bam file {} contains {} mapped and {} unmapped reads.".format(
bam, samfile.mapped, samfile.unmapped))
if samfile.mapped == 0:
logging.error("Nanoget: Bam file {} does not contain aligned reads.".format(bam))
sys.exit("FATAL: not a single read was mapped in bam file {}".format(bam))
return samfile
def process_ubam(bam, **kwargs):
"""Extracting metrics from unaligned bam format
Extracting lengths
"""
logging.info("Nanoget: Starting to collect statistics from ubam file {}.".format(bam))
samfile = pysam.AlignmentFile(bam, "rb", check_sq=False)
if not samfile.has_index():
pysam.index(bam)
# Need to reload the samfile after creating index
samfile = pysam.AlignmentFile(bam, "rb", check_sq=False)
logging.info("Nanoget: No index for bam file could be found, created index.")
datadf = pd.DataFrame(
data=[(read.query_name, ut.ave_qual(read.query_qualities), read.query_length)
for read in samfile.fetch(until_eof=True)],
columns=["readIDs", "quals", "lengths"]) \
.dropna(axis='columns', how='all') \
.dropna(axis='index', how='any')
logging.info("Nanoget: ubam {} contains {} reads.".format(
bam, datadf["lengths"].size))
return ut.reduce_memory_usage(datadf)
def process_bam(bam, **kwargs):
"""Combines metrics from bam after extraction.
Processing function: calls pool of worker functions
to extract from a bam file the following metrics:
-lengths
-aligned lengths
-qualities
-aligned qualities
-mapping qualities
-edit distances to the reference genome scaled by read length
Returned in a pandas DataFrame
"""
logging.info("Nanoget: Starting to collect statistics from bam file {}.".format(bam))
samfile = check_bam(bam)
chromosomes = samfile.references
if len(chromosomes) > 100 or kwargs["huge"]:
logging.info("Nanoget: lots of contigs (>100) or --huge, not running in separate processes")
datadf = pd.DataFrame(
data=extract_from_bam(bam, None, kwargs["keep_supp"]),
columns=["readIDs", "quals", "aligned_quals", "lengths",
"aligned_lengths", "mapQ", "percentIdentity"]) \
.dropna(axis='columns', how='all') \
.dropna(axis='index', how='any')
else:
unit = chromosomes
with cfutures.ProcessPoolExecutor(max_workers=kwargs["threads"]) as executor:
datadf = pd.DataFrame(
data=[res for sublist in executor.map(extract_from_bam,
repeat(bam),
unit,
repeat(kwargs["keep_supp"]))
for res in sublist],
columns=["readIDs", "quals", "aligned_quals", "lengths",
"aligned_lengths", "mapQ", "percentIdentity"]) \
.dropna(axis='columns', how='all') \
.dropna(axis='index', how='any')
logging.info(f"Nanoget: bam {bam} contains {datadf['lengths'].size} primary alignments.")
return ut.reduce_memory_usage(datadf)
def process_cram(cram, **kwargs):
"""Combines metrics from cram after extraction.
Processing function: calls pool of worker functions
to extract from a cram file the following metrics:
-lengths
-aligned lengths
-qualities
-aligned qualities
-mapping qualities
-edit distances to the reference genome scaled by read length
Returned in a pandas DataFrame
"""
logging.info("Nanoget: Starting to collect statistics from cram file {}.".format(cram))
samfile = check_bam(cram, samtype="cram")
chromosomes = samfile.references
if len(chromosomes) > 100:
unit = [None]
logging.info("Nanoget: lots of contigs (>100), not running in separate processes")
else:
unit = chromosomes
with cfutures.ProcessPoolExecutor(max_workers=kwargs["threads"]) as executor:
datadf = pd.DataFrame(
data=[res for sublist in executor.map(extract_from_bam,
repeat(cram), unit, repeat(kwargs["keep_supp"]))
for res in sublist],
columns=["readIDs", "quals", "aligned_quals", "lengths",
"aligned_lengths", "mapQ", "percentIdentity"]) \
.dropna(axis='columns', how='all') \
.dropna(axis='index', how='any')
logging.info(f"Nanoget: cram {cram} contains {datadf['lengths'].size} primary alignments.")
return ut.reduce_memory_usage(datadf)
def extract_from_bam(bam, chromosome, keep_supplementary=True):
"""Extracts metrics from bam.
Worker function per chromosome
loop over a bam file and create list with tuples containing metrics:
-qualities
-aligned qualities
-lengths
-aligned lengths
-mapping qualities
-edit distances to the reference genome scaled by read length
"""
samfile = pysam.AlignmentFile(bam, "rb")
if keep_supplementary:
return [
(read.query_name,
ut.ave_qual(read.query_qualities),
ut.ave_qual(read.query_alignment_qualities),
read.query_length,
read.query_alignment_length,
read.mapping_quality,
get_pID(read))
for read in samfile.fetch(reference=chromosome, multiple_iterators=True)
if not read.is_secondary and not read.is_unmapped]
else:
return [
(read.query_name,
ut.ave_qual(read.query_qualities),
ut.ave_qual(read.query_alignment_qualities),
read.query_length,
read.query_alignment_length,
read.mapping_quality,
get_pID(read))
for read in samfile.fetch(reference=chromosome, multiple_iterators=True)
if not read.is_secondary and not read.is_unmapped and not read.is_supplementary]
def get_pID(read):
"""Return the percent identity of a read.
based on the NM tag if present,
if not calculate from MD tag and CIGAR string
read.query_alignment_length can be zero in the case of ultra long reads aligned with minimap2 -L
"""
match = reduce(lambda x, y: x + y[1] if y[0] in (0, 7, 8) else x, read.cigartuples, 0)
ins = reduce(lambda x, y: x + y[1] if y[0] == 1 else x, read.cigartuples, 0)
delt = reduce(lambda x, y: x + y[1] if y[0] == 2 else x, read.cigartuples, 0)
alignment_length = match + ins + delt
try:
return (1 - read.get_tag("NM") / alignment_length) * 100
except KeyError:
try:
return 100 * (1 - (parse_MD(read.get_tag("MD")) + parse_CIGAR(read.cigartuples)) /
alignment_length)
except KeyError:
return None
except ZeroDivisionError:
return None
def parse_MD(MDlist):
"""Parse MD string to get number of mismatches and deletions."""
return sum([len(item) for item in re.split('[0-9^]', MDlist)])
def parse_CIGAR(cigartuples):
"""Count the insertions in the read using the CIGAR string."""
return sum([item[1] for item in cigartuples if item[0] == 1])
def handle_compressed_input(inputfq, file_type="fastq"):
"""Return handles from compressed files according to extension.
Check for which fastq input is presented and open a handle accordingly
Can read from compressed files (gz, bz2, bgz) or uncompressed
Relies on file extensions to recognize compression
"""
ut.check_existance(inputfq)
if inputfq.endswith(('.gz', 'bgz')):
import gzip
logging.info("Nanoget: Decompressing gzipped {} {}".format(file_type, inputfq))
return gzip.open(inputfq, 'rt')
elif inputfq.endswith('.bz2'):
import bz2
logging.info("Nanoget: Decompressing bz2 compressed {} {}".format(file_type, inputfq))
return bz2.open(inputfq, 'rt')
elif inputfq.endswith(('.fastq', '.fq', 'fasta', '.fa', '.fas')):
return open(inputfq, 'r')
else:
logging.error("INPUT ERROR: Unrecognized file extension {}".format(inputfq))
sys.exit('INPUT ERROR:\nUnrecognized file extension in {}\n'
'Supported are gz, bz2, bgz, fastq, fq, fasta, fa and fas'.format(inputfq))
def process_fasta(fasta, **kwargs):
"""Combine metrics extracted from a fasta file."""
logging.info("Nanoget: Starting to collect statistics from a fasta file.")
inputfasta = handle_compressed_input(fasta, file_type="fasta")
return ut.reduce_memory_usage(pd.DataFrame(
data=[len(rec) for rec in SeqIO.parse(inputfasta, "fasta")],
columns=["lengths"]
).dropna())
def process_fastq_plain(fastq, **kwargs):
"""Combine metrics extracted from a fastq file."""
logging.info("Nanoget: Starting to collect statistics from plain fastq file.")
inputfastq = handle_compressed_input(fastq)
return ut.reduce_memory_usage(pd.DataFrame(
data=[res for res in extract_from_fastq(inputfastq) if res],
columns=["quals", "lengths"]
).dropna())
def extract_from_fastq(fq):
"""Extract metrics from a fastq file.
Return average quality and read length
"""
for rec in SeqIO.parse(fq, "fastq"):
yield ut.ave_qual(rec.letter_annotations["phred_quality"]), len(rec)
def stream_fastq_full(fastq, threads):
"""Generator for returning metrics extracted from fastq.
Extract from a fastq file:
-readname
-average and median quality
-read_lenght
"""
logging.info("Nanoget: Starting to collect full metrics from plain fastq file.")
inputfastq = handle_compressed_input(fastq)
with cfutures.ProcessPoolExecutor(max_workers=threads) as executor:
for results in executor.map(extract_all_from_fastq, SeqIO.parse(inputfastq, "fastq")):
yield results
logging.info("Nanoget: Finished collecting statistics from plain fastq file.")
def extract_all_from_fastq(rec):
"""Extract metrics from a fastq file.
Return identifier, read length, average quality and median quality
"""
return (rec.id,
len(rec),
ut.ave_qual(rec.letter_annotations["phred_quality"]),
None)
def info_to_dict(info):
"""Get the key-value pairs from the albacore/minknow fastq description and return dict"""
return {field.split('=')[0]: field.split('=')[1] for field in info.split(' ')[1:]}
def process_fastq_rich(fastq, **kwargs):
"""Extract metrics from a richer fastq file.
Extract information from fastq files generated by albacore or MinKNOW,
containing richer information in the header (key-value pairs)
read=<int> [72]
ch=<int> [159]
start_time=<timestamp> [2016-07-15T14:23:22Z] # UTC ISO 8601 ISO 3339 timestamp
Z indicates UTC time, T is the delimiter between date expression and time expression
dateutil.parser.parse("2016-07-15T14:23:22Z") imported as dparse
-> datetime.datetime(2016, 7, 15, 14, 23, 22, tzinfo=tzutc())
"""
logging.info("Nanoget: Starting to collect statistics from rich fastq file.")
inputfastq = handle_compressed_input(fastq)
res = []
for record in SeqIO.parse(inputfastq, "fastq"):
try:
read_info = info_to_dict(record.description)
res.append(
(ut.ave_qual(record.letter_annotations["phred_quality"]),
len(record),
read_info["ch"],
read_info["start_time"],
read_info["runid"]))
except KeyError:
logging.error("Nanoget: keyerror when processing record {}".format(record.description))
sys.exit("Unexpected fastq identifier:\n{}\n\n \
missing one or more of expected fields 'ch', 'start_time' or 'runid'".format(
record.description))
df = pd.DataFrame(
data=res,
columns=["quals", "lengths", "channelIDs", "timestamp", "runIDs"]).dropna()
df["channelIDs"] = df["channelIDs"].astype("int64")
return ut.reduce_memory_usage(df)
def readfq(fp):
"""Generator function adapted from https://github.com/lh3/readfq."""
last = None # this is a buffer keeping the last unprocessed line
while True: # mimic closure; is it a bad idea?
if not last: # the first record or a record following a fastq
for l in fp: # search for the start of the next record
if l[0] in '>@': # fasta/q header line
last = l[:-1] # save this line
break
if not last:
break
name, seqs, last = last[1:].partition(" ")[0], [], None
for l in fp: # read the sequence
if l[0] in '@+>':
last = l[:-1]
break
seqs.append(l[:-1])
if not last or last[0] != '+': # this is a fasta record
yield name, ''.join(seqs), None # yield a fasta record
if not last:
break
else: # this is a fastq record
seq, leng, seqs = ''.join(seqs), 0, []
for l in fp: # read the quality
seqs.append(l[:-1])
leng += len(l) - 1
if leng >= len(seq): # have read enough quality
last = None
yield name, seq, ''.join(seqs) # yield a fastq record
break
if last: # reach EOF before reading enough quality
yield name, seq, None # yield a fasta record instead
break
def fq_minimal(fq):
"""Minimal fastq metrics extractor.
Quickly parse a fasta/fastq file - but makes expectations on the file format
There will be dragons if unexpected format is used
Expects a fastq_rich format, but extracts only timestamp and length
"""
try:
while True:
time = next(fq)[1:].split(" ")[4][11:-1]
length = len(next(fq))
next(fq)
next(fq)
yield time, length
except StopIteration:
yield None
def process_fastq_minimal(fastq, **kwargs):
"""Swiftly extract minimal features (length and timestamp) from a rich fastq file"""
infastq = handle_compressed_input(fastq)
try:
df = pd.DataFrame(
data=[rec for rec in fq_minimal(infastq) if rec],
columns=["timestamp", "lengths"]
)
except IndexError:
logging.error("Fatal: Incorrect file structure for fastq_minimal")
sys.exit("Error: file does not match expected structure for fastq_minimal")
return ut.reduce_memory_usage(df)
| gpl-3.0 | -1,263,447,835,598,286,300 | 38.169133 | 100 | 0.616344 | false |
richteer/wambda | creature.py | 1 | 2038 |
class Creature():
_maxhealth = 1
_health = 1
_speed = 1
_ch = '='
_zone = None
_gold = 0
_name = "wat"
_initiative = 0
_x = 0
_y = 0
def __init__(self, hp, speed, ch, name):
self._health = hp
self._maxhealth = hp
self._speed = speed
self._ch = ch
self._name = name
def _set_pos(self, y,x):
self._x = x
self._y = y
def _tick(self):
for c in self._zone.creatures:
if c.__class__.__name__ == "Player":
p = c
if not p:
return None
dx = self._x - p._x
dy = self._y - p._y
if (dx == 0 and abs(dy) == 1) or (abs(dx) == 1 and dy == 0):
p._takedamage(1, source=self)
elif abs(dx) > abs(dy):
if dx < 0:
self.move_right()
else:
self.move_left()
elif abs(dx) < abs(dy):
if dy < 0:
self.move_down()
else:
self.move_up()
def _move(self, y, x):
self._zone.tiles[self._y][self._x].creature = None
self._x += x
self._y += y
self._zone.tiles[self._y][self._x].creature = self
def _trymove(self, y, x):
return not (self._zone.tiles[y][x].solid or self._zone.tiles[y][x].creature)
def _takedamage(self, amount, source=None):
self._health -= amount
if self._health == 0:
self._zone.tiles[self._y][self._x].creature = None
return True
return False
def move_left(self):
if self._trymove(self._y, self._x-self._speed):
self._move(0,-self._speed)
def move_right(self):
if self._trymove(self._y, self._x+self._speed):
self._move(0,self._speed)
def move_up(self):
if self._trymove(self._y-self._speed, self._x):
self._move(-self._speed,0)
def move_down(self):
if self._trymove(self._y+self._speed, self._x):
self._move(self._speed,0)
def pickup(self):
it = self._zone.tiles[self._y][self._x].item
self._zone.tiles[self._y][self._x].item = None
if it:
if hasattr(it, "gold"):
self._gold += it.gold
else:
setattr(self, it.func.__name__, it.func)
else:
pass
# TODO: This
def gencreatures(zone):
c = Creature(2,1,'E',"Emu")
c._initiative = 1
c._set_pos(13,7)
zone.add_creature(c)
| gpl-2.0 | 6,510,516,860,936,087,000 | 18.786408 | 78 | 0.580471 | false |
littlecodersh/itchatmp | itchatmp/controllers/mpapi/mp/users.py | 1 | 8744 | ''' This package is for user managing in wechat mp
1. What can we do?
- set tags and everything around them
- get all your users (of course not at a time) or get detailed information of one
- set blacklist and everything around it
3. I alse listed API list for you:
- TAGS
create_tag
get_tags
update_tag
delete_tag
get_users_of_tag
add_users_into_tag
delete_users_of_tag
get_tags_of_user
- USER INFO
get_users
get_user_info
set_alias
- BLACKLIST
get_blacklist
add_users_into_blacklist
delete_users_of_blacklist
'''
import logging
from ..requests import requests
from itchatmp.utils import retry, encode_send_dict
from itchatmp.config import SERVER_URL
from itchatmp.content import (
IMAGE, VOICE, VIDEO, MUSIC, TEXT, NEWS, CARD)
from itchatmp.returnvalues import ReturnValue
logger = logging.getLogger('itchatmp')
def create_tag(name, id=None, accessToken=None):
''' create_tag
* id is for qy only
'''
data = encode_send_dict({'tag': {'name': name}})
if data is None:
return ReturnValue({'errcode': -10001})
r = requests.post('%s/cgi-bin/tags/create?access_token=%s'
% (SERVER_URL, accessToken), data=data)
def _wrap_result(result):
result = ReturnValue(result.json())
if 'tag' in result:
result['errcode'] = 0
return result
r._wrap_result = _wrap_result
return r
def get_tags(accessToken=None):
r = requests.get('%s/cgi-bin/tags/get?access_token=%s'
% (SERVER_URL, accessToken))
def _wrap_result(result):
result = ReturnValue(result.json())
if 'tags' in result:
result['errcode'] = 0
return result
r._wrap_result = _wrap_result
return r
def update_tag(id, name, accessToken=None):
data = encode_send_dict({'tag': {'name': name, 'id': id}})
if data is None:
return ReturnValue({'errcode': -10001})
r = requests.post('%s/cgi-bin/tags/update?access_token=%s'
% (SERVER_URL, accessToken), data=data)
def _wrap_result(result):
return ReturnValue(result.json())
r._wrap_result = _wrap_result
return r
def delete_tag(id, accessToken=None):
data = encode_send_dict({'tag': {'id': id}})
if data is None:
return ReturnValue({'errcode': -10001})
r = requests.post('%s/cgi-bin/tags/delete?access_token=%s'
% (SERVER_URL, accessToken), data=data)
def _wrap_result(result):
return ReturnValue(result.json())
r._wrap_result = _wrap_result
return r
def get_users_of_tag(id, nextOpenId='', accessToken=None):
data = encode_send_dict({'tagid': id, 'next_openid': nextOpenId})
if data is None:
return ReturnValue({'errcode': -10001})
r = requests.post('%s/cgi-bin/user/tag/get?access_token=%s'
% (SERVER_URL, accessToken), data=data)
def _wrap_result(result):
result = ReturnValue(result.json())
if 'count' in result:
result['errcode'] = 0
return result
r._wrap_result = _wrap_result
return r
def add_users_into_tag(id, userIdList=None, partyList=None, accessToken=None):
if not userIdList:
return ReturnValue({'errcode': 40035, 'errmsg': 'must have one userId'})
data = encode_send_dict({'openid_list': userIdList, 'tagid': id})
if data is None:
return ReturnValue({'errcode': -10001})
r = requests.post('%s/cgi-bin/tags/members/batchtagging?access_token=%s'
% (SERVER_URL, accessToken), data=data)
def _wrap_result(result):
return ReturnValue(result.json())
r._wrap_result = _wrap_result
return r
def delete_users_of_tag(id, userIdList=None, partyList=None, accessToken=None):
if not userIdList: return ReturnValue({'errcode': 40035, 'errmsg': 'must have one userId'})
data = encode_send_dict({'tagid': id, 'openid_list': userIdList})
if data is None: return ReturnValue({'errcode': -10001})
r = requests.post('%s/cgi-bin/tags/members/batchuntagging?access_token=%s'
% (SERVER_URL, accessToken), data=data)
def _wrap_result(result):
return ReturnValue(result.json())
r._wrap_result = _wrap_result
return r
def get_tags_of_user(userId, accessToken=None):
data = encode_send_dict({'openid': userId})
if data is None: return ReturnValue({'errcode': -10001})
r = requests.post('%s/cgi-bin/tags/getidlist?access_token=%s'
% (SERVER_URL, accessToken), data=data)
def _wrap_result(result):
result = ReturnValue(result.json())
if 'tagid_list' in result: result['errcode'] = 0
return result
r._wrap_result = _wrap_result
return r
def set_alias(userId, alias, accessToken=None):
''' this method is for verified service mp only '''
data = encode_send_dict({'openid': userId, 'remark': alias})
if data is None: return ReturnValue({'errcode': -10001})
r = requests.post('%s/cgi-bin/user/info/updateremark?access_token=%s'
% (SERVER_URL, accessToken), data=data)
def _wrap_result(result):
return ReturnValue(result.json())
r._wrap_result = _wrap_result
return r
def get_user_info(userId, accessToken=None):
''' get info of a user or a list of users
* userId can be a list or only one userId
'''
def _batch_get_user_info(userId, accessToken=None):
data = {'user_list': [{'openid': id, 'lang': 'zh-CN'} for id in userId]}
data = encode_send_dict(data)
if data is None: return ReturnValue({'errcode': -10001})
r = requests.post('%s/cgi-bin/user/info/batchget?access_token=%s'
% (SERVER_URL, accessToken), data=data)
def _wrap_result(result):
result = ReturnValue(result.json())
if 'user_info_list' in result: result['errcode'] = 0
return result
r._wrap_result = _wrap_result
return result
def _get_user_info(userId, accessToken=None):
params = {
'access_token': accessToken,
'openid': userId,
'lang': 'zh_CN', }
r = requests.get('%s/cgi-bin/user/info' % SERVER_URL, params=params)
def _wrap_result(result):
result = ReturnValue(result.json())
if 'openid' in result: result['errcode'] = 0
return result
r._wrap_result = _wrap_result
return r
if isinstance(userId, list):
return _batch_get_user_info(userId, accessToken)
else:
return _get_user_info(userId, accessToken)
def get_users(nextOpenId='', departmentId=None, fetchChild=False, status=4, accessToken=None):
''' get users from nextOpenId
* departmentId, fetchChild, status is for qy api
'''
params = {
'access_token': accessToken,
'next_openid': nextOpenId, }
r = requests.get('%s/cgi-bin/user/get' % SERVER_URL, params=params)
def _wrap_result(result):
result = ReturnValue(result.json())
if 'data' in result: result['errcode'] = 0
return result
r._wrap_result = _wrap_result
return r
def get_blacklist(beginOpenId='', accessToken=None):
data = {'begin_openid': beginOpenId}
data = encode_send_dict(data)
r = requests.post('%s/cgi-bin/tags/members/getblacklist?access_token=%s' %
(SERVER_URL, accessToken), data=data)
def _wrap_result(result):
result = ReturnValue(result.json())
if 'data' in result: result['errcode'] = 0
return result
r._wrap_result = _wrap_result
return r
def add_users_into_blacklist(userId, accessToken=None):
''' userId can be a userId or a list of userId '''
if not isinstance(userId, list):
userId = [userId]
data = {'openid_list': userId}
data = encode_send_dict(data)
r = requests.post('%s/cgi-bin/tags/members/batchblacklist?access_token=%s' %
(SERVER_URL, accessToken), data=data)
def _wrap_result(result):
return ReturnValue(result.json())
r._wrap_result = _wrap_result
return r
def delete_users_of_blacklist(userId, accessToken=None):
''' userId can be a userId or a list of userId '''
if not isinstance(userId, list):
userId = [userId]
data = {'openid_list': userId}
data = encode_send_dict(data)
r = requests.post('%s/cgi-bin/tags/members/batchunblacklist?access_token=%s' %
(SERVER_URL, accessToken), data=data)
def _wrap_result(result):
return ReturnValue(result.json())
r._wrap_result = _wrap_result
return r
| mit | 5,263,644,145,367,471,000 | 35.689655 | 95 | 0.612534 | false |
shahabsaf1/Python | plugins/chatter.py | 1 | 1250 | # -*- coding: utf-8 -*-
from utils import *
from cleverbot import Cleverbot
from HTMLParser import HTMLParser
# If someone mentions the bot's username, it replies
commands = [('@' + bot['username'].lower())]
action = 'typing'
hidden = True
def run(msg):
input = msg['text'].replace(bot['first_name'] + ' ', '')
cb = Cleverbot()
unescape = HTMLParser().unescape
try:
message = unescape(cb.ask(input))
except:
message = u'🙃'
send_message(msg['chat']['id'], message, reply_to_message_id = msg['message_id'])
def process(msg):
if ('reply_to_message' in msg and
'text' in msg['reply_to_message'] and
'text' in msg):
if (str(msg['chat']['id']) in groups and
groups[str(msg['chat']['id'])]['special'] != 'log'):
if (msg['reply_to_message']['from']['id'] == bot['id'] and
not msg['text'].startswith(config['command_start'])):
msg['text'] = '@' + bot['username'] + ' ' + msg['text']
if ('text' in msg and
msg['chat']['type'] == 'private' and
not msg['text'].startswith(config['command_start'])):
msg['text'] = '@' + bot['username'] + ' ' + msg['text']
| gpl-2.0 | -4,327,251,469,896,459,000 | 29.974359 | 85 | 0.531676 | false |
gpmidi/zabbixMongoDB | src/mon/zbx/comm/metrics/discovery.py | 1 | 3356 | '''
Created on Jan 12, 2014
@author: Paulson McIntyre (GpMidi) <[email protected]>
'''
# Built-in
import time
import logging
import socket
import collections
import re
try:
# Python 3.x?
import json # @UnresolvedImport
except:
# Python 2.7
import simplejson as json # @UnresolvedImport @Reimport
# Others
# Ours
from mon.zbx.comm.metric import Metric
class DiscoveryMetric(Metric):
""" Helps with low-level item/graph/etc discovery
"""
DEFAULT_KEY = lambda metric: "discovery.default"
DEFAULT_VALUE = lambda metric: json.dumps(dict(data = []))
ENFORCE_METRIC_MACRO = True
ENFORCE_METRIC_MACRO_MATCH = re.compile(r'^\{\#[A-Z0-9_\-]+\}$')
def __init__(self, discovered = None, value = None, **kwargs):
self.discovered = discovered
super(DiscoveryMetric, self).__init__(value = value, **kwargs)
def getDiscovered(self):
if self.discovered is None:
self.discovered = []
assert isinstance(self.discovered, collections.Iterable), "Expected discovered to be itterable. Got %r. " % self.discovered
# TODO: Add handling of discovered not being itterable
if self.ENFORCE_METRIC_MACRO:
for discovered in self.discovered:
assert isinstance(discovered, dict), "Expected discovered type of %r to be a dict" % discovered
for k,v in discovered.items():
assert self.ENFORCE_METRIC_MACRO_MATCH.match(k), "Metric's macro name is invalid. Got %r" % k
assert isinstance(v, str) or isinstance(v, unicode), "Metric value %r isn't a string" % v
return self.discovered
def addMetric(self, **macros):
if self.discovered is None:
self.discovered = []
assert len(macros)>0,"Expected at least one macro to be set. Got %r"%macros
if self.ENFORCE_METRIC_MACRO:
for k,v in macros.items():
assert self.ENFORCE_METRIC_MACRO_MATCH.match(k), "Metric's macro name is invalid. Got %r" % k
assert isinstance(v, str) or isinstance(v, unicode), "Metric value %r isn't a string" % v
self.discovered.append(macros)
def clearMetrics(self):
self.discovered = []
def getValue(self):
asObjs = dict(data = self.getDiscovered())
asStr = json.dumps(asObjs, indent = 0).replace(' ', '\t')\
.replace('{\n', '\t{\n').replace('\n}, \n', '\t}\n\t,\n')\
.replace('"{#', '\t\t"{#').replace('\n}\n', '\t}\n')\
.replace('": "', '":"').replace('\t{\n\"data\": ', '{\n\"data\":')
self.l.log(3, "Created JSON %r from %r", asStr, asObjs)
return asStr
def toZbxJSON(self):
""" Convert to JSON that Zabbix will accept """
# Zabbix has very fragile JSON parser, and we cannot use json to dump whole packet
ret = (
'\t\t{\n'
'\t\t\t"host":%s,\n'
'\t\t\t"key":%s,\n'
'\t\t\t"value":%s,\n'
'\t\t\t"clock":%s}'
) % (
json.dumps(self.getHost()),
json.dumps(self.getKey()),
json.dumps(self.getValue()),
self.getClock(),
)
self.l.log(3, "Serialized %r to %r", self, ret)
return ret
| gpl-2.0 | -6,271,459,724,271,895,000 | 35.879121 | 131 | 0.561979 | false |
cpknowles/BRG | black_rapids_forward_model/black_rapids_depth_integrated.py | 1 | 14468 | from pylab import *
from scipy.interpolate import RectBivariateSpline
from scipy import ndimage as nd
import numpy as np
import gdal
def fill(data, invalid=None):
"""
Replace the value of invalid 'data' cells (indicated by 'invalid')
by the value of the nearest valid data cell
Input:
data: numpy array of any dimension
invalid: a binary array of same shape as 'data'. True cells set where data
value should be replaced.
If None (default), use: invalid = np.isnan(data)
Output:
Return a filled array.
"""
#import numpy as np
#import scipy.ndimage as nd
if invalid is None: invalid = np.isnan(data)
ind = nd.distance_transform_edt(invalid, return_distances=False, return_indices=True)
return data[tuple(ind)]
### DATA ###
data = gdal.Open('input_data_bed_v2/DEM_2010/ifsar_2010.tif')
S_array = data.ReadAsArray()[::-1,:]
ncols = data.RasterXSize
nrows = data.RasterYSize
transf = data.GetGeoTransform()
x = arange(transf[0],transf[0]+transf[1]*data.RasterXSize,transf[1])
y = arange(transf[3],transf[3]+transf[5]*data.RasterYSize,transf[5])[::-1]
S_spline = RectBivariateSpline(x,y,S_array.T,kx=1,ky=1,s=0)
data = gdal.Open('input_data_bed_v2/BED_MC/bed.tif')
B_array = data.ReadAsArray()[::-1,:]
ncols = data.RasterXSize
nrows = data.RasterYSize
transf = data.GetGeoTransform()
x = arange(transf[0],transf[0]+transf[1]*data.RasterXSize,transf[1])
y = arange(transf[3],transf[3]+transf[5]*data.RasterYSize,transf[5])[::-1]
B_spline = RectBivariateSpline(x,y,B_array.T,kx=1,ky=1,s=0)
data = gdal.Open('input_data_bed_v2/SMB_2010_2013/mb_field_25.tif')
adot_array = data.ReadAsArray()[::-1,:]
adot_array = fill(adot_array,adot_array==adot_array.min())
ncols = data.RasterXSize
nrows = data.RasterYSize
transf = data.GetGeoTransform()
x = arange(transf[0],transf[0]+transf[1]*data.RasterXSize,transf[1])
y = arange(transf[3],transf[3]+transf[5]*data.RasterYSize,transf[5])[::-1]
adot_spline = RectBivariateSpline(x,y,adot_array.T,kx=1,ky=1,s=0)
data = gdal.Open('input_data_bed_v2/DH_2010_2013/dhdt_weq_lower.tif')
dhdt_array = data.ReadAsArray()[::-1,:]
dhdt_array[dhdt_array<-1000] = 0
dhdt_array = fill(dhdt_array,dhdt_array==dhdt_array.min())
ncols = data.RasterXSize
nrows = data.RasterYSize
transf = data.GetGeoTransform()
x = arange(transf[0],transf[0]+transf[1]*data.RasterXSize,transf[1])
y = arange(transf[3],transf[3]+transf[5]*data.RasterYSize,transf[5])[::-1]
dhdt_spline = RectBivariateSpline(x,y,dhdt_array.T,kx=1,ky=1,s=0)
from dolfin import *
from ice_model_functions import *
##########################################################
################# SET PETSC OPTIONS ####################
##########################################################
PETScOptions.set("ksp_type","preonly")
PETScOptions.set("pc_type","lu")
PETScOptions.set("pc_factor_mat_solver_package","mumps")
PETScOptions.set("mat_mumps_icntl_14","1000")
PETScOptions.set("ksp_final_residual","0")
##########################################################
################# SET FENICS OPTIONS ###################
##########################################################
parameters['form_compiler']['quadrature_degree'] = 2
parameters['form_compiler']['cpp_optimize'] = True
parameters['form_compiler']['representation'] = 'quadrature'
#parameters['form_compiler']['precision'] = 30
parameters['allow_extrapolation'] = True
ffc_options = {"optimize": True, \
"eliminate_zeros": True, \
"precompute_basis_const": True, \
"precompute_ip_const": True}
##########################################################
#################### CONSTANTS #########################
##########################################################
# TIME
minute = 60.0
hour = 60*minute
day = 24*hour
year = 365*day
# CONSTANTS
rho = 917.
g = 9.81
# RHEOLOGICAL CONSTANTS
rho_i = 910.
n = 3.0
Bc = 3.61e-13*year
Bw = 1.73e3*year
Qc = 6e4
Qw = 13.9e4
Rc = 8.314
gamma = 8.7e-4
eps_reg = Constant(1e-10)
# THERMAL CONTANTS
k = 2.1*year
Cp = 2009.
kappa = k/(rho_i*Cp)
q_geo = 0.042*year
# ADJOINT REG
theta = Constant(1e-10)
# MASS
thklim = 10.
dt = Constant(0.001)
###################################################
########### GEOMETRY AND INPUT DATA ##############
###################################################
##### BOUNDARY DATA #####
class Beta2(Expression):
def eval(self,values,x):
values[0] = 11000.
class S_exp(Expression):
def eval(self,values,x):
values[0] = S_spline(x[0],x[1])
class B_exp(Expression):
def eval(self,values,x):
values[0] = B_spline(x[0],x[1])
class Adot_exp(Expression):
def eval(self,values,x):
values[0] = 1000.0/910.0*adot_spline(x[0],x[1])/3. # Christian provides these fields as mwe/3a, hence correction.
class Dhdt_exp(Expression):
def eval(self,values,x):
values[0] = 1000.0/910.0*dhdt_spline(x[0],x[1])/3.
mesh = Mesh('outline.xml')
# FUNCTION SPACES
Q = FunctionSpace(mesh,"CG",1) # SCALAR
Q2 = MixedFunctionSpace([Q,]*2)
V = MixedFunctionSpace([Q]*5) # VELOCITY + MASS
beta2 = interpolate(Beta2(),Q)
#### !!!!!! #### Note the distinction between effective and normal mass balance !
adot = interpolate(Adot_exp(),Q) - interpolate(Dhdt_exp(),Q) # Effective mass balance (near steady initially)
#adot = interpolate(Adot_exp(),Q) # True mass balance (way imbalanced)
B = interpolate(B_exp(),Q)
S_obs = interpolate(S_exp(),Q)
S0 = interpolate(S_exp(),Q)
H0 = Function(Q)
H0.vector()[:] = S_obs.vector()[:] - B.vector()[:] # Set initial thickness
# FUNCTIONS
U = Function(V)
Lamda = Function(V)
Phi = TestFunction(V)
dU = TrialFunction(V)
gamma = TestFunction(Q)
ubar,vbar,udef,vdef,H = split(U)
phibar,psibar,phidef,psidef,xsi = split(Lamda)
S = B+H
# METRICS FOR COORDINATE TRANSFORM
def dsdx(s):
return 1./H*(S.dx(0) - s*H.dx(0))
def dsdy(s):
return 1./H*(S.dx(1) - s*H.dx(1))
def dsdz(s):
return -1./H
p = 4
# TEST FUNCTION COEFFICIENTS
coef = [lambda s:1.0, lambda s:1./p*((p+1)*s**p - 1)]
dcoef = [lambda s:0, lambda s:(p+1)*s**(p-1)]
u_ = [ubar,udef]
v_ = [vbar,vdef]
phi_ = [phibar,phidef]
psi_ = [psibar,psidef]
u = VerticalBasis(u_,coef,dcoef)
v = VerticalBasis(v_,coef,dcoef)
phi = VerticalBasis(phi_,coef,dcoef)
psi = VerticalBasis(psi_,coef,dcoef)
# TERMWISE STRESSES AND NONLINEARITIES
def A_v():
return Constant(1e-16)
# 2nd INVARIANT STRAIN RATE
def epsilon_dot(s):
return ((u.dx(s,0) + u.ds(s)*dsdx(s))**2 \
+(v.dx(s,1) + v.ds(s)*dsdy(s))**2 \
+(u.dx(s,0) + u.ds(s)*dsdx(s))*(v.dx(s,1) + v.ds(s)*dsdy(s)) \
+0.25*((u.ds(s)*dsdz(s))**2 + (v.ds(s)*dsdz(s))**2 \
+ ((u.dx(s,1) + u.ds(s)*dsdy(s)) + (v.dx(s,0) + v.ds(s)*dsdx(s)))**2) \
+ eps_reg)
# VISCOSITY
def eta_v(s):
return A_v()**(-1./n)/2.*epsilon_dot(s)**((1.-n)/(2*n))
# MEMBRANE STRESSES
E = Constant(1.0)
def membrane_xx(s):
return (phi.dx(s,0) + phi.ds(s)*dsdx(s))*H*(E*eta_v(s))*(4*(u.dx(s,0) + u.ds(s)*dsdx(s)) + 2*(v.dx(s,1) + v.ds(s)*dsdy(s)))
def membrane_xy(s):
return (phi.dx(s,1) + phi.ds(s)*dsdy(s))*H*(E*eta_v(s))*((u.dx(s,1) + u.ds(s)*dsdy(s)) + (v.dx(s,0) + v.ds(s)*dsdx(s)))
def membrane_yx(s):
return (psi.dx(s,0) + psi.ds(s)*dsdx(s))*H*(E*eta_v(s))*((u.dx(s,1) + u.ds(s)*dsdy(s)) + (v.dx(s,0) + v.ds(s)*dsdx(s)))
def membrane_yy(s):
return (psi.dx(s,1) + psi.ds(s)*dsdy(s))*H*(E*eta_v(s))*(2*(u.dx(s,0) + u.ds(s)*dsdx(s)) + 4*(v.dx(s,1) + v.ds(s)*dsdy(s)))
# SHEAR STRESSES
def shear_xz(s):
return dsdz(s)**2*phi.ds(s)*H*eta_v(s)*u.ds(s)
def shear_yz(s):
return dsdz(s)**2*psi.ds(s)*H*eta_v(s)*v.ds(s)
# DRIVING STRESSES
def tau_dx():
return rho*g*H*S.dx(0)*Lamda[0]
def tau_dy():
return rho*g*H*S.dx(1)*Lamda[1]
def boundary_membrane_xx(s):
return phi(s)*H*(E*eta_v(s))*(4*(u.dx(s,0) + u.ds(s)*dsdx(s)) + 2*(v.dx(s,1) + v.ds(s)*dsdy(s)))
def boundary_membrane_xy(s):
return phi(s)*H*(E*eta_v(s))*((u.dx(s,1) + u.ds(s)*dsdy(s)) + (v.dx(s,0) + v.ds(s)*dsdx(s)))
def boundary_membrane_yx(s):
return psi(s)*H*(E*eta_v(s))*((u.dx(s,1) + u.ds(s)*dsdy(s)) + (v.dx(s,0) + v.ds(s)*dsdx(s)))
def boundary_membrane_yy(s):
return psi(s)*H*(E*eta_v(s))*(2*(u.dx(s,0) + u.ds(s)*dsdx(s)) + 4*(v.dx(s,1) + v.ds(s)*dsdy(s)))
N = FacetNormal(mesh)
# GET QUADRATURE POINTS (THIS SHOULD BE ODD: WILL GENERATE THE GAUSS-LEGENDRE RULE
# POINTS AND WEIGHTS OF O(n), BUT ONLY THE POINTS IN [0,1] ARE KEPT< DUE TO SYMMETRY.
points,weights = half_quad(11)
# INSTANTIATE VERTICAL INTEGRATOR
vi = VerticalIntegrator(points,weights)
# FIRST ORDER EQUATIONS
I_x = - vi.intz(membrane_xx) - vi.intz(membrane_xy) - vi.intz(shear_xz) - phi(1)*beta2*u(1) - tau_dx()
I_y = - vi.intz(membrane_yx) - vi.intz(membrane_yy) - vi.intz(shear_yz) - psi(1)*beta2*v(1) - tau_dy()
I = (I_x + I_y)*dx
### MASS BALANCE ###
# SUPG PARAMETERS
h = CellSize(mesh)
tau = h/(2.0*sqrt(U[0]**2 + U[1]**2 + 25.0))
Hmid = 0.5*H + 0.5*H0
xsihat = tau*(U[0]*xsi.dx(0) + U[1]*xsi.dx(1))
# STABILIZED CONTINUITY EQUATION
I += ((H - H0)/dt*xsi - (xsi.dx(0)*U[0]*Hmid + xsi.dx(1)*U[1]*Hmid) + xsihat*(U[0]*Hmid.dx(0) + U[1]*Hmid.dx(1) + Hmid*(U[0].dx(0) + U[1].dx(1))) - (adot)*(xsi + xsihat))*dx# + xsi*(U[0]*Hmid*N[0] + U[1]*Hmid*N[1])*ds(1)
I_misfit = theta*dot(grad(beta2),grad(beta2))*dx
I += I_misfit
# JACOBIAN FOR COUPLED MASS + MOMENTUM SOLVE
R = derivative(I,Lamda,Phi)
J = derivative(R,U,dU)
# Adjoint forms, if so desired
R_adj = derivative(I,U,Phi)
J_adj = derivative(R_adj,Lamda,dU)
G = derivative(I,beta2,gamma)
#####################################################################
######################### I/O Functions ###########################
#####################################################################
# For moving data between vector functions and scalar functions
assigner_inv = FunctionAssigner([Q,Q,Q,Q,Q],V)
assigner = FunctionAssigner(V,[Q,Q,Q,Q,Q])
assigner_vec = FunctionAssigner(Q2,[Q,Q])
#####################################################################
###################### Variational Solvers ########################
#####################################################################
# Positivity constraints and zero-flux boundary conditions don't play well together, so I enforce the former through a non-slip Dirichlet boundary condition on velocity. This is a little weird in the context of glaciers, but it's the only condition that will uphold mass conservation (there is still a fictitious momentum flux across the boundary, aka a non-real stress, but that's more acceptable to me).
bcs = [DirichletBC(V.sub(i),0,lambda x,on:on) for i in range(4)]
bc_2 = DirichletBC(V.sub(4),thklim,lambda x,o:(o and x[0]>393092) or (o and (x[1]>1.5273e6 and x[0]<372129 and x[0]>368953)))
mass_problem = NonlinearVariationalProblem(R,U,J=J,bcs=bcs+[bc_2],form_compiler_parameters=ffc_options)
mass_solver = NonlinearVariationalSolver(mass_problem)
mass_solver.parameters['nonlinear_solver'] = 'snes'
mass_solver.parameters['snes_solver']['method'] = 'vinewtonrsls'
mass_solver.parameters['snes_solver']['relative_tolerance'] = 1e-6
mass_solver.parameters['snes_solver']['absolute_tolerance'] = 1e-6
mass_solver.parameters['snes_solver']['maximum_iterations'] = 10
mass_solver.parameters['snes_solver']['error_on_nonconvergence'] = False
mass_solver.parameters['snes_solver']['linear_solver'] = 'mumps'
bc_adj_1 = DirichletBC(V,[0.0,0.0,0.0,0.0,0.0],lambda x,on:on)
bc_adj_2 = DirichletBC(V.sub(4),0.0,lambda x,on:on)
adj_problem = NonlinearVariationalProblem(R_adj,Lamda,J=J_adj,bcs=[bc_adj_1,bc_adj_2],form_compiler_parameters=ffc_options)
adj_solver = NonlinearVariationalSolver(adj_problem)
adj_solver.parameters['newton_solver']['relative_tolerance'] = 1e-3
adj_solver.parameters['newton_solver']['absolute_tolerance'] = 1e-3
adj_solver.parameters['newton_solver']['maximum_iterations'] = 3
adj_solver.parameters['newton_solver']['error_on_nonconvergence'] = False
adj_solver.parameters['newton_solver']['linear_solver'] = 'mumps'
#####################################################################
################## INITIAL CONDITIONS AND BOUNDS ##################
#####################################################################
l_thick_bound = project(Constant(thklim),Q)
u_thick_bound = project(Constant(1e4),Q)
l_v_bound = project(-10000.0,Q)
u_v_bound = project(10000.0,Q)
l_bound = Function(V)
u_bound = Function(V)
un = Function(Q)
u2n = Function(Q)
vn = Function(Q)
v2n = Function(Q)
lx = Function(Q)
l2x = Function(Q)
mx = Function(Q)
m2x = Function(Q)
p0 = Function(Q)
assigner.assign(U,[un,vn,u2n,v2n,H0])
assigner.assign(l_bound,[l_v_bound]*4+[l_thick_bound])
assigner.assign(u_bound,[u_v_bound]*4+[u_thick_bound])
results_dir = './results/'
Hfile_ptc = File(results_dir + 'H.pvd')
Ufile_ptc = File(results_dir + 'Us.pvd')
bfile_ptc = File(results_dir + 'beta2.pvd')
opt_dir = './results_opt/'
Ufile_opt = File(opt_dir + 'Us.pvd')
bfile_opt = File(opt_dir + 'beta2.pvd')
Us = project(as_vector([u(0),v(0)]))
assigner_inv.assign([lx,l2x,mx,m2x,p0],Lamda)
# Uncomment if you want to start from the end of the last run
#File(results_dir + 'U.xml') >> U
#H0_temp = project(H)
#H0.vector()[:] = H0_temp.vector()[:]
t = 2016.75
#Start slow for convergence. Due to an oddity in topography, this model will not converge for the first 5 or so iterations as it fills a hole, then will work fine after.
dt_schedule = [0.00001]*5 + [0.01]*10 + [0.1]*5 + [0.5]*100 + [1.0]*100
#Time stepping
solve(R==0, U, bcs=bcs+[bc_2])
assigner_inv.assign([un,vn,u2n,v2n,H0],U)
#H0_temp = project(H)
#H0.vector()[:] = H0_temp.vector()[:]
Us_temp = project(as_vector([u(0),v(0)]))
Us.vector()[:] = Us_temp.vector()[:]
S_temp = project(S)
S0.vector()[:] = S_temp.vector()[:]
Hfile_ptc << (H0,t)
Ufile_ptc << (Us,t)
bfile_ptc << (S0,t)
"""
for dts in dt_schedule:
dt.assign(dts)
t += dts
#mass_solver.solve(l_bound,u_bound)
solve(R==0, U, bcs=bcs+[bc_2])
assigner_inv.assign([un,vn,u2n,v2n,H0],U)
#H0_temp = project(H)
#H0.vector()[:] = H0_temp.vector()[:]
Us_temp = project(as_vector([u(0),v(0)]))
Us.vector()[:] = Us_temp.vector()[:]
S_temp = project(S)
S0.vector()[:] = S_temp.vector()[:]
Hfile_ptc << (H0,t)
Ufile_ptc << (Us,t)
bfile_ptc << (S0,t)
"""
File(results_dir + 'Ustar.xml') << U
| mit | 8,416,404,929,511,161,000 | 29.91453 | 406 | 0.593655 | false |
TradeHero/gitinspector | gitinspector/main.py | 1 | 2678 | #!/usr/bin/python
# coding: utf-8
#
# Copyright © 2012-2014 Ejwa Software. All rights reserved.
#
# This file is part of gitinspector.
#
# gitinspector 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.
#
# gitinspector 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 gitinspector. If not, see <http://www.gnu.org/licenses/>.
from __future__ import print_function
from __future__ import unicode_literals
import localization
localization.init()
import basedir
import format
import os
import sys
import terminal
import procedure
import subprocess
class Runner:
def __init__(self):
self.repo = "."
self.command_line = "python " + " ".join(sys.argv[:])
self.command_line = self.command_line.replace("main.py", "gitinspector.py")
def output(self):
terminal.skip_escapes(not sys.stdout.isatty())
terminal.set_stdout_encoding()
previous_directory = os.getcwd()
os.chdir(self.repo)
absolute_path = basedir.get_basedir_git()
os.chdir(absolute_path)
procedure.remove_inspection_branches()
procedure.create_branches_for_inspection()
format.output_header()
sorted_branches = procedure.sort_branches_by_last_update()
for (commit, branch_name) in sorted_branches:
if procedure.eligible_for_inspection(commit):
if procedure.switch_to_branch(branch_name):
output = subprocess.Popen(self.command_line, shell=True, bufsize=1, stdout=subprocess.PIPE).stdout
print(output.read())
else:
print("\n\n ==> All eligible branches have been inspected!")
break
procedure.remove_inspection_branches()
os.chdir(previous_directory)
def __check_python_version__():
if sys.version_info < (2, 6):
python_version = str(sys.version_info[0]) + "." + str(sys.version_info[1])
sys.exit(_("gitinspector requires at least Python 2.6 to run (version {0} was found).").format(python_version))
def main():
terminal.check_terminal_encoding()
terminal.set_stdin_encoding()
__run__ = Runner()
__check_python_version__()
__run__.output()
if __name__ == "__main__":
main()
| gpl-3.0 | -6,643,906,900,088,932,000 | 30.127907 | 119 | 0.663429 | false |
nuobit/odoo-addons | connector_sage/models/payroll_sage_labour_agreement/adapter.py | 1 | 1429 | # Copyright NuoBiT Solutions, S.L. (<https://www.nuobit.com>)
# Eric Antones <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
from odoo import models, fields
from odoo.addons.component.core import Component
from odoo.addons.queue_job.job import job
class PayrollSageLabourAgreementAdapter(Component):
_name = 'sage.payroll.sage.labour.agreement.adapter'
_inherit = 'sage.adapter'
_apply_on = 'sage.payroll.sage.labour.agreement'
_sql = """select c.CodigoEmpresa, n.CodigoConvenio, n.Convenio, n.FechaRegistroCV, n.FechaFinalNom,
n.FechaRevision, n.CodigoConvenioColectivo, n.CodigoConvenioColectivoAnt,
n.JornadaAnual, n.ConvenioBloqueado
from (select distinct c.CodigoEmpresa, c.CodigoConvenio, c.FechaRegistroCV
from %(schema)s.ConvenioConcepto c
where exists (
select 1
from %(schema)s.Convenio n
where c.CodigoConvenio = n.CodigoConvenio and
c.FechaRegistroCV = n.FechaRegistroCV
)
) c, %(schema)s.Convenio n
where c.CodigoConvenio = n.CodigoConvenio and
c.FechaRegistroCV = n.FechaRegistroCV
"""
_id = ('CodigoEmpresa', 'CodigoConvenio', 'FechaRegistroCV')
| agpl-3.0 | 7,343,226,407,742,488,000 | 43.65625 | 104 | 0.604619 | false |
JackPerdue/easybuild-easyconfigs | setup.py | 1 | 4640 | ##
# Copyright 2012-2013 Ghent University
#
# This file is part of EasyBuild,
# originally created by the HPC team of Ghent University (http://ugent.be/hpc/en),
# with support of Ghent University (http://ugent.be/hpc),
# the Flemish Supercomputer Centre (VSC) (https://vscentrum.be/nl/en),
# the Hercules foundation (http://www.herculesstichting.be/in_English)
# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
#
# http://github.com/hpcugent/easybuild
#
# EasyBuild 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 v2.
#
# EasyBuild 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 EasyBuild. If not, see <http://www.gnu.org/licenses/>.
##
"""
This script can be used to install easybuild-easyconfigs, e.g. using:
easy_install --user .
or
python setup.py --prefix=$HOME/easybuild
@author: Kenneth Hoste (Ghent University)
"""
import glob
import os
import re
import shutil
import sys
from distutils import log
# note: release candidates should be versioned as a pre-release, e.g. "1.1rc1"
# 1.1-rc1 would indicate a post-release, i.e., and update of 1.1, so beware!
VERSION = "1.13.0.0"
API_VERSION = VERSION.split('.')[0]
EB_VERSION = '.'.join(VERSION.split('.')[0:2])
suff = ''
rc_regexp = re.compile("^.*(rc[0-9]*)$")
res = rc_regexp.search(str(VERSION))
if res:
suff = res.group(1)
dev_regexp = re.compile("^.*[0-9]dev$")
if dev_regexp.match(VERSION):
suff = 'dev'
API_VERSION += suff
EB_VERSION += suff
# log levels: 0 = WARN (default), 1 = INFO, 2 = DEBUG
log.set_verbosity(1)
# try setuptools, fall back to distutils if needed
try:
from setuptools import setup
log.info("Installing with setuptools.setup...")
install_package = 'setuptools'
except ImportError, err:
log.info("Failed to import setuptools.setup (%s), so falling back to distutils.setup" % err)
from distutils.core import setup
install_package = 'distutils'
# utility function to read README file
def read(fname):
"""Read contents of given file."""
return open(os.path.join(os.path.dirname(__file__), fname)).read()
# utility function to get list of data files (i.e. easyconfigs)
def get_data_files():
"""
Return list of data files, i.e. easyconfigs, patches, etc.,
and retain directory structure.
"""
data_files = []
for dirname,dirs,files in os.walk(os.path.join('easybuild', 'easyconfigs')):
if files:
data_files.append((dirname, [os.path.join(dirname, f) for f in files]))
return data_files
log.info("Installing version %s (required versions: API >= %s, easyblocks >= %s)" % (VERSION, API_VERSION, EB_VERSION))
setup(
name = "easybuild-easyconfigs",
version = VERSION,
author = "EasyBuild community",
author_email = "[email protected]",
description = """EasyBuild is a software installation framework in Python that allows you to \
install software in a structured and robust way.
This package contains a collection of easyconfigs, i.e. simple text files written in Python syntax \
that specify the build parameters for software packages (version, compiler toolchain, dependency \
versions, etc.)""",
license = "GPLv2",
keywords = "software build building installation installing compilation HPC scientific",
url = "http://hpcugent.github.com/easybuild",
data_files = get_data_files(),
long_description = read("README.rst"),
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
"Operating System :: POSIX :: Linux",
"Programming Language :: Python :: 2.4",
"Topic :: Software Development :: Build Tools",
],
platforms = "Linux",
# install_requires list is not enforced, because of 'old-and-unmanageable' setup?
# do we even want the dependency, since it's artificial?
install_requires = [
"easybuild-framework >= %s" % API_VERSION,
"easybuild-easyblocks >= %s" % EB_VERSION
],
zip_safe = False
)
| gpl-2.0 | -1,068,465,021,707,233,500 | 35.535433 | 119 | 0.669397 | false |
bjornwallner/proq2-server | apps/modeller9v8/modlib/modeller/salign.py | 1 | 7695 | import modeller
class SalignData(object):
"""Data returned from the 'alignment.salign' method"""
def __init__(self, aln_score, qscorepct):
self.aln_score = aln_score
self.qscorepct = qscorepct
def _salign_fw_local_gaps1(aln, feature_weights, ogp, egp, matrix_offset):
"""Local alignment with given parameters"""
return aln.salign(rms_cutoff=3.5, normalize_pp_scores=False,
rr_file='$(LIB)/as1.sim.mat', overhang=0,
gap_penalties_1d=(ogp, egp),
local_alignment=True, matrix_offset=matrix_offset,
matrix_offset_3d=-0.5, gap_penalties_3d=(0, 3),
gap_gap_score=0, gap_residue_score=0,
alignment_type='tree', nsegm=2,
feature_weights=feature_weights,
improve_alignment=True, fit=True, write_fit=False,
output='ALIGNMENT QUALITY')
def _salign_fw_gaps3(aln, feature_weights, ogp3d, egp3d):
"""Global alignment with given parameters"""
ogp = ogp3d
egp = egp3d
def _salign_wrap(aln, **keys):
try:
return aln.salign(auto_overhang=True, overhang_auto_limit=5,
overhang_factor=1, **keys)
except modeller.ModellerError, detail:
print "SALIGN with auto_overhang failed: %s" % str(detail)
print "Retrying without auto_overhang"
return aln.salign(**keys)
return _salign_wrap(aln, rms_cutoff=3.5, normalize_pp_scores=False,
rr_file='$(LIB)/as1.sim.mat', overhang=0,
gap_penalties_1d=(ogp, egp),
local_alignment=False, matrix_offset=-0.2,
gap_penalties_3d=(ogp3d, egp3d), gap_gap_score=0,
gap_residue_score=0, alignment_type='tree',
nsegm=2, feature_weights=feature_weights,
improve_alignment=True, fit=True, write_fit=False,
write_whole_pdb=False, output='ALIGNMENT QUALITY')
def _frange(start, end=None, inc=1.0):
"""A range function that accepts floating point increments"""
if end is None:
end = float(start)
start = 0.0
else:
start = float(start)
count = int((end - start)/inc)
if start + (count*inc) != end:
count += 1
for i in range(count):
yield start + i*inc
class _TemporaryDirectory(object):
"""Create a temporary directory, and delete it when this object
goes out of scope."""
def __init__(self):
import tempfile
import shutil
self.shutil = shutil
self.tmpdir = tempfile.mkdtemp()
def __del__(self):
if hasattr(self, 'shutil'):
self.shutil.rmtree(self.tmpdir)
def get_path(self, path):
"""Return the name of a file in the temporary directory"""
import os
return os.path.join(self.tmpdir, path)
def iterative_structural_align(aln):
"""Given an alignment of structures, iterate over parameter values
to obtain the best structural alignment."""
for seq in aln:
if not hasattr(seq, 'atoms'):
raise modeller.ModellerError("This method only works for an " + \
"alignment of structures.")
tmpdir = _TemporaryDirectory()
fil = tmpdir.get_path("inp.pir")
aln.write(file=fil)
opfile = tmpdir.get_path("salign_local_mid.ali")
opfile2 = tmpdir.get_path("salign_local.ali")
# -- Iterating over values of gap penalties and matrix offset
qmax = 0.0
win_ogp3d = None
fw1=(1., 0., 0., 0., 1., 0.)
fw2=(0., 1., 0., 0., 0., 0.)
fw3=(0., 0., 0., 0., 1., 0.)
# -- Iterating over gap penalties 1D to get initial alignments
print "Iterate over 1D penalties to get initial alignments"
for ogp in _frange(-150, 1, 50):
for egp in _frange(-50, 1, 50):
for mo in _frange(-3.0, -0.05, 0.3):
aln.clear()
aln.append(file=fil)
try:
qwlty1 = _salign_fw_local_gaps1(aln,fw1,ogp,egp,mo)
if qwlty1.qscorepct >= qmax:
qmax = qwlty1.qscorepct
aln.write(file=opfile, alignment_format='PIR')
win_ogp = ogp
win_egp = egp
win_mo = mo
print "Qlty scrs", ogp,"\t",egp,"\t",qwlty1.qscorepct
except modeller.ModellerError, detail:
print "Set of parameters",fw1,ogp,egp,"resulted in the following error\t"+str(detail)
# -- Iterating over gap penalties 3D to get final alignments
print "Iterate over 3D penalties to get final alignments"
qmax3d = 0.
for ogp3d in _frange(0, 3, 1):
for egp3d in range (2, 5, 1):
aln.clear()
aln.append(file=opfile)
try:
qwlty2 = _salign_fw_gaps3(aln,fw2,ogp3d,egp3d)
if qwlty2.qscorepct >= qmax3d:
qmax3d = qwlty2.qscorepct
aln.write(file=opfile2, alignment_format='PIR')
win_ogp3d = ogp3d
win_egp3d = egp3d
print "Qlty scrs", ogp3d,"\t",egp3d,"\t",qwlty2.qscorepct
except modeller.ModellerError,detail:
print "Set of parameters",fw2,ogp3d,egp3d,"resulted in the following error\t"+str(detail)
qmax = max(qmax, qmax3d)
# try alternate initial alignments only if the qmax score is less than 70%
qmax_old = qmax
if qmax_old <= 70:
print "Trying alternate initial alignments"
for ogp in _frange(0.0, 2.2, 0.3):
for egp in _frange(0.1, 2.3, 0.3):
for mo in _frange(-3.0, -0.05, 0.3):
aln.clear()
aln.append(file=fil)
try:
qwlty1 = _salign_fw_local_gaps1(aln,fw3,ogp,egp,mo)
if qwlty1.qscorepct >= qmax:
qmax = qwlty1.qscorepct
aln.write(file=opfile, alignment_format='PIR')
win_ogp = ogp
win_egp = egp
win_mo = mo
print "Qlty scrs", ogp,"\t",egp,"\t",qwlty1.qscorepct
except modeller.ModellerError, detail:
print "Set of parameters",fw3,ogp,egp,"resulted in the following error\t"+str(detail)
# -- Iterating over gap penalties 3D to get final alignments
print "Trying alternate final alignments"
qmax3d = 0.
for ogp3d in _frange(0, 3, 1):
for egp3d in range(2, 5, 1):
aln.clear()
aln.append(file=opfile)
try:
qwlty2 = _salign_fw_gaps3(aln,fw2,ogp3d,egp3d)
if qwlty2.qscorepct >= qmax3d:
qmax3d = qwlty2.qscorepct
aln.write(file=opfile2, alignment_format='PIR')
win_ogp3d = ogp3d
win_egp3d = egp3d
print "Qlty scrs", ogp3d,"\t",egp3d,"\t",qwlty2.qscorepct
except modeller.ModellerError,detail:
print "Set of parameters",fw2,ogp3d,egp3d,"resulted in the following error\t"+str(detail)
qmax = max(qmax, qmax3d)
print "final max quality = ", qmax
if win_ogp3d is None:
raise modeller.ModellerError("Structure alignment failed")
else:
aln.clear()
aln.append(file=opfile2)
| gpl-3.0 | 6,687,180,254,797,475,000 | 41.28022 | 109 | 0.535802 | false |
GoogleCloudPlatform/gsutil | gslib/parallel_tracker_file.py | 1 | 12431 | # -*- coding: utf-8 -*-
# Copyright 2015 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Helper functions for composite upload tracker file functionality."""
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
from __future__ import unicode_literals
from collections import namedtuple
import errno
import json
import random
import six
import gslib
from gslib.exception import CommandException
from gslib.tracker_file import (WriteJsonDataToTrackerFile,
RaiseUnwritableTrackerFileException)
from gslib.utils.constants import UTF8
ObjectFromTracker = namedtuple('ObjectFromTracker', 'object_name generation')
class _CompositeUploadTrackerEntry(object):
"""Enum class for composite upload tracker file JSON keys."""
COMPONENTS_LIST = 'components'
COMPONENT_NAME = 'component_name'
COMPONENT_GENERATION = 'component_generation'
ENC_SHA256 = 'encryption_key_sha256'
PREFIX = 'prefix'
def ReadParallelUploadTrackerFile(tracker_file_name, logger):
"""Read the tracker file from the last parallel composite upload attempt.
If it exists, the tracker file is of the format described in
WriteParallelUploadTrackerFile or a legacy format. If the file doesn't exist
or is formatted incorrectly, then the upload will start from the beginning.
This function is not thread-safe and must be protected by a lock if
called within Command.Apply.
Args:
tracker_file_name: The name of the tracker file to read parse.
logger: logging.Logger for outputting log messages.
Returns:
enc_key_sha256: Encryption key SHA256 used to encrypt the existing
components, or None if an encryption key was not used.
component_prefix: String prefix used in naming the existing components, or
None if no prefix was found.
existing_components: A list of ObjectFromTracker objects representing
the set of files that have already been uploaded.
"""
enc_key_sha256 = None
prefix = None
existing_components = []
tracker_file = None
# If we already have a matching tracker file, get the serialization data
# so that we can resume the upload.
try:
tracker_file = open(tracker_file_name, 'r')
tracker_data = tracker_file.read()
tracker_json = json.loads(tracker_data)
enc_key_sha256 = tracker_json[_CompositeUploadTrackerEntry.ENC_SHA256]
prefix = tracker_json[_CompositeUploadTrackerEntry.PREFIX]
for component in tracker_json[_CompositeUploadTrackerEntry.COMPONENTS_LIST]:
existing_components.append(
ObjectFromTracker(
component[_CompositeUploadTrackerEntry.COMPONENT_NAME],
component[_CompositeUploadTrackerEntry.COMPONENT_GENERATION]))
except IOError as e:
# Ignore non-existent file (happens first time a upload is attempted on an
# object, or when re-starting an upload after a
# ResumableUploadStartOverException), but warn user for other errors.
if e.errno != errno.ENOENT:
logger.warn(
'Couldn\'t read upload tracker file (%s): %s. Restarting '
'parallel composite upload from scratch.', tracker_file_name,
e.strerror)
except (KeyError, ValueError) as e:
# Legacy format did not support user-supplied encryption.
enc_key_sha256 = None
(prefix, existing_components) = _ParseLegacyTrackerData(tracker_data)
finally:
if tracker_file:
tracker_file.close()
return (enc_key_sha256, prefix, existing_components)
def _ParseLegacyTrackerData(tracker_data):
"""Parses a legacy parallel composite upload tracker file.
Args:
tracker_data: Legacy tracker file contents.
Returns:
component_prefix: The prefix used in naming the existing components, or
None if no prefix was found.
existing_components: A list of ObjectFromTracker objects representing
the set of files that have already been uploaded.
"""
# Old tracker files used a non-JSON format.
# The first line represents the prefix, followed by line pairs of object_name
# and generation. Discard the last blank line.
old_tracker_data = tracker_data.split('\n')[:-1]
prefix = None
existing_components = []
if old_tracker_data:
prefix = old_tracker_data[0]
i = 1
while i < len(old_tracker_data) - 1:
(name, generation) = (old_tracker_data[i], old_tracker_data[i + 1])
if not generation:
# Cover the '' case.
generation = None
existing_components.append(ObjectFromTracker(name, generation))
i += 2
return (prefix, existing_components)
def ValidateParallelCompositeTrackerData(tracker_file_name, existing_enc_sha256,
existing_prefix, existing_components,
current_enc_key_sha256, bucket_url,
command_obj, logger, delete_func,
delete_exc_handler):
"""Validates that tracker data matches the current encryption key.
If the data does not match, makes a best-effort attempt to delete existing
temporary component objects encrypted with the old key.
Args:
tracker_file_name: String file name of tracker file.
existing_enc_sha256: Encryption key SHA256 used to encrypt the existing
components, or None if an encryption key was not used.
existing_prefix: String prefix used in naming the existing components, or
None if no prefix was found.
existing_components: A list of ObjectFromTracker objects representing
the set of files that have already been uploaded.
current_enc_key_sha256: Current Encryption key SHA256 that should be used
to encrypt objects.
bucket_url: Bucket URL in which the components exist.
command_obj: Command class for calls to Apply.
logger: logging.Logger for outputting log messages.
delete_func: command.Apply-callable function for deleting objects.
delete_exc_handler: Exception handler for delete_func.
Returns:
prefix: existing_prefix, or None if the encryption key did not match.
existing_components: existing_components, or empty list if the encryption
key did not match.
"""
if six.PY3:
if isinstance(existing_enc_sha256, str):
existing_enc_sha256 = existing_enc_sha256.encode(UTF8)
if isinstance(current_enc_key_sha256, str):
current_enc_key_sha256 = current_enc_key_sha256.encode(UTF8)
if existing_prefix and existing_enc_sha256 != current_enc_key_sha256:
try:
logger.warn(
'Upload tracker file (%s) does not match current encryption '
'key. Deleting old components and restarting upload from '
'scratch with a new tracker file that uses the current '
'encryption key.', tracker_file_name)
components_to_delete = []
for component in existing_components:
url = bucket_url.Clone()
url.object_name = component.object_name
url.generation = component.generation
command_obj.Apply(
delete_func,
components_to_delete,
delete_exc_handler,
arg_checker=gslib.command.DummyArgChecker,
parallel_operations_override=command_obj.ParallelOverrideReason.SPEED)
except: # pylint: disable=bare-except
# Regardless of why we can't clean up old components, need to proceed
# with the user's original intent to upload the file, so merely warn.
component_names = [
component.object_name for component in existing_components
]
logger.warn(
'Failed to delete some of the following temporary objects:\n%s\n'
'(Continuing on to re-upload components from scratch.)',
'\n'.join(component_names))
# Encryption keys have changed, so the old components and prefix
# cannot be used.
return (None, [])
return (existing_prefix, existing_components)
def GenerateComponentObjectPrefix(encryption_key_sha256=None):
"""Generates a random prefix for component objects.
Args:
encryption_key_sha256: Encryption key SHA256 that will be used to encrypt
the components. This is hashed into the prefix to avoid collision
during resumption with a different encryption key.
Returns:
String prefix for use in the composite upload.
"""
return str(
(random.randint(1, (10**10) - 1) + hash(encryption_key_sha256)) % 10**10)
def WriteComponentToParallelUploadTrackerFile(tracker_file_name,
tracker_file_lock,
component,
logger,
encryption_key_sha256=None):
"""Rewrites an existing tracker file with info about the uploaded component.
Follows the format described in _CreateParallelUploadTrackerFile.
Args:
tracker_file_name: Tracker file to append to.
tracker_file_lock: Thread and process-safe Lock protecting the tracker file.
component: ObjectFromTracker describing the object that was uploaded.
logger: logging.Logger for outputting log messages.
encryption_key_sha256: Encryption key SHA256 for use in this upload, if any.
"""
with tracker_file_lock:
(existing_enc_key_sha256, prefix,
existing_components) = (ReadParallelUploadTrackerFile(
tracker_file_name, logger))
if existing_enc_key_sha256 != encryption_key_sha256:
raise CommandException(
'gsutil client error: encryption key SHA256 (%s) in tracker file '
'does not match encryption key SHA256 (%s) of component %s' %
(existing_enc_key_sha256, encryption_key_sha256,
component.object_name))
newly_completed_components = [component]
completed_components = existing_components + newly_completed_components
WriteParallelUploadTrackerFile(tracker_file_name,
prefix,
completed_components,
encryption_key_sha256=encryption_key_sha256)
def WriteParallelUploadTrackerFile(tracker_file_name,
prefix,
components,
encryption_key_sha256=None):
"""Writes information about components that were successfully uploaded.
The tracker file is serialized JSON of the form:
{
"encryption_key_sha256": sha256 hash of encryption key (or null),
"prefix": Prefix used for the component objects,
"components": [
{
"component_name": Component object name,
"component_generation": Component object generation (or null),
}, ...
]
}
where N is the number of components that have been successfully uploaded.
This function is not thread-safe and must be protected by a lock if
called within Command.Apply.
Args:
tracker_file_name: The name of the parallel upload tracker file.
prefix: The generated prefix that used for uploading any existing
components.
components: A list of ObjectFromTracker objects that were uploaded.
encryption_key_sha256: Encryption key SHA256 for use in this upload, if any.
"""
if six.PY3:
if isinstance(encryption_key_sha256, bytes):
encryption_key_sha256 = encryption_key_sha256.decode('ascii')
tracker_components = []
for component in components:
tracker_components.append({
_CompositeUploadTrackerEntry.COMPONENT_NAME: component.object_name,
_CompositeUploadTrackerEntry.COMPONENT_GENERATION: component.generation
})
tracker_file_data = {
_CompositeUploadTrackerEntry.COMPONENTS_LIST: tracker_components,
_CompositeUploadTrackerEntry.ENC_SHA256: encryption_key_sha256,
_CompositeUploadTrackerEntry.PREFIX: prefix
}
WriteJsonDataToTrackerFile(tracker_file_name, tracker_file_data)
| apache-2.0 | -5,276,166,415,215,530,000 | 39.891447 | 80 | 0.690773 | false |
LuyaoHuang/depend-test-framework | examples/vm_basic_doc.py | 1 | 1635 | from utils import STEPS, RESULT, SETUP
import copy
# TODO: use a class for this
DEFAULT = {
'memory': 1048576,
'uuid': 'c156ca6f-3c16-435b-980d-9745e1d84ad1',
'name': 'vm1',
'id': 1,
}
def start_guest(params, env):
"""
Start guest
"""
params.doc_logger.info(STEPS + "# virsh start %s" % params.guest_name)
params.doc_logger.info(RESULT + "Domain %s started" % params.guest_name)
# TODO: move this to another place, since the auto part will need this also
info = dict(env.get_data('$guest_name.config').data)
env.set_data('$guest_name.active', info)
def destroy_guest(params, env):
"""
Destory guest
"""
params.doc_logger.info(STEPS + "# virsh destroy %s" % params.guest_name)
params.doc_logger.info(RESULT + "Domain %s destroyed" % params.guest_name)
def define_guest(params, env):
"""
define a new guest
"""
params.doc_logger.info(STEPS + "# virsh define %s" % params.guest_xml)
params.doc_logger.info(RESULT + "Domain %s defined from %s" % (params.guest_name,
params.guest_xml))
info = dict(DEFAULT)
# TODO: support store mutli domain info
if params.guest_name:
info['name'] = params.guest_name
if params.guest_memory:
info['memory'] = params.guest_memory
env.set_data('$guest_name.config', info)
def undefine_guest(params, env):
"""
undefine guest
"""
params.doc_logger.info(STEPS + "# virsh undefine %s" % params.guest_name)
params.doc_logger.info(RESULT + "Domain %s has been undefined" % (params.guest_name))
| mit | 8,700,338,535,210,262,000 | 29.849057 | 89 | 0.615902 | false |
Nextdoor/ndscheduler | ndscheduler/corescheduler/job.py | 1 | 3499 | """Base class for a job."""
import os
import socket
from ndscheduler.corescheduler import utils
class JobBase:
def __init__(self, job_id, execution_id):
self.job_id = job_id
self.execution_id = execution_id
@classmethod
def create_test_instance(cls):
"""Creates an instance of this class for testing."""
return cls(None, None)
@classmethod
def get_scheduled_description(cls):
hostname = socket.gethostname()
pid = os.getpid()
return 'hostname: %s | pid: %s' % (hostname, pid)
@classmethod
def get_scheduled_error_description(cls):
hostname = socket.gethostname()
pid = os.getpid()
return 'hostname: %s | pid: %s' % (hostname, pid)
@classmethod
def get_running_description(cls):
hostname = socket.gethostname()
pid = os.getpid()
return 'hostname: %s | pid: %s' % (hostname, pid)
@classmethod
def get_failed_description(cls):
hostname = socket.gethostname()
pid = os.getpid()
return 'hostname: %s | pid: %s' % (hostname, pid)
@classmethod
def get_succeeded_description(cls, result=None):
hostname = socket.gethostname()
pid = os.getpid()
return 'hostname: %s | pid: %s' % (hostname, pid)
@classmethod
def get_scheduled_error_result(cls):
return utils.get_stacktrace()
@classmethod
def get_failed_result(cls):
return utils.get_stacktrace()
@classmethod
def meta_info(cls):
"""Returns meta info for this job class.
For example:
{
'job_class_string': 'myscheduler.jobs.myjob.MyJob',
'arguments': [
{'type': 'string', 'description': 'name of this channel'},
{'type': 'string', 'description': 'what this channel does'},
{'type': 'int', 'description': 'created year'}
],
'example_arguments': '["music channel", "it's an awesome channel", 1997]',
'notes': 'need to specify environment variable API_KEY first'
}
The arguments property should be consistent with the run() method.
This info will be used in web ui for explaining what kind of arguments is needed for a job.
You should override this function if you want to make your scheduler web ui informative :)
:return: meta info for this job class.
:rtype: dict
"""
return {
'job_class_string': '%s.%s' % (cls.__module__, cls.__name__),
'arguments': [],
'example_arguments': '',
'notes': ''
}
@classmethod
def run_job(cls, job_id, execution_id, *args, **kwargs):
"""Wrapper to run this job in a static context.
:param str job_id: Job id.
:param str execution_id: Execution id.
:param args:
:param kwargs:
"""
job = cls(job_id, execution_id)
return job.run(*args, **kwargs)
def run(self, *args, **kwargs):
"""The "main" function for a job.
Any subclass has to implement this function.
The return value of this function will be stored in the database as json formatted string
and will be shown for each execution in web ui.
:param args:
:param kwargs:
:return: None or json serializable object.
"""
raise NotImplementedError('Please implement this function')
| bsd-2-clause | -5,716,953,715,774,555,000 | 32.32381 | 99 | 0.577022 | false |
bloer/bgexplorer | bgexplorer/modelviewer/modelviewer.py | 1 | 25907 | #python 2/3 compatibility
from __future__ import (absolute_import, division,
print_function, unicode_literals)
from itertools import chain
from flask import (Blueprint, render_template, request, abort, url_for, g,
Response, make_response, current_app)
import threading
import zlib
import json
import numpy as np
from uncertainties import unumpy
from math import ceil, log10
from io import BytesIO
try:
from matplotlib.figure import Figure
except ImportError:
Figure = None
from bson import ObjectId
from .. import utils
from ..dbview import SimsDbView
from . import billofmaterials as bomfuncs
from ..modeldb import InMemoryCacher
from bgmodelbuilder import units
import logging
log = logging.getLogger(__name__)
from time import sleep
def make_etag(model):
""" Generate a string to use as an etag """
try:
return f"{model.id}-{model.editDetails['date']}"
except AttributeError:
# this should be a dictionary...
return f"{model['_id']}-{model['editDetails']['date']}"
class ModelViewer(object):
"""Blueprint for inspecting saved model definitions
Args:
app: The bgexplorer Flask object
modeldb: a ModelDB object. If None, will get from the Flask object
url_prefix (str): Where to mount this blueprint relative to root
"""
defaultversion='HEAD'
joinkey='___'
def __init__(self, app=None, modeldb=None,
cacher=InMemoryCacher(), url_prefix='/explore'):
self.app = app
self._modeldb = modeldb
self.bp = Blueprint('modelviewer', __name__,
static_folder='static',
template_folder='templates',
url_prefix='/<modelname>/<version>')
self.bp.add_app_template_global(lambda : self, 'getmodelviewer')
self.set_url_processing()
self.register_endpoints()
if self.app:
self.init_app(app, url_prefix)
self._threads = {}
self._cacher = cacher
#### User Overrides ####
self.bomcols = bomfuncs.getdefaultcols()
def init_app(self, app, url_prefix=''):
"""Register ourselves with the app"""
app.register_blueprint(self.bp,
url_prefix=url_prefix+self.bp.url_prefix)
app.extensions['ModelViewer'] = self
@property
def modeldb(self):
return self._modeldb or utils.get_modeldb()
@property
def simsdb(self):
return g.simsdbview.simsdb
def set_url_processing(self):
"""process model objects into URL strings, and pre-load models
into the `flask.g` object before passing to endpoint functions
"""
@self.bp.after_request
def addpostheaders(response):
""" Add cache-control headers to all modelviewer responses """
if self.app.config.get('NO_CLIENT_CACHE'):
return
# todo: add Last-Modified
response.headers["Cache-Control"] = "private, max-age=100"
try:
response.headers['ETag'] = make_etag(g.model)
except (AttributeError, KeyError): # model is not loaded in g
pass
return response
@self.bp.url_defaults
def add_model(endpoint, values):
model = values.pop('model', None) or g.get('model', None)
if model:
#model could be object or dict
name = getattr(model,'name', None) or model.get('name',None)
version = getattr(model,'version', None)
if version is None and hasattr(model,'get'):
version = model.get('version',None)
values.setdefault('modelname', name)
permalink = values.pop('permalink',None)
if permalink is not None:
values['version'] = (version if permalink
else self.defaultversion)
else:
values.setdefault('version',
version if not g.get('permalink')
else self.defaultversion)
elif 'modelid' in values:
values['modelname'] = values.pop('modelid')
values['version'] = '_'
values['permalink'] = 1
#transform components, specs into IDs
if 'component' in values:
values['componentid'] = values.pop('component').id
if 'spec' in values:
values['specid'] = values.pop('spec').getrootspec().id
if 'match' in values:
values['matchid'] = values.pop('match').id
@self.bp.url_value_preprocessor
def find_model(endpoint, values):
# URL has different formats that result in different queries
query = None
if 'modelid' in values:
query = values.pop('modelid')
elif 'modelname' in values:
query={'name': values.pop('modelname')}
version = values.pop('version',self.defaultversion)
if version == '_': #special, means name is actually ID
query['_id'] = query.pop('name')
elif version != self.defaultversion:
query['version'] = version
if not query:
abort(400, "Incomplete model specification")
# this function is called before `before_requests`, but we don't
# want to extract the model if the client requested a cached
# view. So we have to do the cache checking here
etagreq = request.headers.get('If-None-Match')
if etagreq and not self.app.config.get('NO_CLIENT_CACHE'):
# construct the etag from the DB entry
projection = {'editDetails.date': True}
modeldict = self.modeldb.get_raw_model(query, projection)
etag = make_etag(modeldict)
if etagreq == etag:
abort(make_response('', '304 Not Modified',{'ETag': etag}))
# if we get here, it's not in client cache
g.model = utils.getmodelordie(query,self.modeldb)
if version == self.defaultversion:
g.permalink = url_for(endpoint, permalink=True,
**values)
g.simsdbview = utils.get_simsdbview(model=g.model)
#construct the cached datatable in the background
if self._cacher:
self.build_datatable(g.model)
def register_endpoints(self):
"""Define the view functions here"""
@self.bp.route('/')
def overview():
history = self.modeldb.get_model_history(g.model.id)
return render_template('overview.html', history=history)
@self.bp.route('/component/')
@self.bp.route('/component/<componentid>') #should be uuid type?
def componentview(componentid=None):
if componentid:
component = utils.getcomponentordie(g.model, componentid)
matches = g.model.getsimdata(component=component)
datasets = sum((m.dataset or [] for m in matches), [])
return render_template("componentview.html",
component=component, datasets=datasets)
else:
return render_template("componentsoverview.html")
@self.bp.route('/emissions/')
def emissionsoverview():
rootspecs = [ s for s in g.model.specs.values() if not s.parent]
return render_template("emissionsoverview.html",
rootspecs=rootspecs)
@self.bp.route('/emission/<specid>')
def emissionview(specid):
spec = utils.getspecordie(g.model, specid)
#find all simulation datasets associated to this spec
matches = []
if spec.getrootspec() == spec:
matches = g.model.getsimdata(rootspec=spec)
else:
matches = g.model.getsimdata(spec=spec)
datasets = sum((m.dataset or [] for m in matches), [])
return render_template('emissionview.html', spec=spec,
matches=matches, datasets=datasets)
@self.bp.route('/simulations/')
def simulationsoverview():
return render_template("simulationsoverview.html")
@self.bp.route('/queries/')
def queriesoverview():
#build a unique list of all queries
queries = {}
for m in g.model.getsimdata():
key = str(m.query)
if key not in queries:
queries[key] = []
queries[key].append(m)
return render_template('queriesoverview.html',queries=queries)
@self.bp.route('/dataset/<dataset>')
def datasetview(dataset):
detail = self.simsdb.getdatasetdetails(dataset)
return render_template("datasetview.html", dataset=dataset,
detail = detail)
@self.bp.route('/simdatamatch/<matchid>')
def simdatamatchview(matchid):
match = utils.getsimdatamatchordie(g.model, matchid)
linkspec = match.spec.getrootspec()
return render_template("simdatamatchview.html", match=match)
@self.bp.route('/billofmaterials')
def billofmaterials():
bomrows = bomfuncs.getbomrows()
return render_template("billofmaterials.html",
bomrows=bomrows,
bomcols=self.bomcols)
@self.bp.route('/datatable')
def datatable():
"""Return groups and values for all simdatamatches"""
return self.get_datatable(g.model)
@self.bp.route('/tables/default')
def tablesdefault():
"""Show some default tables with the calculated rows"""
return render_template("tablesdefault.html")
@self.bp.route('/charts/default')
def chartsdefault():
"""Show some default charts with the calculated rates"""
return render_template("chartsdefault.html")
@self.bp.route('/spectra/default')
def spectradefault():
return render_template("spectradefault.html")
@self.bp.route('/export')
def export():
"""Present the model as a JSON document"""
d = g.model.todict()
#replace ObjectIds with strings
if isinstance(d.get('_id'), ObjectId):
d['_id'] = str(d['_id'])
if isinstance(d.get('derivedFrom'), ObjectId):
d['derivedFrom'] = str(d['derivedFrom'])
return Response(json.dumps(d), mimetype="application/json")
@self.bp.route('/getspectrum')
@self.bp.route('/getspectrum/<specname>')
def getspectrum(specname=None):
# get the generator for the spectrum
if not specname:
valname = request.args.get('val')
if not valname:
abort(404, "Either spectrum name or value name is required")
specname = g.simsdbview.values_spectra.get(valname)
if not specname:
# valname might have a unit suffix applied to it
index = valname.rfind(' [')
valname = valname[:index]
specname = g.simsdbview.values_spectra.get(valname)
if not specname:
abort(404, f"No spectrum associated to value '{valname}'")
speceval = g.simsdbview.spectra.get(specname)
if speceval is None:
abort(404, f"No spectrum generator for '{specname}'")
log.debug(f"Generating spectrum: {specname}")
title = specname
# get the matches
matches = request.args.getlist('m')
try:
matches = [g.model.simdata[m] for m in matches]
except KeyError:
abort(404, "Request for unknown sim data match")
if not matches:
# matches may be filtered by component or spec
component = None
if 'componentid' in request.args:
component = utils.getcomponentordie(g.model,
request.args['componentid'])
title += ", Component = "+component.name
rootspec = None
if 'specid' in request.args:
rootspec = utils.getspecordie(g.model,
request.args['specid'])
title += ", Source = "+rootspec.name
matches = g.model.getsimdata(rootcomponent=component, rootspec=rootspec)
# test for a group filter
groupname = request.args.get('groupname')
groupval = request.args.get('groupval')
if groupname and groupval and groupval != g.simsdbview.groupjoinkey:
try:
groupfunc = g.simsdbview.groups[groupname]
except KeyError:
abort(404, f"No registered grouping function {groupname}")
def _filter_group(match):
mgval = g.simsdbview.evalgroup(match, groupname, False)
return g.simsdbview.is_subgroup(mgval, groupval)
matches = list(filter(_filter_group, matches))
title += ", "+groupname+" = "
title += '/'.join(g.simsdbview.unflatten_gval(groupval, True))
if not matches:
abort(404, "No sim data matching query")
spectrum = self.simsdb.evaluate([speceval], matches)[0]
if not hasattr(spectrum, 'hist') or not hasattr(spectrum, 'bin_edges'):
abort(500, f"Error generating spectrum, got {type(spectrum)}")
unit = g.simsdbview.spectra_units.get(specname, None)
if unit is not None:
try:
spectrum.hist.ito(unit)
except AttributeError: #not a quantity
pass
fmt = request.args.get("format", "png").lower()
response = None
if fmt == 'tsv':
response = Response(self.streamspectrum(spectrum, sep='\t'),
mimetype='text/tab-separated-value')
elif fmt == 'csv':
response = Response(self.streamspectrum(spectrum, sep=','),
mimetype='text/csv')
elif fmt == 'png':
response = self.specimage(spectrum, title=title)
else:
abort(400, f"Unhandled format specifier {fmt}")
return response
def streamspectrum(self, spectrum, sep=',', include_errs=True,
fmt='{:.5g}'):
""" Return a generator response for a spectrum
Args:
spectrum (Histogram): spectrum to stream
sep (str): separator (e.g. csv or tsv)
include_errs (bool): if True, include a column for errors
fmt (str): format specifier
Returns:
generator to construct Response
"""
bins, vals = spectrum.bin_edges, spectrum.hist
vals_has_units = hasattr(vals, 'units')
bins_has_units = hasattr(bins, 'units')
# yield the header
head = ["Bin", "Value"]
if bins_has_units:
head[0] += f' [{bins.units}]'
if vals_has_units:
head[1] += f' [{vals.units}]'
if include_errs:
head.append('Error')
yield sep.join(head)+'\n'
# now remove units and extract errors
if vals_has_units:
vals = vals.m
if bins_has_units:
bins = bins.m
vals, errs = unumpy.nominal_values(vals), unumpy.std_devs(vals)
for abin, aval, anerr in zip(bins, vals, errs):
yield sep.join((str(abin), fmt.format(aval), fmt.format(anerr)))+'\n'
def specimage(self, spectrum, title=None, logx=True, logy=True):
""" Generate a png image of a spectrum
Args:
spectrum (Histogram): spectrum to plot
title (str): title
logx (bool): set x axis to log scale
logy (bool): set y axis to log scale
Returns:
a Response object
"""
if Figure is None:
abort(500, "Matplotlib is not available")
log.debug("Generating spectrum image")
# apparently this aborts sometimes?
try:
x = spectrum.bin_edges.m
except AttributeError:
x = spectrum.bin_edges
fig = Figure()
ax = fig.subplots()
ax.errorbar(x=x[:-1],
y=unumpy.nominal_values(spectrum.hist),
yerr=unumpy.std_devs(spectrum.hist),
drawstyle='steps-post',
elinewidth=0.6,
)
ax.set_title(title)
if logx:
ax.set_xscale('log')
if logy:
ax.set_yscale('log')
if hasattr(spectrum.bin_edges, 'units'):
ax.set_xlabel(f'Bin [{spectrum.bin_edges.units}]')
if hasattr(spectrum.hist, 'units'):
ax.set_ylabel(f"Value [{spectrum.hist.units}]")
"""
#limit to at most N decades...
maxrange = 100000
ymin, ymax = plt.ylim()
ymax = 10**ceil(log10(ymax))
ymin = max(ymin, ymax/maxrange)
plt.ylim(ymin, ymax)
plt.tick_params(which='major',length=6, width=1)
plt.tick_params(which='minor',length=4,width=1)
iplt.gcf().set_size_inches(9,6)
plt.gca().set_position((0.08,0.1,0.7,0.8))
"""
log.debug("Rendering...")
out = BytesIO()
fig.savefig(out, format='png')
log.debug("Done generating image")
size = out.tell()
out.seek(0)
res = Response(out.getvalue(),
content_type='image/png',
headers={'Content-Length': size,
'Content-Disposition': 'inline',
},
)
return res
#need to pass simsdb because it goes out of context
def streamdatatable(self, model, simsdbview=None):
"""Stream exported data table so it doesn't all go into mem at once
"""
log.debug(f"Generating data table for model {model.id}")
#can't evaluate values if we don't have a simsdb
if simsdbview is None:
simsdbview = utils.get_simsdbview(model=model) or SimsDbView()
simsdb = simsdbview.simsdb
valitems = list(simsdbview.values.values())
matches = model.simdata.values()
#send the header
valheads = ['V_'+v+(' [%s]'%simsdbview.values_units[v]
if v in simsdbview.values_units else '')
for v in simsdbview.values]
yield('\t'.join(chain(['ID'],
('G_'+g for g in simsdbview.groups),
valheads))
+'\n')
#loop through matches
for match in matches:
evals = []
if valitems:
evals = simsdb.evaluate(valitems, match)
for index, vlabel in enumerate(simsdbview.values):
# convert to unit if provided
unit = simsdbview.values_units.get(vlabel,None)
if unit:
try:
evals[index] = evals[index].to(unit).m
except AttributeError: #not a Quantity...
pass
except units.errors.DimensionalityError as e:
if evals[index] != 0 :
log.warning(e)
evals[index] = getattr(evals[index], 'm', 0)
# convert to string
evals[index] = "{:.3g}".format(evals[index])
if match.spec.islimit:
evals[index] = '<'+evals[index]
groupvals = (g(match) for g in simsdbview.groups.values())
groupvals = (simsdbview.groupjoinkey.join(g)
if isinstance(g,(list,tuple)) else g
for g in groupvals)
yield('\t'.join(chain([match.id],
(str(g) for g in groupvals),
evals))
+'\n')
#sleep(0.2) # needed to release the GIL
log.debug(f"Finished generating data table for model {model.id}")
@staticmethod
def datatablekey(model):
return "datatable:"+make_etag(model)
def build_datatable(self, model):
"""Generate a gzipped datatable and cache it
Args:
model: a BgModel
Returns:
None if no cacher is defined
0 if the result is already cached
Thread created to generate the cache otherwise
"""
#don't bother to call if we don't have a cache
if not self._cacher:
return None
#TODO: self._threads and self._Cacher should probably be mutexed
#see if there's already a worker
key = self.datatablekey(model)
if key in self._threads:
return self._threads[key]
#see if it's already cached
if self._cacher.test(key):
return 0
#if we get here, we need to generate it
def cachedatatable(dbview):
compressor = zlib.compressobj()
res = b''.join(compressor.compress(s.encode('utf-8'))
for s in self.streamdatatable(model, dbview))
res += compressor.flush()
self._cacher.store(key, res)
self._threads.pop(key) #is this a bad idea???
dbview = utils.get_simsdbview(model=model)
thread = threading.Thread(target=cachedatatable,name=key,
args=(dbview,))
self._threads[key] = thread
thread.start()
return thread
def get_datatable(self, model):
"""Return a Result object with the encoded or streamed datatable"""
key = self.datatablekey(model)
if not self._cacher: # or self.modeldb.is_model_temp(model.id):
#no cache, so stream it directly, don't bother to zip it
#should really be text/csv, but then browsersr won't let you see it
return Response(self.streamdatatable(model), mimetype='text/plain')
if not self._cacher.test(key):
thread = self.build_datatable(model)
if thread:
thread.join() #wait until it's done
res = self._cacher.get(key)
if not res:
abort(500,"Unable to generate datatable")
return Response(res, headers={'Content-Type':'text/plain;charset=utf-8',
'Content-Encoding':'deflate',
})
def get_componentsort(self, component, includeself=True):
"""Return an array component names in assembly order to be passed
to the javascript analyzer for sorting component names
"""
#TODO: cache this
result = [component.name] if includeself else []
for child in component.getcomponents(merge=False):
branches = self.get_componentsort(child)
if includeself:
branches = [self.joinkey.join((component.name, s))
for s in branches]
result.extend(branches)
return result
def get_groupsort(self):
res = dict(**g.simsdbview.groupsort)
#todo: set up provided lists
if 'Component' not in res:
res['Component'] = self.get_componentsort(g.model.assemblyroot, False)
return res
def eval_matches(self, matches, dovals=True, dospectra=False):
""" Evaluate `matches` for all registered values and specs
Args:
matches: list of SimDataMatch objects to evaluate
dovals (bool): include entries from `self.values` ?
dospectra (bool): include entries from `self.spectra` ?
Returns:
values (dict): dictionary mapping of keys in `self.values` and
`self.spectra` to evaluated results. If a key in
`spectra` conflicts with one in values, it will be
renamed to "spectrum_<key>"
"""
# this no longer works, but wasn't used. Keep around for now...
raise NotImplementedError()
vals = dict(**self.values) if dovals else {}
if dospectra:
for key, spectrum in self.spectra.items():
if key in vals:
key = f'spectrum_{key}'
vals[key] = spectrum
result = dict(zip(vals.keys(),
self.simsdb.evaluate(vals.values(), matches)))
if dovals:
for key, unit in self.values_units.items():
try:
result[key].ito(unit)
except AttributeError:
pass
if dospectra:
for key, unit in self.spectra_units.items():
if dovals and key in self.values:
key = f'spectrum_{key}'
try:
result[key].ito(unit)
except AttributeError:
pass
return result
| bsd-2-clause | 1,891,880,198,293,276,000 | 38.979938 | 88 | 0.53557 | false |
michaelchughes/satdetect | satdetect/ioutil/IOUtil.py | 1 | 2151 | ''' IOUtil.py
'''
import os
import numpy as np
import glob
import joblib
import scipy.io
from skimage.data import imread
from distutils.dir_util import mkpath
def imgpath2list(imgpath):
''' Transform provided path (or path pattern) into a list of valid paths
Args
-------
imgpath : list or string
either exact jpeg path ('/path/to/myfile.jpg')
or pattern to be read by glob ('/path/to/manyfiles/*.jpg')
Returns
--------
imgpathList : list of valid paths on this system
'''
## Remove backslashes from imgpath,
## since these are sometimes added by terminal
if type(imgpath) == str:
imgpath = imgpath.replace('\\', '')
if type(imgpath) == list:
imgpathList = imgpath
elif imgpath.count('*') > 0:
imgpathList = glob.glob(imgpath)
else:
imgpathList = [imgpath]
return imgpathList
def getFilepathParts(path):
''' Transform string defining a filesystem absolute path into component parts
Example
---------
>> getFilepathParts('/data/mhughes/myimage.jpg')
('/data/mhughes/', 'myimage', '.jpg')
'''
pathdirs = path.split(os.path.sep)
pathdir = os.path.sep.join(pathdirs[:-1])
basefields = pathdirs[-1].split('.')
basename = basefields[0]
ext = '.' + basefields[1]
return pathdir, basename, ext
def loadImage(path, basename='', color='rgb'):
''' Load JPEG image from file,
Returns
--------
IM : 2D or 3D array, size H x W x nColors
dtype will be float64, with each pixel in range (0,1)
'''
path = str(path)
if len(basename) > 0:
path = os.path.join(path, basename)
if color == 'gray' or color == 'grey':
IM = imread(path, as_grey=True)
assert IM.ndim == 2
else:
IM = imread(path, as_grey=False)
if not IM.ndim == 3:
raise ValueError('Color image not available.')
if IM.dtype == np.float:
MaxVal = 1.0
elif IM.dtype == np.uint8:
MaxVal = 255
else:
raise ValueError("Unrecognized dtype: %s" % (IM.dtype))
assert IM.min() >= 0.0
assert IM.max() <= MaxVal
IM = np.asarray(IM, dtype=np.float64)
if MaxVal > 1:
IM /= MaxVal
return IM | mit | 501,435,163,611,969,660 | 24.927711 | 79 | 0.623896 | false |
ericholscher/django | django/core/management/__init__.py | 1 | 15955 | import collections
import imp
from importlib import import_module
from optparse import OptionParser, NO_DEFAULT
import os
import sys
from django.core.exceptions import ImproperlyConfigured
from django.core.management.base import BaseCommand, CommandError, handle_default_options
from django.core.management.color import color_style
from django.utils import six
# For backwards compatibility: get_version() used to be in this module.
from django import get_version
# A cache of loaded commands, so that call_command
# doesn't have to reload every time it's called.
_commands = None
def find_commands(management_dir):
"""
Given a path to a management directory, returns a list of all the command
names that are available.
Returns an empty list if no commands are defined.
"""
command_dir = os.path.join(management_dir, 'commands')
try:
return [f[:-3] for f in os.listdir(command_dir)
if not f.startswith('_') and f.endswith('.py')]
except OSError:
return []
def find_management_module(app_name):
"""
Determines the path to the management module for the given app_name,
without actually importing the application or the management module.
Raises ImportError if the management module cannot be found for any reason.
"""
parts = app_name.split('.')
parts.append('management')
parts.reverse()
part = parts.pop()
path = None
# When using manage.py, the project module is added to the path,
# loaded, then removed from the path. This means that
# testproject.testapp.models can be loaded in future, even if
# testproject isn't in the path. When looking for the management
# module, we need look for the case where the project name is part
# of the app_name but the project directory itself isn't on the path.
try:
f, path, descr = imp.find_module(part, path)
except ImportError as e:
if os.path.basename(os.getcwd()) != part:
raise e
else:
if f:
f.close()
while parts:
part = parts.pop()
f, path, descr = imp.find_module(part, [path] if path else None)
if f:
f.close()
return path
def load_command_class(app_name, name):
"""
Given a command name and an application name, returns the Command
class instance. All errors raised by the import process
(ImportError, AttributeError) are allowed to propagate.
"""
module = import_module('%s.management.commands.%s' % (app_name, name))
return module.Command()
def get_commands():
"""
Returns a dictionary mapping command names to their callback applications.
This works by looking for a management.commands package in django.core, and
in each installed application -- if a commands package exists, all commands
in that package are registered.
Core commands are always included. If a settings module has been
specified, user-defined commands will also be included.
The dictionary is in the format {command_name: app_name}. Key-value
pairs from this dictionary can then be used in calls to
load_command_class(app_name, command_name)
If a specific version of a command must be loaded (e.g., with the
startapp command), the instantiated module can be placed in the
dictionary in place of the application name.
The dictionary is cached on the first call and reused on subsequent
calls.
"""
global _commands
if _commands is None:
_commands = dict((name, 'django.core') for name in find_commands(__path__[0]))
# Find the installed apps
from django.conf import settings
try:
apps = settings.INSTALLED_APPS
except ImproperlyConfigured:
# Still useful for commands that do not require functional settings,
# like startproject or help
apps = []
# Find and load the management module for each installed app.
for app_name in apps:
try:
path = find_management_module(app_name)
_commands.update(dict((name, app_name)
for name in find_commands(path)))
except ImportError:
pass # No management module - ignore this app
return _commands
def call_command(name, *args, **options):
"""
Calls the given command, with the given options and args/kwargs.
This is the primary API you should use for calling specific commands.
Some examples:
call_command('syncdb')
call_command('shell', plain=True)
call_command('sqlall', 'myapp')
"""
# Load the command object.
try:
app_name = get_commands()[name]
except KeyError:
raise CommandError("Unknown command: %r" % name)
if isinstance(app_name, BaseCommand):
# If the command is already loaded, use it directly.
klass = app_name
else:
klass = load_command_class(app_name, name)
# Grab out a list of defaults from the options. optparse does this for us
# when the script runs from the command line, but since call_command can
# be called programmatically, we need to simulate the loading and handling
# of defaults (see #10080 for details).
defaults = {}
for opt in klass.option_list:
if opt.default is NO_DEFAULT:
defaults[opt.dest] = None
else:
defaults[opt.dest] = opt.default
defaults.update(options)
return klass.execute(*args, **defaults)
class LaxOptionParser(OptionParser):
"""
An option parser that doesn't raise any errors on unknown options.
This is needed because the --settings and --pythonpath options affect
the commands (and thus the options) that are available to the user.
"""
def error(self, msg):
pass
def print_help(self):
"""Output nothing.
The lax options are included in the normal option parser, so under
normal usage, we don't need to print the lax options.
"""
pass
def print_lax_help(self):
"""Output the basic options available to every command.
This just redirects to the default print_help() behavior.
"""
OptionParser.print_help(self)
def _process_args(self, largs, rargs, values):
"""
Overrides OptionParser._process_args to exclusively handle default
options and ignore args and other options.
This overrides the behavior of the super class, which stop parsing
at the first unrecognized option.
"""
while rargs:
arg = rargs[0]
try:
if arg[0:2] == "--" and len(arg) > 2:
# process a single long option (possibly with value(s))
# the superclass code pops the arg off rargs
self._process_long_opt(rargs, values)
elif arg[:1] == "-" and len(arg) > 1:
# process a cluster of short options (possibly with
# value(s) for the last one only)
# the superclass code pops the arg off rargs
self._process_short_opts(rargs, values)
else:
# it's either a non-default option or an arg
# either way, add it to the args list so we can keep
# dealing with options
del rargs[0]
raise Exception
except: # Needed because we might need to catch a SystemExit
largs.append(arg)
class ManagementUtility(object):
"""
Encapsulates the logic of the django-admin.py and manage.py utilities.
A ManagementUtility has a number of commands, which can be manipulated
by editing the self.commands dictionary.
"""
def __init__(self, argv=None):
self.argv = argv or sys.argv[:]
self.prog_name = os.path.basename(self.argv[0])
def main_help_text(self, commands_only=False):
"""
Returns the script's main help text, as a string.
"""
if commands_only:
usage = sorted(get_commands().keys())
else:
usage = [
"",
"Type '%s help <subcommand>' for help on a specific subcommand." % self.prog_name,
"",
"Available subcommands:",
]
commands_dict = collections.defaultdict(lambda: [])
for name, app in six.iteritems(get_commands()):
if app == 'django.core':
app = 'django'
else:
app = app.rpartition('.')[-1]
commands_dict[app].append(name)
style = color_style()
for app in sorted(commands_dict.keys()):
usage.append("")
usage.append(style.NOTICE("[%s]" % app))
for name in sorted(commands_dict[app]):
usage.append(" %s" % name)
# Output an extra note if settings are not properly configured
try:
from django.conf import settings
settings.INSTALLED_APPS
except ImproperlyConfigured as e:
usage.append(style.NOTICE(
"Note that only Django core commands are listed as settings "
"are not properly configured (error: %s)." % e))
return '\n'.join(usage)
def fetch_command(self, subcommand):
"""
Tries to fetch the given subcommand, printing a message with the
appropriate command called from the command line (usually
"django-admin.py" or "manage.py") if it can't be found.
"""
# Get commands outside of try block to prevent swallowing exceptions
commands = get_commands()
try:
app_name = commands[subcommand]
except KeyError:
sys.stderr.write("Unknown command: %r\nType '%s help' for usage.\n" %
(subcommand, self.prog_name))
sys.exit(1)
if isinstance(app_name, BaseCommand):
# If the command is already loaded, use it directly.
klass = app_name
else:
klass = load_command_class(app_name, subcommand)
return klass
def autocomplete(self):
"""
Output completion suggestions for BASH.
The output of this function is passed to BASH's `COMREPLY` variable and
treated as completion suggestions. `COMREPLY` expects a space
separated string as the result.
The `COMP_WORDS` and `COMP_CWORD` BASH environment variables are used
to get information about the cli input. Please refer to the BASH
man-page for more information about this variables.
Subcommand options are saved as pairs. A pair consists of
the long option string (e.g. '--exclude') and a boolean
value indicating if the option requires arguments. When printing to
stdout, a equal sign is appended to options which require arguments.
Note: If debugging this function, it is recommended to write the debug
output in a separate file. Otherwise the debug output will be treated
and formatted as potential completion suggestions.
"""
# Don't complete if user hasn't sourced bash_completion file.
if 'DJANGO_AUTO_COMPLETE' not in os.environ:
return
cwords = os.environ['COMP_WORDS'].split()[1:]
cword = int(os.environ['COMP_CWORD'])
try:
curr = cwords[cword-1]
except IndexError:
curr = ''
subcommands = list(get_commands()) + ['help']
options = [('--help', None)]
# subcommand
if cword == 1:
print(' '.join(sorted(filter(lambda x: x.startswith(curr), subcommands))))
# subcommand options
# special case: the 'help' subcommand has no options
elif cwords[0] in subcommands and cwords[0] != 'help':
subcommand_cls = self.fetch_command(cwords[0])
# special case: 'runfcgi' stores additional options as
# 'key=value' pairs
if cwords[0] == 'runfcgi':
from django.core.servers.fastcgi import FASTCGI_OPTIONS
options += [(k, 1) for k in FASTCGI_OPTIONS]
# special case: add the names of installed apps to options
elif cwords[0] in ('dumpdata', 'sql', 'sqlall', 'sqlclear',
'sqlcustom', 'sqlindexes', 'sqlsequencereset', 'test'):
try:
from django.conf import settings
# Get the last part of the dotted path as the app name.
options += [(a.split('.')[-1], 0) for a in settings.INSTALLED_APPS]
except ImportError:
# Fail silently if DJANGO_SETTINGS_MODULE isn't set. The
# user will find out once they execute the command.
pass
options += [(s_opt.get_opt_string(), s_opt.nargs) for s_opt in
subcommand_cls.option_list]
# filter out previously specified options from available options
prev_opts = [x.split('=')[0] for x in cwords[1:cword-1]]
options = [opt for opt in options if opt[0] not in prev_opts]
# filter options by current input
options = sorted((k, v) for k, v in options if k.startswith(curr))
for option in options:
opt_label = option[0]
# append '=' to options which require args
if option[1]:
opt_label += '='
print(opt_label)
sys.exit(1)
def execute(self):
"""
Given the command-line arguments, this figures out which subcommand is
being run, creates a parser appropriate to that command, and runs it.
"""
# Preprocess options to extract --settings and --pythonpath.
# These options could affect the commands that are available, so they
# must be processed early.
parser = LaxOptionParser(usage="%prog subcommand [options] [args]",
version=get_version(),
option_list=BaseCommand.option_list)
self.autocomplete()
try:
options, args = parser.parse_args(self.argv)
handle_default_options(options)
except: # Needed because parser.parse_args can raise SystemExit
pass # Ignore any option errors at this point.
try:
subcommand = self.argv[1]
except IndexError:
subcommand = 'help' # Display help if no arguments were given.
if subcommand == 'help':
if len(args) <= 2:
parser.print_lax_help()
sys.stdout.write(self.main_help_text() + '\n')
elif args[2] == '--commands':
sys.stdout.write(self.main_help_text(commands_only=True) + '\n')
else:
self.fetch_command(args[2]).print_help(self.prog_name, args[2])
elif subcommand == 'version':
sys.stdout.write(parser.get_version() + '\n')
# Special-cases: We want 'django-admin.py --version' and
# 'django-admin.py --help' to work, for backwards compatibility.
elif self.argv[1:] == ['--version']:
# LaxOptionParser already takes care of printing the version.
pass
elif self.argv[1:] in (['--help'], ['-h']):
parser.print_lax_help()
sys.stdout.write(self.main_help_text() + '\n')
else:
self.fetch_command(subcommand).run_from_argv(self.argv)
def execute_from_command_line(argv=None):
"""
A simple method that runs a ManagementUtility.
"""
utility = ManagementUtility(argv)
utility.execute()
| bsd-3-clause | -5,019,545,367,211,549,000 | 38.105392 | 98 | 0.59812 | false |
Nexedi/neoppod | neo/neoctl/neoctl.py | 1 | 7980 | #
# Copyright (C) 2006-2019 Nexedi SA
#
# 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, see <http://www.gnu.org/licenses/>.
import argparse
from neo.lib import util
from neo.lib.app import BaseApplication, buildOptionParser
from neo.lib.connection import ClientConnection, ConnectionClosed
from neo.lib.protocol import ClusterStates, NodeStates, ErrorCodes, Packets
from .handler import CommandEventHandler
class NotReadyException(Exception):
pass
@buildOptionParser
class NeoCTL(BaseApplication):
connection = None
connected = False
@classmethod
def _buildOptionParser(cls):
# XXX: Use argparse sub-commands.
parser = cls.option_parser
parser.description = "NEO Control node"
parser('a', 'address', default='127.0.0.1:9999',
parse=lambda x: util.parseNodeAddress(x, 9999),
help="address of an admin node")
parser.argument('cmd', nargs=argparse.REMAINDER,
help="command to execute; if not supplied,"
" the list of available commands is displayed")
def __init__(self, address, **kw):
super(NeoCTL, self).__init__(**kw)
self.server = self.nm.createAdmin(address=address)
self.handler = CommandEventHandler(self)
self.response_queue = []
def __getConnection(self):
if not self.connected:
self.connection = ClientConnection(self, self.handler, self.server)
# Never delay reconnection to master. This speeds up unit tests
# and it should not change anything for normal use.
try:
self.connection.setReconnectionNoDelay()
except ConnectionClosed:
self.connection = None
while not self.connected:
if self.connection is None:
raise NotReadyException('not connected')
self.em.poll(1)
return self.connection
def __ask(self, packet):
# TODO: make thread-safe
connection = self.__getConnection()
connection.ask(packet)
response_queue = self.response_queue
assert len(response_queue) == 0
while self.connected:
self.em.poll(1)
if response_queue:
break
else:
raise NotReadyException, 'Connection closed'
response = response_queue.pop()
if response[0] == Packets.Error and \
response[1] == ErrorCodes.NOT_READY:
raise NotReadyException(response[2])
return response
def enableStorageList(self, uuid_list):
"""
Put all given storage nodes in "running" state.
"""
packet = Packets.AddPendingNodes(uuid_list)
response = self.__ask(packet)
if response[0] != Packets.Error or response[1] != ErrorCodes.ACK:
raise RuntimeError(response)
return response[2]
def tweakPartitionTable(self, uuid_list=(), dry_run=False):
response = self.__ask(Packets.TweakPartitionTable(dry_run, uuid_list))
if response[0] != Packets.AnswerTweakPartitionTable:
raise RuntimeError(response)
return response[1:]
def setNumReplicas(self, nr):
response = self.__ask(Packets.SetNumReplicas(nr))
if response[0] != Packets.Error or response[1] != ErrorCodes.ACK:
raise RuntimeError(response)
return response[2]
def setClusterState(self, state):
"""
Set cluster state.
"""
packet = Packets.SetClusterState(state)
response = self.__ask(packet)
if response[0] != Packets.Error or response[1] != ErrorCodes.ACK:
raise RuntimeError(response)
return response[2]
def _setNodeState(self, node, state):
"""
Kill node, or remove it permanently
"""
response = self.__ask(Packets.SetNodeState(node, state))
if response[0] != Packets.Error or response[1] != ErrorCodes.ACK:
raise RuntimeError(response)
return response[2]
def getClusterState(self):
"""
Get cluster state.
"""
packet = Packets.AskClusterState()
response = self.__ask(packet)
if response[0] != Packets.AnswerClusterState:
raise RuntimeError(response)
return response[1]
def getLastIds(self):
response = self.__ask(Packets.AskLastIDs())
if response[0] != Packets.AnswerLastIDs:
raise RuntimeError(response)
return response[1:]
def getLastTransaction(self):
response = self.__ask(Packets.AskLastTransaction())
if response[0] != Packets.AnswerLastTransaction:
raise RuntimeError(response)
return response[1]
def getRecovery(self):
response = self.__ask(Packets.AskRecovery())
if response[0] != Packets.AnswerRecovery:
raise RuntimeError(response)
return response[1:]
def getNodeList(self, node_type=None):
"""
Get a list of nodes, filtering with given type.
"""
packet = Packets.AskNodeList(node_type)
response = self.__ask(packet)
if response[0] != Packets.AnswerNodeList:
raise RuntimeError(response)
return response[1] # node_list
def getPartitionRowList(self, min_offset=0, max_offset=0, node=None):
"""
Get a list of partition rows, bounded by min & max and involving
given node.
"""
packet = Packets.AskPartitionList(min_offset, max_offset, node)
response = self.__ask(packet)
if response[0] != Packets.AnswerPartitionList:
raise RuntimeError(response)
return response[1:]
def startCluster(self):
"""
Set cluster into "verifying" state.
"""
return self.setClusterState(ClusterStates.VERIFYING)
def killNode(self, node):
return self._setNodeState(node, NodeStates.DOWN)
def dropNode(self, node):
return self._setNodeState(node, NodeStates.UNKNOWN)
def getPrimary(self):
"""
Return the primary master UUID.
"""
packet = Packets.AskPrimary()
response = self.__ask(packet)
if response[0] != Packets.AnswerPrimary:
raise RuntimeError(response)
return response[1]
def repair(self, *args):
response = self.__ask(Packets.Repair(*args))
if response[0] != Packets.Error or response[1] != ErrorCodes.ACK:
raise RuntimeError(response)
return response[2]
def truncate(self, tid):
response = self.__ask(Packets.Truncate(tid))
if response[0] != Packets.Error or response[1] != ErrorCodes.ACK:
raise RuntimeError(response)
return response[2]
def checkReplicas(self, *args):
response = self.__ask(Packets.CheckReplicas(*args))
if response[0] != Packets.Error or response[1] != ErrorCodes.ACK:
raise RuntimeError(response)
return response[2]
def flushLog(self):
conn = self.__getConnection()
conn.send(Packets.FlushLog())
while conn.pending():
self.em.poll(1)
def getMonitorInformation(self):
response = self.__ask(Packets.AskMonitorInformation())
if response[0] != Packets.AnswerMonitorInformation:
raise RuntimeError(response)
return response[1:]
| gpl-2.0 | -5,549,362,815,099,683,000 | 34.625 | 79 | 0.624561 | false |
klahnakoski/MySQL-to-S3 | vendor/mo_times/dates.py | 1 | 13619 | # encoding: utf-8
#
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.
#
# Author: Kyle Lahnakoski ([email protected])
#
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
import math
import re
from datetime import datetime, date, timedelta
from decimal import Decimal
from time import time as _time
from mo_dots import Null
from mo_future import unichr, text_type, long
from mo_logs import Except
from mo_logs.strings import deformat
from mo_times.durations import Duration, MILLI_VALUES
from mo_times.vendor.dateutil.parser import parse as parse_date
_utcnow = datetime.utcnow
try:
import pytz
except Exception:
pass
ISO8601 = '%Y-%m-%dT%H:%M:%SZ'
class Date(object):
__slots__ = ["unix"]
MIN = None
MAX = None
def __new__(cls, *args, **kwargs):
if not args or (len(args) == 1 and args[0] == None):
return Null
return parse(*args)
def __init__(self, *args):
if self.unix is None:
self.unix = parse(*args).unix
def __nonzero__(self):
return True
def floor(self, duration=None):
if duration is None: # ASSUME DAY
return _unix2Date(math.floor(self.unix / 86400) * 86400)
elif duration.month:
dt = unix2datetime(self.unix)
month = int(math.floor((dt.year*12+dt.month-1) / duration.month) * duration.month)
year = int(math.floor(month/12))
month -= 12*year
return Date(datetime(year, month+1, 1))
elif duration.milli % (7 * 86400000) == 0:
offset = 4*86400
return _unix2Date(math.floor((self.unix + offset) / duration.seconds) * duration.seconds - offset)
else:
return _unix2Date(math.floor(self.unix / duration.seconds) * duration.seconds)
def format(self, format="%Y-%m-%d %H:%M:%S"):
try:
return unix2datetime(self.unix).strftime(format)
except Exception as e:
from mo_logs import Log
Log.error("Can not format {{value}} with {{format}}", value=unix2datetime(self.unix), format=format, cause=e)
@property
def milli(self):
return self.unix*1000
@property
def hour(self):
"""
:return: HOUR (int) IN THE GMT DAY
"""
return int(int(self.unix)/60/60 % 24)
def addDay(self):
return Date(unix2datetime(self.unix) + timedelta(days=1))
def add(self, other):
if other==None:
return Null
elif isinstance(other, (datetime, date)):
return _unix2Date(self.unix - datetime2unix(other))
elif isinstance(other, Date):
return _unix2Date(self.unix - other.unix)
elif isinstance(other, timedelta):
return Date(unix2datetime(self.unix) + other)
elif isinstance(other, Duration):
if other.month:
value = unix2datetime(self.unix)
if (value+timedelta(days=1)).month != value.month:
# LAST DAY OF MONTH
output = add_month(value+timedelta(days=1), other.month) - timedelta(days=1)
return Date(output)
else:
day = value.day
num_days = (add_month(datetime(value.year, value.month, 1), other.month+1) - timedelta(days=1)).day
day = min(day, num_days)
curr = set_day(value, day)
output = add_month(curr, other.month)
return Date(output)
else:
return _unix2Date(self.unix + other.seconds)
else:
from mo_logs import Log
Log.error("can not subtract {{type}} from Date", type=other.__class__.__name__)
@staticmethod
def now():
return _unix2Date(_time())
@staticmethod
def eod():
"""
RETURN END-OF-TODAY (WHICH IS SAME AS BEGINNING OF TOMORROW)
"""
return _unix2Date(Date.today().unix + 86400)
@staticmethod
def today():
return _unix2Date(math.floor(_time() / 86400) * 86400)
@staticmethod
def range(min, max, interval):
v = min
while v < max:
yield v
v = v + interval
def __str__(self):
return str(unix2datetime(self.unix))
def __repr__(self):
return unix2datetime(self.unix).__repr__()
def __sub__(self, other):
if other == None:
return None
if isinstance(other, datetime):
return Duration(self.unix - Date(other).unix)
if isinstance(other, Date):
return Duration(self.unix - other.unix)
return self.add(-other)
def __lt__(self, other):
other = Date(other)
return self.unix < other.unix
def __eq__(self, other):
if other == None:
return Null
try:
return other.unix == self.unix
except Exception:
pass
try:
return Date(other).unix == self.unix
except Exception:
return False
def __le__(self, other):
other = Date(other)
return self.unix <= other.unix
def __gt__(self, other):
other = Date(other)
return self.unix > other.unix
def __ge__(self, other):
other = Date(other)
return self.unix >= other.unix
def __add__(self, other):
return self.add(other)
def __data__(self):
return self.unix
@classmethod
def min(cls, *values):
output = Null
for v in values:
if output == None and v != None:
output = v
elif v < output:
output = v
return output
def parse(*args):
try:
if len(args) == 1:
a0 = args[0]
if isinstance(a0, (datetime, date)):
output = _unix2Date(datetime2unix(a0))
elif isinstance(a0, Date):
output = _unix2Date(a0.unix)
elif isinstance(a0, (int, long, float, Decimal)):
a0 = float(a0)
if a0 > 9999999999: # WAY TOO BIG IF IT WAS A UNIX TIMESTAMP
output = _unix2Date(a0 / 1000)
else:
output = _unix2Date(a0)
elif isinstance(a0, text_type) and len(a0) in [9, 10, 12, 13] and is_integer(a0):
a0 = float(a0)
if a0 > 9999999999: # WAY TOO BIG IF IT WAS A UNIX TIMESTAMP
output = _unix2Date(a0 / 1000)
else:
output = _unix2Date(a0)
elif isinstance(a0, text_type):
output = unicode2Date(a0)
else:
output = _unix2Date(datetime2unix(datetime(*args)))
else:
if isinstance(args[0], text_type):
output = unicode2Date(*args)
else:
output = _unix2Date(datetime2unix(datetime(*args)))
return output
except Exception as e:
from mo_logs import Log
Log.error("Can not convert {{args}} to Date", args=args, cause=e)
def add_month(offset, months):
month = int(offset.month+months-1)
year = offset.year
if not 0 <= month < 12:
r = _mod(month, 12)
year += int((month - r) / 12)
month = r
month += 1
output = datetime(
year=year,
month=month,
day=offset.day,
hour=offset.hour,
minute=offset.minute,
second=offset.second,
microsecond=offset.microsecond
)
return output
def set_day(offset, day):
output = datetime(
year=offset.year,
month=offset.month,
day=day,
hour=offset.hour,
minute=offset.minute,
second=offset.second,
microsecond=offset.microsecond
)
return output
def parse_time_expression(value):
def simple_date(sign, dig, type, floor):
if dig or sign:
from mo_logs import Log
Log.error("can not accept a multiplier on a datetime")
if floor:
return Date(type).floor(Duration(floor))
else:
return Date(type)
terms = re.match(r'(\d*[|\w]+)\s*([+-]\s*\d*[|\w]+)*', value).groups()
sign, dig, type = re.match(r'([+-]?)\s*(\d*)([|\w]+)', terms[0]).groups()
if "|" in type:
type, floor = type.split("|")
else:
floor = None
if type in MILLI_VALUES.keys():
value = Duration(dig+type)
else:
value = simple_date(sign, dig, type, floor)
for term in terms[1:]:
if not term:
continue
sign, dig, type = re.match(r'([+-])\s*(\d*)([|\w]+)', term).groups()
if "|" in type:
type, floor = type.split("|")
else:
floor = None
op = {"+": "__add__", "-": "__sub__"}[sign]
if type in MILLI_VALUES.keys():
if floor:
from mo_logs import Log
Log.error("floor (|) of duration not accepted")
value = value.__getattribute__(op)(Duration(dig+type))
else:
value = value.__getattribute__(op)(simple_date(sign, dig, type, floor))
return value
def unicode2Date(value, format=None):
"""
CONVERT UNICODE STRING TO UNIX TIMESTAMP VALUE
"""
## http://docs.python.org/2/library/datetime.html#strftime-and-strptime-behavior
if value == None:
return None
if format != None:
try:
if format.endswith("%S.%f") and "." not in value:
value += ".000"
return _unix2Date(datetime2unix(datetime.strptime(value, format)))
except Exception as e:
from mo_logs import Log
Log.error("Can not format {{value}} with {{format}}", value=value, format=format, cause=e)
value = value.strip()
if value.lower() == "now":
return _unix2Date(datetime2unix(_utcnow()))
elif value.lower() == "today":
return _unix2Date(math.floor(datetime2unix(_utcnow()) / 86400) * 86400)
elif value.lower() in ["eod", "tomorrow"]:
return _unix2Date(math.floor(datetime2unix(_utcnow()) / 86400) * 86400 + 86400)
if any(value.lower().find(n) >= 0 for n in ["now", "today", "eod", "tomorrow"] + list(MILLI_VALUES.keys())):
return parse_time_expression(value)
try: # 2.7 DOES NOT SUPPORT %z
local_value = parse_date(value) #eg 2014-07-16 10:57 +0200
return _unix2Date(datetime2unix((local_value - local_value.utcoffset()).replace(tzinfo=None)))
except Exception as e:
e = Except.wrap(e) # FOR DEBUGGING
pass
formats = [
"%Y-%m-%dT%H:%M:%S",
"%Y-%m-%dT%H:%M:%S.%f"
]
for f in formats:
try:
return _unix2Date(datetime2unix(datetime.strptime(value, f)))
except Exception:
pass
deformats = [
"%Y-%m",# eg 2014-07-16 10:57 +0200
"%Y%m%d",
"%d%m%Y",
"%d%m%y",
"%d%b%Y",
"%d%b%y",
"%d%B%Y",
"%d%B%y",
"%Y%m%d%H%M%S",
"%Y%m%dT%H%M%S",
"%d%m%Y%H%M%S",
"%d%m%y%H%M%S",
"%d%b%Y%H%M%S",
"%d%b%y%H%M%S",
"%d%B%Y%H%M%S",
"%d%B%y%H%M%S"
]
value = deformat(value)
for f in deformats:
try:
return unicode2Date(value, format=f)
except Exception:
pass
else:
from mo_logs import Log
Log.error("Can not interpret {{value}} as a datetime", value= value)
DATETIME_EPOCH = datetime(1970, 1, 1)
DATE_EPOCH = date(1970, 1, 1)
def datetime2unix(value):
try:
if value == None:
return None
elif isinstance(value, datetime):
diff = value - DATETIME_EPOCH
return diff.total_seconds()
elif isinstance(value, date):
diff = value - DATE_EPOCH
return diff.total_seconds()
else:
from mo_logs import Log
Log.error("Can not convert {{value}} of type {{type}}", value=value, type=value.__class__)
except Exception as e:
from mo_logs import Log
Log.error("Can not convert {{value}}", value=value, cause=e)
def unix2datetime(unix):
return datetime.utcfromtimestamp(unix)
def unix2Date(unix):
if not isinstance(unix, float):
from mo_logs import Log
Log.error("problem")
return _unix2Date(unix)
def _unix2Date(unix):
output = object.__new__(Date)
output.unix = unix
return output
delchars = "".join(c for c in map(unichr, range(256)) if not c.isalnum())
def deformat(value):
"""
REMOVE NON-ALPHANUMERIC CHARACTERS
"""
output = []
for c in value:
if c in delchars:
continue
output.append(c)
return "".join(output)
Date.MIN = Date(datetime(1, 1, 1))
Date.MAX = Date(datetime(2286, 11, 20, 17, 46, 39))
def is_integer(s):
if s is True or s is False:
return False
try:
if float(s) == round(float(s), 0):
return True
return False
except Exception:
return False
def _mod(value, mod=1):
"""
RETURN NON-NEGATIVE MODULO
RETURN None WHEN GIVEN INVALID ARGUMENTS
"""
if value == None:
return None
elif mod <= 0:
return None
elif value < 0:
return (value % mod + mod) % mod
else:
return value % mod
| mpl-2.0 | -7,967,396,073,122,584,000 | 27.080412 | 121 | 0.543432 | false |
coolsvap/clapper | ansible-tests/validations/library/discovery_diff.py | 1 | 1534 | #!/usr/bin/env python
import json
import os
import sys
from ansible.module_utils.basic import *
from subprocess import Popen, PIPE
DOCUMENTATION = '''
---
module: discovery_diff
short_description: Provide difference in hardware configuration
author: "Swapnil Kulkarni, @coolsvap"
'''
def get_node_hardware_data(hw_id, upenv):
'''Read the inspector data about the given node from Swift'''
p = Popen(('swift', 'download', '--output', '-', 'ironic-inspector', hw_id),
env=upenv, stdout=PIPE, stderr=PIPE)
if p.wait() == 0:
return json.loads(p.stdout.read())
def main():
module = AnsibleModule(
argument_spec={}
)
upenv = os.environ.copy()
with open("files/env_vars.json") as data_file:
env_data = json.load(data_file)
upenv.update(env_data)
p = Popen(('swift', 'list', 'ironic-inspector'), env=upenv, stdout=PIPE, stderr=PIPE)
if p.wait() != 0:
print "Error running `swift list ironic-inspector`"
print p.stderr.read()
sys.exit(1)
hardware_ids = [i.strip() for i in p.stdout.read().splitlines() if i.strip()]
hw_dicts = {}
for hwid in hardware_ids:
hw_dicts[hwid] = get_node_hardware_data(hwid, upenv)
# TODO(coolsvap) find a way to compare the obtained data in meaningful manner
result = {
'changed': True,
'msg': 'Discovery data for %d servers' % len(hw_dicts.keys()),
'results': hw_dicts,
}
module.exit_json(**result)
if __name__ == '__main__':
main()
| apache-2.0 | -5,402,917,734,117,416,000 | 24.566667 | 89 | 0.6206 | false |
simvisage/oricreate | docs/howtos/ex08_rigid_facets/sim013_single_fold_quad_psi_cntl.py | 1 | 4000 | r'''
Fold control using dihedral angle with quadrilateral facets
-----------------------------------------------------------
This example shows the folding process controlled by a dihedral
angle between two facets. In addition to the previous
example, this one introduces quadrilateral facets that
are symmetrically composed of triangles with fixed fold line - i.e.
dihedral angle ''psi'' is equal to zero. The example represents
a standard Miura-Ori vertex with all associated kinematic constraints.
'''
import numpy as np
from oricreate.api import \
SimulationTask, SimulationConfig, \
GuConstantLength, GuDofConstraints, GuPsiConstraints, fix, \
FTV, FTA
def create_cp_factory():
# begin
from oricreate.api import CreasePatternState, CustomCPFactory
x = np.array([[-1, 0, 0],
[0, 0, 0],
[1, 1, 0],
[2, 0, 0],
[1, -1, 0],
[-1, 1, 0],
[-1, -1, 0],
[2, 1, 0],
[2, -1, 0],
], dtype='float_')
L = np.array([[0, 1], [1, 2], [1, 5],
[1, 3], [2, 3],
[1, 4], [3, 4],
#[1, 5],
[6, 1],
[0, 5], [2, 5],
[0, 6], [4, 6],
[3, 7], [2, 7],
[3, 8], [4, 8]
],
dtype='int_')
F = np.array([[5, 1, 2],
[1, 3, 2],
[1, 4, 3],
[1, 4, 6],
[0, 1, 5],
[0, 1, 6],
[3, 2, 7],
[3, 4, 8],
], dtype='int_')
cp = CreasePatternState(X=x,
L=L,
F=F
)
cp_factory = CustomCPFactory(formed_object=cp)
# end
return cp_factory
if __name__ == '__main__':
cp_factory_task = create_cp_factory()
cp = cp_factory_task.formed_object
# Link the crease factory with the constraint client
gu_constant_length = GuConstantLength()
psi_max = np.pi * .49
gu_psi_constraints = \
GuPsiConstraints(forming_task=cp_factory_task,
psi_constraints=[([(2, 1.0)], 0.0),
([(7, 1.0)], 0.0),
([(4, 1.0)], 0.0),
([(6, 1.0)], 0.0),
([(3, 1.0)], lambda t: -psi_max * t),
#([(5, 1.0)], lambda t: psi_max * t),
])
dof_constraints = fix([0], [1]) + fix([1], [0, 1, 2]) \
+ fix([2, 4], [2])
gu_dof_constraints = GuDofConstraints(dof_constraints=dof_constraints)
sim_config = SimulationConfig(goal_function_type='none',
gu={'cl': gu_constant_length,
'u': gu_dof_constraints,
'psi': gu_psi_constraints},
acc=1e-8, MAX_ITER=100)
sim_task = SimulationTask(previous_task=cp_factory_task,
config=sim_config,
n_steps=25)
cp.u[(0, 3), 2] = -0.1
cp.u[(1), 2] = 0.1
sim_task.u_1
cp = sim_task.formed_object
ftv = FTV()
ftv.add(sim_task.sim_history.viz3d_dict['node_numbers'], order=5)
ftv.add(sim_task.sim_history.viz3d)
ftv.add(gu_dof_constraints.viz3d)
fta = FTA(ftv=ftv)
fta.init_view(a=200, e=35, d=5, f=(0, 0, 0), r=0)
fta.add_cam_move(a=200, e=34, n=5, d=5, r=0,
duration=10,
vot_fn=lambda cmt: np.linspace(0, 1, 4),
azimuth_move='damped',
elevation_move='damped',
distance_move='damped')
fta.plot()
fta.render()
fta.configure_traits()
| gpl-3.0 | 4,225,928,669,675,981,000 | 32.613445 | 79 | 0.4195 | false |
arielalmendral/ert | python/python/ert/enkf/plot_data/ensemble_plot_gen_kw_vector.py | 2 | 1627 | # Copyright (C) 2014 Statoil ASA, Norway.
#
# The file 'ensemble_plot_gen_kw_vector.py' is part of ERT - Ensemble based Reservoir Tool.
#
# ERT 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.
#
# ERT 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 at <http://www.gnu.org/licenses/gpl.html>
# for more details.
from cwrap import BaseCClass
from ert.enkf import EnkfPrototype
class EnsemblePlotGenKWVector(BaseCClass):
TYPE_NAME = "ensemble_plot_gen_kw_vector"
_size = EnkfPrototype("int enkf_plot_gen_kw_vector_get_size(ensemble_plot_gen_kw_vector)")
_get_value = EnkfPrototype("double enkf_plot_gen_kw_vector_iget(ensemble_plot_gen_kw_vector, int)")
def __init__(self):
raise NotImplementedError("Class can not be instantiated directly!")
def __len__(self):
""" @rtype: int """
return self._size()
def getValue(self, index):
""" @rtype: float """
return self[index]
def __iter__(self):
cur = 0
while cur < len(self):
yield self[cur]
cur += 1
def __getitem__(self, index):
""" @rtype: float """
return self._get_value(index)
def __repr__(self):
return 'EnsemblePlotGenKWVector(size = %d) %s' % (len(self), self._ad_str())
| gpl-3.0 | -4,897,229,285,005,481,000 | 32.204082 | 103 | 0.657652 | false |
OMS-NetZero/FAIR | fair/tools/magicc.py | 1 | 6123 | from __future__ import division
import numpy as np
from scipy.interpolate import interp1d
def _import_emis_file(rcp):
if rcp in ['rcp3pd', 'rcp26']:
from ..RCPs.rcp26 import Emissions as rcp_emis
elif rcp=='rcp45':
from ..RCPs.rcp45 import Emissions as rcp_emis
elif rcp in ['rcp6', 'rcp60']:
from ..RCPs.rcp60 import Emissions as rcp_emis
elif rcp=='rcp85':
from ..RCPs.rcp85 import Emissions as rcp_emis
else:
raise ValueError('rcp must be rcp26, rcp45, rcp60 or rcp85')
return rcp_emis
def scen_open(filename,
include_cfcs='rcp45',
startyear=1765,
harmonise=None):
"""
Opens a MAGICC6 .SCEN file and extracts the data. Interpolates linearly
between non-consecutive years in the SCEN file. Fills in chlorinated gases
from a specified RCP scenario or from custom emissions.
Inputs:
filename: the .SCEN file to open
Keywords:
include_cfcs: string, False, or nt x 16 numpy array
MAGICC files do not come loaded with CFCs (indices 24-39).
They are given in the harmonised files at
http://www.pik-potsdam.de/~mmalte/rcps/.
- Specify 'rcp3pd', 'rcp45', 'rcp6' or 'rcp85' to use these RCPs.
- Use False to ignore and create a 24-species emission file.
- Provide an array to tack your own chlorinated gases onto the SCEN
startyear: First year of output file. If before first year of the SCEN
file, use RCP4.5 to fill
harmonise: None, or year
Linearly interpolate between 2000 in the RCP file and the specified
year. If None, do not harmonise
Returns:
nt x 40 numpy emissions array
nt is defined as <last year of SCEN file> -
<earlier of startyear and first year of SCEN file> + 1
It is assumed that the .SCEN files follow the formatting convention on
the MAGICC wiki at
http://wiki.magicc.org/index.php?title=Creating_MAGICC_Scenario_Files.
"""
with open(filename) as f:
# First line is the number of time steps in the SCEN file
str_nt = f.readline().strip()
nt = int(str_nt)
# Next 6 lines are unused by FaIR.
for i in range(6):
f.readline()
# Eighth line is the column headers. When object orientation is
# implemented this will be important.
headers = f.readline().split()
# Ninth line is the units. Again this will be important in OO-FaIR
units = f.readline().split()
# Now the data!
scen_emissions = np.genfromtxt(filename, skip_header=9, max_rows=nt)
emissions = np.copy(scen_emissions)
scen_years = scen_emissions[:,0]
# Interpolate between non-consecutive years in SCEN file
f = interp1d(scen_years, emissions[:,1:], kind='linear', axis=0,
assume_sorted=True, bounds_error=True)
full_years = np.arange(scen_years[0], scen_years[-1]+1)
emissions_filled = np.hstack((full_years[:,None], f(full_years)))
# Add CFCs if requested
if type(include_cfcs) is np.ndarray:
if include_cfcs.shape != (len(full_years), 16):
raise ValueError("If chlorinated gas emissions are provided by " +
"the user they should be of size nt x 16 where nt is the number "+
"of consecutive years. Size is %s." % str(include_cfcs.shape))
emissions_filled = np.append(emissions_filled, include_cfcs, axis=1)
elif include_cfcs==False:
pass
elif include_cfcs.lower()[:3]=='rcp':
rcp_emis = _import_emis_file(include_cfcs.lower()).emissions
# Need to ensure only years present in the SCEN file are taken
# Cheers: https://stackoverflow.com/questions/3522946/
# using-numpy-arrays-as-lookup-tables
if int(scen_years[0])<1765:
raise ValueError("CFCs can only be infilled from RCPs as far "+
"back as 1765 at present")
rcp_years = np.arange(scen_years[0], scen_years[-1]+1)
mapping = dict(zip(rcp_emis[:,0], range(rcp_emis.shape[0])))
rcp_cfcs = np.array([rcp_emis[mapping[key],24:] for key in rcp_years])
emissions_filled = np.append(emissions_filled, rcp_cfcs, axis=1)
else:
raise ValueError("include_cfcs should be an nt x 16 numpy array, a " +
"string (rcp3pd, rcp45, rcp6 or rcp85) or False.")
# Fill in any pre-SCEN years from RCP4.5. All pathways are identical <2000
if scen_years[0]>startyear:
if scen_years[0]>2000:
raise ValueError("Can only fill in history unambiguously if " +
"first year in SCEN file is 2000 or earlier. You have requested "+
"startyear=%d and the first year in SCEN file is %d"
% (startyear, scen_years[0]))
else:
# tack RCP45 on to beginning
rcp_emis = _import_emis_file('rcp45').emissions
rcp_years = np.arange(startyear, scen_years[0])
mapping = dict(zip(rcp_emis[:,0], range(rcp_emis.shape[0])))
if include_cfcs==False:
rcp_all = np.array([rcp_emis[mapping[key],:24] for key in rcp_years])
else:
rcp_all = np.array([rcp_emis[mapping[key],:] for key in rcp_years])
emissions_filled = np.insert(emissions_filled, 0, rcp_all, axis=0)
# harmonise?
if harmonise is not None:
harmonise = int(harmonise)
if harmonise < 2000:
raise ValueError("Cannot harmonise before 2000.")
elif harmonise > scen_years[-1]:
raise ValueError("Cannot harmonise after last year of " +
"input dataset")
rcp_emis_2000 = rcp_emis[2000-startyear,:]
for j in range(1,emissions_filled.shape[1]):
f = interp1d((2000,harmonise), (rcp_emis_2000[j],
emissions_filled[harmonise-startyear,j]))
emissions_filled[2000-startyear:harmonise-startyear,j] = f(
np.arange(2000,harmonise))
return emissions_filled
| apache-2.0 | 8,400,502,087,455,092,000 | 41.520833 | 85 | 0.614895 | false |
NCI-GDC/gdcdatamodel | migrations/update_case_cache_append_only.py | 1 | 5901 | #!/usr/bin/env python
from psqlgraph import Node, Edge
from gdcdatamodel import models as md
CACHE_EDGES = {
Node.get_subclass_named(edge.__src_class__): edge
for edge in Edge.get_subclasses()
if 'RelatesToCase' in edge.__name__
}
LEVEL_1_SQL = """
INSERT INTO {cache_edge_table} (src_id, dst_id, _props, _sysan, acl)
SELECT {cls_table}.node_id, node_case.node_id,
'{{}}'::jsonb, '{{}}'::jsonb, '{{}}'::text[]
FROM {cls_table}
-- Step directly to case
JOIN {cls_to_case_edge_table}
ON {cls_table}.node_id = {cls_to_case_edge_table}.src_id
JOIN node_case
ON node_case.node_id = {cls_to_case_edge_table}.dst_id
-- Append only, e.g. insert only those missing
WHERE NOT EXISTS (
SELECT 1 FROM {cache_edge_table}
WHERE {cls_table}.node_id = {cache_edge_table}.src_id
AND node_case.node_id = {cache_edge_table}.dst_id)
"""
APPEND_CACHE_FROM_PARENT_SQL = """
INSERT INTO {cache_edge_table} (src_id, dst_id, _props, _sysan, acl)
SELECT DISTINCT {cls_table}.node_id, node_case.node_id,
'{{}}'::jsonb, '{{}}'::jsonb, '{{}}'::text[]
FROM {cls_table}
-- Step to parent
JOIN {cls_to_parent_edge_table}
ON {cls_table}.node_id = {cls_to_parent_edge_table}.src_id
JOIN {parent_table}
ON {parent_table}.node_id = {cls_to_parent_edge_table}.dst_id
-- Step to parent's related cases
JOIN {parent_cache_edge_table}
ON {parent_table}.node_id = {parent_cache_edge_table}.src_id
JOIN node_case
ON node_case.node_id = {parent_cache_edge_table}.dst_id
-- Append only, e.g. insert only those missing
WHERE NOT EXISTS (
SELECT 1 FROM {cache_edge_table}
WHERE {cls_table}.node_id = {cache_edge_table}.src_id
AND node_case.node_id = {cache_edge_table}.dst_id)
"""
def max_distances_from_case():
"""Breadth first search for max depth every class is from case"""
distances = {}
to_visit = [(md.Case, -1)]
while to_visit:
cls, level = to_visit.pop(0)
if cls not in distances:
children = (
link['src_type']
for _, link in cls._pg_backrefs.items()
)
to_visit.extend((child, level+1) for child in children)
distances[cls] = max(distances.get(cls, level+1), level)
return distances
def get_levels():
"""Returns a map of levels -> [classes] where a level is the max
distance a class is from a case
"""
distances = max_distances_from_case()
distinct_distances = set(distances.values())
levels = {
level: [
cls for cls, distance in distances.items() if distance == level
] for level in distinct_distances
}
return levels
def append_cache_from_parent(graph, child, parent):
"""Creates case cache edges from :param:`parent` that do not already
exist for :param:`child`
Add child cache edges for:
{child -> parent -> case} / {child -> case}
"""
description = child.label + ' -> ' + parent.label + ' -> case'
if parent not in CACHE_EDGES:
print("skipping:", description, ": parent is not cached")
elif child not in CACHE_EDGES:
print("skipping:", description, ": child is not cached")
elif child is parent:
print("skipping:", description, ": cycle")
else:
print(description)
for cls_to_parent_edge in get_edges_between(child, parent):
statement = APPEND_CACHE_FROM_PARENT_SQL.format(
cache_edge_table=CACHE_EDGES[child].__tablename__,
cls_table=child.__tablename__,
cls_to_parent_edge_table=cls_to_parent_edge.__tablename__,
parent_table=parent.__tablename__,
parent_cache_edge_table=CACHE_EDGES[parent].__tablename__,
)
graph.current_session().execute(statement)
def append_cache_from_parents(graph, cls):
"""Creates case cache edges that all parents have that do not already
exist
"""
parents = {
link['dst_type']
for link in cls._pg_links.itervalues()
}
for parent in parents:
append_cache_from_parent(graph, cls, parent)
def get_edges_between(src, dst):
"""Returns all edges from src -> dst (directionality matters)"""
return [
edge
for edge in Edge.get_subclasses()
if edge.__src_class__ == src.__name__
and edge.__dst_class__ == dst.__name__
and edge not in CACHE_EDGES.values()
]
def seed_level_1(graph, cls):
"""Set the case cache for all nodes max 1 step from case"""
for case_edge in get_edges_between(cls, md.Case):
statement = LEVEL_1_SQL.format(
cache_edge_table=CACHE_EDGES[cls].__tablename__,
cls_table=cls.__tablename__,
cls_to_case_edge_table=case_edge.__tablename__,
)
print('Seeding {} through {}'.format(cls.get_label(), case_edge.__name__))
graph.current_session().execute(statement)
def update_case_cache_append_only(graph):
"""Server-side update case cache for all entities
1) Seed direct relationships from level L1 (1 step from case)
2) Visit all nodes in levels stepping out from case and for each
entity in that level L, add the related case edges from all
parents in level L-1 that do not already exist in level L
"""
cls_levels = get_levels()
for cls in Node.get_subclasses():
seed_level_1(graph, cls)
for level in sorted(cls_levels)[2:]:
print("\n\nLevel:", level)
for cls in cls_levels[level]:
append_cache_from_parents(graph, cls)
def main():
print("No main() action defined, please manually call "
"update_case_cache_append_only(graph)")
if __name__ == '__main__':
main()
| apache-2.0 | -4,557,591,127,347,263,500 | 28.068966 | 82 | 0.597356 | false |
Southpaw-TACTIC/TACTIC | src/pyasm/widget/error_wdg.py | 1 | 6906 | ###########################################################
#
# Copyright (c) 2005, Southpaw Technology
# All Rights Reserved
#
# PROPRIETARY INFORMATION. This software is proprietary to
# Southpaw Technology, and is not to be reproduced, transmitted,
# or disclosed in any way without written permission.
#
#
__all__ = ['Error403Wdg', 'Error404Wdg' ]
from pyasm.web import Widget, DivWdg, HtmlElement, Table, SpanWdg, WebContainer
from .input_wdg import HiddenWdg, TextWdg, PasswordWdg
from .web_wdg import SignOutLinkWdg
from .header_wdg import ProjectSwitchWdg
class ErrorWdg(Widget):
LOGIN_MSG = 'login_message'
def get_display(self):
box = DivWdg(css='login')
box.add_style("margin-top: auto")
box.add_style("margin-bottom: auto")
box.add_style("text-align: center")
script = HtmlElement.script('''function login(e) {
if (!e) var e = window.event;
if (e.keyCode == 13) {
submit_icon_button('Submit');
}}
''')
div = DivWdg()
div.add_style("margin: 0px 0px")
div.add_class("centered")
div.add( HtmlElement.br(3) )
div.add(self.get_error_wdg() )
box.add(div)
widget = Widget()
#widget.add( HtmlElement.br(3) )
table = Table()
table.add_style("width: 100%")
table.add_style("height: 85%")
table.add_row()
td = table.add_cell()
td.add_style("vertical-align: middle")
td.add_style("text-align: center")
td.add_style("background: transparent")
td.add(box)
widget.add(table)
return widget
def get_error_wdg(self):
'''function to override'''
pass
def set_message(self, message):
self.message = message
def set_status(self, status):
self.status = status
class Error404Wdg(ErrorWdg):
''' this should be displaying the error status and message, not necessarily 404'''
def __init__(self):
# just defaults to 404
self.status = 404
self.message = ''
super(Error404Wdg, self).__init__()
def get_error_wdg(self):
kwargs = {
}
from tactic.ui.panel import HashPanelWdg
widget = HashPanelWdg.get_widget_from_hash("/error404", return_none=True, kwargs=kwargs)
if widget:
return widget
div = DivWdg()
error_div = DivWdg()
error_div.add("<hr/>")
error_div.add("Error %s" % self.status)
error_div.add("<hr/>")
div.add(error_div)
error_div.add_style("font-size: 18px")
error_div.add_style("font-weight: bold")
error_div.add_style("padding: 10px")
error_div.add_style("width: auto")
error_div.add_color("background", "background", -3)
error_div.add_color("color", "color")
#error_div.add_border()
error_div.add_style("margin-left: 5px")
error_div.add_style("margin-right: 5px")
error_div.add_style("margin-top: -10px")
div.add("<br/>")
span = DivWdg()
#span.add_color("color", "color")
#span.add_style("color", "#FFF")
if self.status == 404:
span.add(HtmlElement.b("You have tried to access a url that is not recognized."))
else:
span.add(HtmlElement.b(self.message))
span.add(HtmlElement.br(2))
web = WebContainer.get_web()
root = web.get_site_root()
if self.message.startswith('No project ['):
label = 'You may need to correct the default_project setting in the TACTIC config.'
else:
label = "Go to the Main page for a list of valid projects"
span.add(label)
div.add(span)
div.add(HtmlElement.br())
from tactic.ui.widget import ActionButtonWdg
button_div = DivWdg()
button_div.add_style("width: 90px")
button_div.add_style("margin: 0px auto")
div.add(button_div)
button = ActionButtonWdg(title="Go to Main", tip='Click to go to main page')
button_div.add(button)
button.add_behavior( {
'type': 'click_up',
'cbjs_action': '''
document.location = '/';
'''
} )
button.add_event("onmouseup", "document.location='/'")
return div
class Error403Wdg(ErrorWdg):
''' this should be displaying the error status and message, not necessarily 404'''
def __init__(self):
# just defaults to 404
self.status = 403
self.message = ''
super(Error403Wdg, self).__init__()
def get_error_wdg(self):
div = DivWdg()
error_div = DivWdg()
error_div.add("<hr/>")
error_div.add("Error %s - Permission Denied" % self.status)
error_div.add("<hr/>")
div.add(error_div)
error_div.add_style("font-size: 16px")
error_div.add_style("font-weight: bold")
error_div.add_style("width: 97%")
error_div.add_color("background", "background", -3)
error_div.add_border()
error_div.add_style("margin-left: 5px")
error_div.add_style("margin-top: -10px")
div.add("<br/>")
span = DivWdg()
#span.add_color("color", "color")
#span.add_style("color", "#FFF")
if self.status == 403:
span.add("<b>You have tried to access a url that is not permitted.</b>")
else:
span.add(HtmlElement.b(self.message))
span.add(HtmlElement.br(2))
web = WebContainer.get_web()
root = web.get_site_root()
span.add("Go back to the Main page for a list of valid projects")
div.add(span)
div.add(HtmlElement.br())
table = Table()
div.add(table)
table.add_row()
table.add_style("margin-left: auto")
table.add_style("margin-right: auto")
from tactic.ui.widget import ActionButtonWdg
button = ActionButtonWdg(title="Go to Main", tip='Click to go to main page')
table.add_cell(button)
button.add_behavior( {
'type': 'click_up',
'cbjs_action': '''
document.location = '/projects';
'''
} )
button.add_style("margin-left: auto")
button.add_style("margin-right: auto")
button = ActionButtonWdg(title="Sign Out", tip='Click to Sign Out')
table.add_cell(button)
button.add_behavior( {
'type': 'click_up',
'login': web.get_user_name(),
'cbjs_action': '''
var server = TacticServerStub.get();
server.execute_cmd("SignOutCmd", {login: bvr.login} );
window.location.href='%s';
''' % root
} )
button.add_style("margin-left: auto")
button.add_style("margin-right: auto")
return div
| epl-1.0 | 5,733,914,920,654,536,000 | 28.262712 | 96 | 0.5585 | false |
novafloss/populous | populous/cli.py | 1 | 2649 | import importlib
import logging
import click
import click_log
import six
from .loader import load_blueprint
from .exceptions import ValidationError, YAMLError, BackendError
logger = logging.getLogger('populous')
click_log.basic_config(logger)
def get_blueprint(files, **kwargs):
try:
return load_blueprint(*files, **kwargs)
except (YAMLError, ValidationError) as e:
raise click.ClickException(six.text_type(e))
except Exception as e:
raise click.ClickException("Unexpected error during the blueprint "
"loading: {}".format(e))
@click.group()
@click.version_option()
@click_log.simple_verbosity_option(logger)
def cli():
pass
@cli.group()
def run():
pass
def _generic_run(modulename, classname, files, **kwargs):
try:
try:
module = importlib.import_module(
'populous.backends.' + modulename,
package='populous.backends'
)
backend_cls = getattr(module, classname)
except (ImportError, AttributeError):
raise click.ClickException("Backend not found.")
backend = backend_cls(**kwargs)
blueprint = get_blueprint(files, backend=backend)
try:
with backend.transaction():
blueprint.generate()
logger.info("Closing DB transaction...")
finally:
backend.close()
logger.info("Have fun!")
except BackendError as e:
raise click.ClickException(six.text_type(e))
@run.command()
@click.option('--host', help="Database host address")
@click.option('--port', type=int, help="Database host port")
@click.option('--db', help="Database name")
@click.option('--user', help="Postgresql user name used to authenticate")
@click.option('--password', help="Postgresql password used to authenticate")
@click.argument('files', nargs=-1, required=True)
def postgres(host, port, db, user, password, files):
return _generic_run('postgres', 'Postgres', files, host=host, port=port,
db=db, user=user, password=password)
@cli.command()
def generators():
"""
List all the available generators.
"""
from populous import generators
base = generators.Generator
for name in dir(generators):
generator = getattr(generators, name)
if isinstance(generator, type) and issubclass(generator, base):
name = generator.__name__
doc = (generator.__doc__ or '').strip()
if doc:
click.echo("{} - {}".format(name, doc))
else:
click.echo(name)
| mit | -7,277,352,776,441,271,000 | 26.309278 | 76 | 0.619857 | false |
highweb-project/highweb-webcl-html5spec | tools/android/loading/activity_lens.py | 1 | 11113 | # Copyright 2016 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.
"""Gives a picture of the CPU activity between timestamps.
When executed as a script, takes a loading trace, and prints the activity
breakdown for the request dependencies.
"""
import collections
import logging
import operator
import request_track
class ActivityLens(object):
"""Reconstructs the activity of the main renderer thread between requests."""
_SCRIPT_EVENT_NAMES = ('EvaluateScript', 'FunctionCall')
_PARSING_EVENT_NAMES = ('ParseHTML', 'ParseAuthorStyleSheet')
def __init__(self, trace):
"""Initializes an instance of ActivityLens.
Args:
trace: (LoadingTrace) loading trace.
"""
self._trace = trace
events = trace.tracing_track.GetEvents()
self._renderer_main_pid_tid = self._GetRendererMainThreadId(events)
self._tracing = self._trace.tracing_track.TracingTrackForThread(
self._renderer_main_pid_tid)
@classmethod
def _GetRendererMainThreadId(cls, events):
"""Returns the most active main renderer thread.
Several renderers may be running concurrently, but we assume that only one
of them is busy during the time covered by the loading trace.. It can be
selected by looking at the number of trace events generated.
Args:
events: [tracing.Event] List of trace events.
Returns:
(PID (int), TID (int)) of the busiest renderer main thread.
"""
events_count_per_pid_tid = collections.defaultdict(int)
main_renderer_thread_ids = set()
for event in events:
tracing_event = event.tracing_event
pid = event.tracing_event['pid']
tid = event.tracing_event['tid']
events_count_per_pid_tid[(pid, tid)] += 1
if (tracing_event['cat'] == '__metadata'
and tracing_event['name'] == 'thread_name'
and event.args['name'] == 'CrRendererMain'):
main_renderer_thread_ids.add((pid, tid))
pid_tid_events_counts = sorted(events_count_per_pid_tid.items(),
key=operator.itemgetter(1), reverse=True)
if (len(pid_tid_events_counts) > 1
and pid_tid_events_counts[0][1] < 2 * pid_tid_events_counts[1][1]):
logging.warning(
'Several active renderers (%d and %d with %d and %d events).'
% (pid_tid_events_counts[0][0][0], pid_tid_events_counts[1][0][0],
pid_tid_events_counts[0][1], pid_tid_events_counts[1][1]))
return pid_tid_events_counts[0][0]
def _OverlappingMainRendererThreadEvents(self, start_msec, end_msec):
return self._tracing.OverlappingEvents(start_msec, end_msec)
@classmethod
def _ClampedDuration(cls, event, start_msec, end_msec):
return max(0, (min(end_msec, event.end_msec)
- max(start_msec, event.start_msec)))
@classmethod
def _ThreadBusyness(cls, events, start_msec, end_msec):
"""Amount of time a thread spent executing from the message loop."""
busy_duration = 0
message_loop_events = [
e for e in events
if (e.tracing_event['cat'] == 'toplevel'
and e.tracing_event['name'] == 'MessageLoop::RunTask')]
for event in message_loop_events:
clamped_duration = cls._ClampedDuration(event, start_msec, end_msec)
busy_duration += clamped_duration
interval_msec = end_msec - start_msec
assert busy_duration <= interval_msec
return busy_duration
@classmethod
def _ScriptsExecuting(cls, events, start_msec, end_msec):
"""Returns the time during which scripts executed within an interval.
Args:
events: ([tracing.Event]) list of tracing events.
start_msec: (float) start time in ms, inclusive.
end_msec: (float) end time in ms, inclusive.
Returns:
A dict {URL (str) -> duration_msec (float)}. The dict may have a None key
for scripts that aren't associated with a URL.
"""
script_to_duration = collections.defaultdict(float)
script_events = [e for e in events
if ('devtools.timeline' in e.tracing_event['cat']
and (e.tracing_event['name']
in cls._SCRIPT_EVENT_NAMES))]
for event in script_events:
clamped_duration = cls._ClampedDuration(event, start_msec, end_msec)
script_url = event.args['data'].get('scriptName', None)
script_to_duration[script_url] += clamped_duration
return dict(script_to_duration)
@classmethod
def _FullyIncludedEvents(cls, events, event):
"""Return a list of events wholly included in the |event| span."""
(start, end) = (event.start_msec, event.end_msec)
result = []
for event in events:
if start <= event.start_msec < end and start <= event.end_msec < end:
result.append(event)
return result
@classmethod
def _Parsing(cls, events, start_msec, end_msec):
"""Returns the HTML/CSS parsing time within an interval.
Args:
events: ([tracing.Event]) list of events.
start_msec: (float) start time in ms, inclusive.
end_msec: (float) end time in ms, inclusive.
Returns:
A dict {URL (str) -> duration_msec (float)}. The dict may have a None key
for tasks that aren't associated with a URL.
"""
url_to_duration = collections.defaultdict(float)
parsing_events = [e for e in events
if ('devtools.timeline' in e.tracing_event['cat']
and (e.tracing_event['name']
in cls._PARSING_EVENT_NAMES))]
for event in parsing_events:
# Parsing events can contain nested script execution events, avoid
# double-counting by discounting these.
nested_events = cls._FullyIncludedEvents(events, event)
events_tree = _EventsTree(event, nested_events)
js_events = events_tree.DominatingEventsWithNames(cls._SCRIPT_EVENT_NAMES)
duration_to_subtract = sum(
cls._ClampedDuration(e, start_msec, end_msec) for e in js_events)
tracing_event = event.tracing_event
clamped_duration = cls._ClampedDuration(event, start_msec, end_msec)
if tracing_event['name'] == 'ParseAuthorStyleSheet':
url = tracing_event['args']['data']['styleSheetUrl']
else:
url = tracing_event['args']['beginData']['url']
parsing_duration = clamped_duration - duration_to_subtract
assert parsing_duration >= 0
url_to_duration[url] += parsing_duration
return dict(url_to_duration)
def GenerateEdgeActivity(self, dep):
"""For a dependency between two requests, returns the renderer activity
breakdown.
Args:
dep: (Request, Request, str) As returned from
RequestDependencyLens.GetRequestDependencies().
Returns:
{'edge_cost': (float) ms, 'busy': (float) ms,
'parsing': {'url' -> time_ms}, 'script' -> {'url' -> time_ms}}
"""
(first, second, reason) = dep
(start_msec, end_msec) = request_track.IntervalBetween(
first, second, reason)
assert end_msec - start_msec >= 0.
events = self._OverlappingMainRendererThreadEvents(start_msec, end_msec)
result = {'edge_cost': end_msec - start_msec,
'busy': self._ThreadBusyness(events, start_msec, end_msec),
'parsing': self._Parsing(events, start_msec, end_msec),
'script': self._ScriptsExecuting(events, start_msec, end_msec)}
return result
def BreakdownEdgeActivityByInitiator(self, dep):
"""For a dependency between two requests, categorizes the renderer activity.
Args:
dep: (Request, Request, str) As returned from
RequestDependencyLens.GetRequestDependencies().
Returns:
{'script': float, 'parsing': float, 'other_url': float,
'unknown_url': float, 'unrelated_work': float}
where the values are durations in ms:
- idle: The renderer main thread was idle.
- script: The initiating file was executing.
- parsing: The initiating file was being parsed.
- other_url: Other scripts and/or parsing activities.
- unknown_url: Activity which is not associated with a URL.
- unrelated_work: Activity unrelated to scripts or parsing.
"""
activity = self.GenerateEdgeActivity(dep)
breakdown = {'unrelated_work': activity['busy'],
'idle': activity['edge_cost'] - activity['busy'],
'script': 0, 'parsing': 0,
'other_url': 0, 'unknown_url': 0}
for kind in ('script', 'parsing'):
for (script_name, duration_ms) in activity[kind].items():
if not script_name:
breakdown['unknown_url'] += duration_ms
elif script_name == dep[0].url:
breakdown[kind] += duration_ms
else:
breakdown['other_url'] += duration_ms
breakdown['unrelated_work'] -= sum(
breakdown[x] for x in ('script', 'parsing', 'other_url', 'unknown_url'))
return breakdown
def MainRendererThreadBusyness(self, start_msec, end_msec):
"""Returns the amount of time the main renderer thread was busy.
Args:
start_msec: (float) Start of the interval.
end_msec: (float) End of the interval.
"""
events = self._OverlappingMainRendererThreadEvents(start_msec, end_msec)
return self._ThreadBusyness(events, start_msec, end_msec)
class _EventsTree(object):
"""Builds the hierarchy of events from a list of fully nested events."""
def __init__(self, root_event, events):
"""Creates the tree.
Args:
root_event: (Event) Event held by the tree root.
events: ([Event]) List of events that are fully included in |root_event|.
"""
self.event = root_event
self.start_msec = root_event.start_msec
self.end_msec = root_event.end_msec
self.children = []
events.sort(key=operator.attrgetter('start_msec'))
if not events:
return
current_child = (events[0], [])
for event in events[1:]:
if event.end_msec < current_child[0].end_msec:
current_child[1].append(event)
else:
self.children.append(_EventsTree(current_child[0], current_child[1]))
current_child = (event, [])
self.children.append(_EventsTree(current_child[0], current_child[1]))
def DominatingEventsWithNames(self, names):
"""Returns a list of the top-most events in the tree with a matching name.
"""
if self.event.name in names:
return [self.event]
else:
result = []
for child in self.children:
result += child.DominatingEventsWithNames(names)
return result
if __name__ == '__main__':
import sys
import json
import loading_trace
import request_dependencies_lens
filename = sys.argv[1]
json_dict = json.load(open(filename))
loading_trace = loading_trace.LoadingTrace.FromJsonDict(json_dict)
activity_lens = ActivityLens(loading_trace)
dependencies_lens = request_dependencies_lens.RequestDependencyLens(
loading_trace)
deps = dependencies_lens.GetRequestDependencies()
for requests_dep in deps:
print activity_lens.GenerateEdgeActivity(requests_dep)
| bsd-3-clause | 3,075,392,639,984,073,700 | 38.130282 | 80 | 0.651219 | false |
prospero78/pyPC | pak_pc/pak_gui/pak_widgets/mod_frm_cpu.py | 1 | 1734 | # -*- coding: utf8 -*-
'''
Этот модуль заточен под отображение состояния центрального процессора.
Ввиду его отдельности -- его можно втыкать куда угодно. )
'''
from Tkinter import Frame
from pak_pc.pak_gui.pak_widgets.mod_frm_reg import ClsFrmReg
from pak_pc.pak_gui.pak_widgets.mod_frm_reg_pc import ClsFrmRegPC
from pak_pc.pak_gui.pak_widgets.mod_frm_reg_bp import ClsFrmRegBP
from pak_pc.pak_gui.pak_widgets.mod_frm_cpu_frec import ClsFrmCpuFreq
from pak_pc.pak_gui.pak_widgets.mod_frm_reg_sp import ClsFrmRegSP
class ClsFrmCPU(Frame):
"""
Класс описывающий фрейм для отображения информации о состоянии
процессора.
:param root: ссылка на корневой класс.
"""
def __init__(self, root=None):
Frame.__init__(self, master=root, border=3, relief='sunken')
self.pack(side='top', fill='x')
# отображаем регистр программной отладки
self.frm_reg_bp = ClsFrmRegBP(root=self)
# отображаем программный счётчик
self.frm_reg_pc = ClsFrmRegPC(root=self)
# self.frm_reg_a.lbl_name['text']='reg_a'
# отображаем указатель стека
self.frm_reg_sp = ClsFrmRegSP(root=self)
# отображение регистра А
self.frm_reg_a = ClsFrmReg(root=self)
self.frm_reg_a.lbl_name['text'] = 'reg_a'
# отображение частоты виртуального процессора
self.frm_cpu_freq = ClsFrmCpuFreq(root=self)
| lgpl-3.0 | -1,709,216,792,433,874,700 | 32.214286 | 70 | 0.683154 | false |
alex-petrenko/hierarchical-rl | microtbs_rl/algorithms/a2c/multi_env.py | 1 | 3019 | import threading
import numpy as np
from queue import Queue
from microtbs_rl.utils.common_utils import *
logger = logging.getLogger(os.path.basename(__file__))
class _MultiEnvWorker:
"""
Helper class for the MultiEnv.
Currently implemented with threads, and it's slow because of GIL.
It would be much better to implement this with multiprocessing.
"""
def __init__(self, idx, make_env_func):
self.idx = idx
self.env = make_env_func()
self.env.seed(idx)
self.observation = self.env.reset()
self.action_queue = Queue()
self.result_queue = Queue()
self.thread = threading.Thread(target=self.start)
self.thread.start()
def start(self):
while True:
action = self.action_queue.get()
if action is None: # stop signal
logger.info('Stop worker %d...', self.idx)
break
observation, reward, done, _ = self.env.step(action)
if done:
observation = self.env.reset()
self.result_queue.put((observation, reward, done))
self.action_queue.task_done()
class MultiEnv:
"""Run multiple gym-compatible environments in parallel, keeping more or less the same interface."""
def __init__(self, num_envs, make_env_func):
self.num_envs = num_envs
self.workers = [_MultiEnvWorker(i, make_env_func) for i in range(num_envs)]
self.action_space = self.workers[0].env.action_space
self.observation_space = self.workers[0].env.observation_space
self.curr_episode_reward = [0] * num_envs
self.episode_rewards = [[]] * num_envs
def initial_observations(self):
return [worker.observation for worker in self.workers]
def step(self, actions):
"""Obviously, returns vectors of obs, rewards, dones instead of usual single values."""
assert len(actions) == len(self.workers)
for worker, action in zip(self.workers, actions):
worker.action_queue.put(action)
results = []
for worker in self.workers:
worker.action_queue.join()
results.append(worker.result_queue.get())
observations, rewards, dones = zip(*results)
for i in range(self.num_envs):
self.curr_episode_reward[i] += rewards[i]
if dones[i]:
self.episode_rewards[i].append(self.curr_episode_reward[i])
self.curr_episode_reward[i] = 0
return observations, rewards, dones
def close(self):
logger.info('Stopping multi env...')
for worker in self.workers:
worker.action_queue.put(None) # terminate
worker.thread.join()
def calc_avg_rewards(self, n):
avg_reward = 0
for i in range(self.num_envs):
last_episodes_rewards = self.episode_rewards[i][-n:]
avg_reward += np.mean(last_episodes_rewards)
return avg_reward / float(self.num_envs)
| mit | 1,352,694,666,587,328,800 | 30.447917 | 104 | 0.60583 | false |
greenpau/ndmtk | setup.py | 1 | 9670 | #
# ndmtk - Network Discovery and Management Toolkit
# Copyright (C) 2016 Paul Greenberg @greenpau
# See LICENSE.txt for licensing details
#
# File: setup.py
#
from __future__ import print_function;
try:
from setuptools import setup;
except ImportError:
from ez_setup import use_setuptools;
use_setuptools();
from setuptools.command.install import install;
from setuptools.command.sdist import sdist;
from setuptools.command.test import test;
from setuptools.command.develop import develop;
from setuptools import setup;
from codecs import open;
import traceback;
import unittest;
import os;
import sys;
import re;
import stat;
import unittest;
pkg_name = 'ndmtk';
pkg_ver = '0.2.0';
cmdclass = {};
def _load_test_suite():
test_loader = unittest.TestLoader();
test_suite = test_loader.discover(os.path.join(pkg_dir, pkg_name, 'tests'), pattern='test_*.py');
return test_suite;
def remove_ansible_files(ansible_dirs):
for ansible_dir in ansible_dirs:
for suffix in ['.py', '.pyc']:
for plugin_type in ['plugins/action', 'plugins/callback']:
plugin_file = os.path.join(ansible_dir, plugin_type , pkg_name + suffix);
if os.path.isfile(plugin_file) or os.path.islink(plugin_file):
print("[INFO] found '%s'" % plugin_file);
try:
if os.path.islink(plugin_file):
os.unlink(plugin_file);
else:
os.remove(plugin_file);
print("[INFO] removed '%s'" % plugin_file);
except:
exc_type, exc_value, exc_traceback = sys.exc_info();
print("[ERROR] failed to remove %s %s" % (plugin_file, ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))));
return
def pre_build_toolkit():
for ts in _load_test_suite():
tsr=unittest.TextTestRunner();
tr = tsr.run(ts);
if len(tr.failures) > 0:
for tf in tr.failures:
print('[ERROR] ' + str(tf[1]));
return [];
print("[INFO] checking whether 'ansible' python package is installed ...");
ansible_dirs = _find_py_package('ansible');
if len(ansible_dirs) == 0:
print("[ERROR] 'ansible' python package was not found");
return [];
print("[INFO] the path to 'ansible' python package is: " + str(ansible_dirs));
remove_ansible_files(ansible_dirs);
return ansible_dirs;
def _find_utility(name):
x = any(os.access(os.path.join(path, name), os.X_OK) for path in os.environ["PATH"].split(os.pathsep));
return x;
def _find_py_package(name):
pkg_dirs = [];
for path in sys.path:
if not re.search('site-packages$', path):
continue;
if not os.path.exists(path):
continue;
if not os.path.isdir(path):
continue
target = os.path.join(path, name);
if not os.path.exists(target):
continue;
if not os.path.isdir(target):
continue;
if target not in pkg_dirs:
pkg_dirs.append(target);
return pkg_dirs;
def _post_build_toolkit(ansible_dirs, plugin_dir=None):
if plugin_dir is None:
plugin_dirs = _find_py_package(pkg_name);
if len(plugin_dirs) > 0:
print("[INFO] the path to '" + pkg_name + "' python package is: " + str(plugin_dirs));
for d in plugin_dirs:
if re.search('bdist', d) or re.search('build', d):
continue;
plugin_dir = d;
break;
if plugin_dir is None:
print("[ERROR] failed to find '" + pkg_name + "' python package, aborting!");
return;
if re.search('bdist', plugin_dir) or re.search('build', plugin_dir):
return;
if re.search('site-packages.?$', plugin_dir):
plugin_dir += pkg_name;
print("[INFO] the path to '" + pkg_name + "' python package is: " + str(plugin_dir));
'''
Create a symlink, i.e. `ln -s TARGET LINK_NAME`
'''
_egg_files = [];
for ansible_dir in ansible_dirs:
for i in ['action', 'callback']:
symlink_target = os.path.join(plugin_dir, 'plugins/' + i + '/ndmtk.py');
symlink_name = os.path.join(ansible_dir, 'plugins/' + i + '/ndmtk.py');
try:
os.symlink(symlink_target, symlink_name);
os.chmod(symlink_name, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH);
_egg_files.append(symlink_name);
_egg_files.append(symlink_name + 'c');
print("[INFO] created symlink '" + symlink_name + "' to plugin '" + symlink_target + "'");
except:
exc_type, exc_value, exc_traceback = sys.exc_info();
print('[ERROR] an attempt to create a symlink ' + symlink_name + ' to plugin ' + symlink_target + ' failed, aborting!');
print(traceback.format_exception(exc_type, exc_value, exc_traceback));
return;
class install_(install):
def run(self):
ansible_dirs = pre_build_toolkit();
if len(ansible_dirs) == 0:
return 1;
install.run(self);
if len(ansible_dirs) > 0:
self.execute(_post_build_toolkit, (ansible_dirs, self.install_lib, ), msg="running post_install_scripts");
cmdclass['install'] = install_;
cmdclass['bdist_wheel'] = install_;
class uninstall_(develop):
def run(self):
plugin_dirs = [];
for dp in sys.path:
if not re.search('site-packages$', dp):
continue;
ds = [name for name in os.listdir(dp) if os.path.isdir(os.path.join(dp, name))];
if ds:
for d in ds:
if not re.match(pkg_name, d):
continue;
if os.path.join(dp, d) not in plugin_dirs:
plugin_dirs.append(os.path.join(dp, d));
if plugin_dirs:
for dp in plugin_dirs:
try:
for root, dirs, files in os.walk(dp, topdown=False):
for name in files:
if os.path.islink(os.path.join(root, name)):
os.unlink(os.path.join(root, name));
else:
os.remove(os.path.join(root, name));
for name in dirs:
os.rmdir(os.path.join(root, name));
os.rmdir(dp);
print("[INFO] deleted '" + dp + "'");
except:
print("[INFO] failed to delete '" + dp + "'");
exc_type, exc_value, exc_traceback = sys.exc_info();
print(traceback.format_exception(exc_type, exc_value, exc_traceback));
else:
print("[INFO] no relevant files for the uninstall found, all clean");
ansible_dirs = _find_py_package('ansible');
if len(ansible_dirs) == 0:
print("[ERROR] 'ansible' python package was not found");
return;
remove_ansible_files(ansible_dirs);
return;
cmdclass['uninstall'] = uninstall_;
pkg_dir = os.path.abspath(os.path.dirname(__file__));
pkg_license='OSI Approved :: GNU General Public License v3 or later (GPLv3+)';
pkg_description = 'Network Discovery and Management Toolkit packaged as Ansible Plugin';
pkg_url = 'https://github.com/greenpau/' + pkg_name;
#pkg_download_url = 'http://pypi.python.org/packages/source/' + pkg_name[0] + '/' + pkg_name + '/' + pkg_name + '-' + pkg_ver + '.tar.gz';
pkg_download_url = 'https://github.com/greenpau/ndmtk/archive/master.zip';
pkg_author = 'Paul Greenberg';
pkg_author_email = '[email protected]';
pkg_packages = [pkg_name.lower()];
pkg_requires = ['ansible>=2.0'];
pkg_data=[
'*.yml',
'*.j2',
'tests/*.py',
'plugins/callback/*.py',
'plugins/action/*.py',
'plugins/action/*.j2',
'plugins/action/*.yml',
'plugins/action/files/cli/os/*.yml',
'plugins/action/files/cli/core/*.yml',
'README.rst',
'LICENSE.txt',
];
pkg_platforms='any';
pkg_classifiers=[
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Information Technology',
'Intended Audience :: System Administrators',
'Intended Audience :: Telecommunications Industry',
'License :: ' + pkg_license,
'Programming Language :: Python',
'Operating System :: POSIX :: Linux',
'Topic :: Utilities',
'Topic :: System :: Networking',
'Topic :: System :: Networking :: Monitoring',
'Topic :: System :: Systems Administration',
];
pkg_keywords=[
'ansible',
'ansible plugin',
'network',
'ssh',
'telnet',
'console',
'automation',
'network automation',
'network discovery',
];
pkg_test_suite='setup._load_test_suite';
pkg_long_description=pkg_description;
with open(os.path.join(pkg_dir, pkg_name, 'README.rst'), encoding='utf-8') as f:
pkg_long_description = f.read();
setup(
name=pkg_name,
version=pkg_ver,
description=pkg_description,
long_description=pkg_long_description,
url=pkg_url,
download_url=pkg_download_url,
author=pkg_author,
author_email=pkg_author_email,
license=pkg_license,
platforms=pkg_platforms,
classifiers=pkg_classifiers,
packages=pkg_packages,
package_data= {
pkg_name.lower() : pkg_data,
},
keywords=pkg_keywords,
install_requires=pkg_requires,
test_suite=pkg_test_suite,
cmdclass=cmdclass
);
| gpl-3.0 | -8,815,621,890,355,421,000 | 35.217228 | 153 | 0.57001 | false |
amarian12/p2pool-adaptive-nvc | p2pool/networks.py | 1 | 2034 | from p2pool.bitcoin import networks
from p2pool.util import math
# CHAIN_LENGTH = number of shares back client keeps
# REAL_CHAIN_LENGTH = maximum number of shares back client uses to compute payout
# REAL_CHAIN_LENGTH must always be <= CHAIN_LENGTH
# REAL_CHAIN_LENGTH must be changed in sync with all other clients
# changes can be done by changing one, then the other
nets = dict(
novacoin=math.Object(
PARENT=networks.nets['novacoin'],
SHARE_PERIOD=15, # seconds
CHAIN_LENGTH=12*60*60//10, # shares
REAL_CHAIN_LENGTH=12*60*60//10, # shares
TARGET_LOOKBEHIND=200, # shares
SPREAD=3, # blocks
IDENTIFIER='e037d5b8c6923610'.decode('hex'),
PREFIX='7208c1a53ef659b0'.decode('hex'),
P2P_PORT=39946,
MIN_TARGET=0,
MAX_TARGET=2**256//2**20 - 1,
PERSIST=True,
WORKER_PORT=8891,
BOOTSTRAP_ADDRS='37.57.95.59:8777 81.200.241.54:8777 82.200.205.39:8777 82.234.193.23:8777 85.198.114.251:8777 85.234.62.99:8777 89.239.190.22:8777 89.250.210.94:8777 94.198.0.39:8777 95.84.138.99:8777 109.238.244.73:8777 176.37.148.85:8777 178.19.249.43:8777 178.159.127.151:8777 188.130.184.1:8777 212.98.191.90:8777 212.113.35.38:8777'.split(' '),
ANNOUNCE_CHANNEL='#p2pool-alt',
VERSION_CHECK=lambda v: v >= 60011,
),
novacoin_testnet=math.Object(
PARENT=networks.nets['novacoin_testnet'],
SHARE_PERIOD=4, # seconds
CHAIN_LENGTH=20*60//3, # shares
REAL_CHAIN_LENGTH=20*60//3, # shares
TARGET_LOOKBEHIND=200, # shares
SPREAD=3, # blocks
IDENTIFIER='e037d5b8c7923110'.decode('hex'),
PREFIX='7208c1a54ef619b0'.decode('hex'),
P2P_PORT=18777,
MIN_TARGET=0,
MAX_TARGET=2**256//2**20 - 1,
PERSIST=False,
WORKER_PORT=18336,
BOOTSTRAP_ADDRS=''.split(' '),
ANNOUNCE_CHANNEL='#p2pool-alt',
VERSION_CHECK=lambda v: v >= 60011,
),
)
for net_name, net in nets.iteritems():
net.NAME = net_name
| gpl-3.0 | 8,468,677,192,613,597,000 | 40.510204 | 358 | 0.636676 | false |
bburan/psiexperiment | psi/controller/output.py | 1 | 9465 | import logging
log = logging.getLogger(__name__)
from types import GeneratorType
from functools import partial
import numpy as np
from atom.api import (Unicode, Enum, Event, Typed, Property, Float, Int, Bool,
List)
import enaml
from enaml.application import deferred_call
from enaml.core.api import Declarative, d_
from enaml.workbench.api import Extension
from ..util import coroutine, SignalBuffer
from .queue import AbstractSignalQueue
from psi.core.enaml.api import PSIContribution
import time
class Synchronized(PSIContribution):
outputs = Property()
engines = Property()
def _get_outputs(self):
return self.children
def _get_engines(self):
return set(o.engine for o in self.outputs)
class Output(PSIContribution):
name = d_(Unicode()).tag(metadata=True)
label = d_(Unicode()).tag(metadata=True)
target_name = d_(Unicode())
target = d_(Typed(Declarative).tag(metadata=True), writable=False)
channel = Property()
engine = Property()
# These two are defined as properties because it's theoretically possible
# for the output to transform these (e.g., an output could upsample
# children or "equalize" something before passing it along).
fs = Property().tag(metadata=True)
calibration = Property().tag(metadata=True)
filter_delay = Property().tag(metadata=True)
# TODO: clean this up. it's sort of hackish.
token = d_(Typed(Declarative))
# Can the user configure properties (such as the token) via the GUI?
configurable = d_(Bool(True))
callbacks = List()
def connect(self, cb):
self.callbacks.append(cb)
def notify(self, data):
# Correct for filter delay
d = data.copy()
d['t0'] += self.filter_delay
for cb in self.callbacks:
cb(d)
def _get_engine(self):
if self.channel is None:
return None
else:
return self.channel.engine
def _get_channel(self):
from .channel import Channel
target = self.target
while True:
if target is None:
return None
elif isinstance(target, Channel):
return target
else:
target = target.target
def _get_filter_delay(self):
return self.target.filter_delay
def _get_fs(self):
return self.channel.fs
def _get_calibration(self):
return self.channel.calibration
def is_ready(self):
raise NotImplementedError
class BufferedOutput(Output):
dtype = Unicode('double')
buffer_size = Property()
active = Bool(False)
source = Typed(object)
_buffer = Typed(SignalBuffer)
_offset = Int(0)
def _get_buffer_size(self):
return self.channel.buffer_size
def _default__buffer(self):
return SignalBuffer(self.fs, self.buffer_size, 0, self.dtype)
def get_samples(self, offset, samples, out):
lb = offset
ub = offset + samples
buffered_lb = self._buffer.get_samples_lb()
buffered_ub = self._buffer.get_samples_ub()
log.trace('Getting %d samples from %d to %d for %s', samples, lb, ub,
self.name)
log.trace('Buffer has %d to %d for %s', buffered_lb, buffered_ub,
self.name)
if lb > buffered_ub:
# This breaks an implicit software contract.
raise SystemError('Mismatch between offsets')
elif lb == buffered_ub:
log.trace('Generating new data')
pass
elif lb >= buffered_lb and ub <= buffered_ub:
log.trace('Extracting from buffer')
out[:] = self._buffer.get_range_samples(lb, ub)
samples = 0
offset = ub
elif lb >= buffered_lb and ub > buffered_ub:
log.trace('Extracting from buffer and generating new data')
b = self._buffer.get_range_samples(lb)
s = b.shape[-1]
out[:s] = b
samples -= s
offset += s
# Don't generate new samples if occuring before activation.
if (samples > 0) and (offset < self._offset):
s = min(self._offset-offset, samples)
data = np.zeros(s)
self._buffer.append_data(data)
if (samples == s):
out[-samples:] = data
else:
out[-samples:-samples+s] = data
samples -= s
offset += s
# Generate new samples
if samples > 0:
data = self.get_next_samples(samples)
self._buffer.append_data(data)
out[-samples:] = data
def get_next_samples(self, samples):
raise NotImplementedError
def activate(self, offset):
log.debug('Activating %s at %d', self.name, offset)
self.active = True
self._offset = offset
self._buffer.invalidate_samples(offset)
def deactivate(self, offset):
log.debug('Deactivating %s at %d', self.name, offset)
self.active = False
self.source = None
self._buffer.invalidate_samples(offset)
def is_ready(self):
return self.source is not None
def get_duration(self):
return self.source.get_duration()
class EpochOutput(BufferedOutput):
def get_next_samples(self, samples):
log.trace('Getting %d samples for %s', samples, self.name)
if self.active:
buffered_ub = self._buffer.get_samples_ub()
# Pad with zero
zero_padding = max(self._offset-buffered_ub, 0)
zero_padding = min(zero_padding, samples)
waveform_samples = samples - zero_padding
waveforms = []
if zero_padding:
w = np.zeros(zero_padding, dtype=self.dtype)
waveforms.append(w)
if waveform_samples:
w = self.source.next(waveform_samples)
waveforms.append(w)
if self.source.is_complete():
self.deactivate(self._buffer.get_samples_ub())
waveform = np.concatenate(waveforms, axis=-1)
else:
waveform = np.zeros(samples, dtype=self.dtype)
return waveform
class QueuedEpochOutput(BufferedOutput):
queue = d_(Typed(AbstractSignalQueue))
auto_decrement = d_(Bool(False))
complete_cb = Typed(object)
complete = d_(Event(), writable=False)
def _observe_queue(self, event):
self.source = self.queue
self._update_queue()
def _observe_target(self, event):
self._update_queue()
def _update_queue(self):
if self.queue is not None and self.target is not None:
self.queue.set_fs(self.fs)
self.queue.connect(self.notify)
def get_next_samples(self, samples):
if self.active:
waveform, empty = self.queue.pop_buffer(samples, self.auto_decrement)
if empty and self.complete_cb is not None:
self.complete = True
log.debug('Queue empty. Calling complete callback.')
deferred_call(self.complete_cb)
self.active = False
else:
waveform = np.zeros(samples, dtype=np.double)
return waveform
def add_setting(self, setting, averages=None, iti_duration=None):
with enaml.imports():
from .output_manifest import initialize_factory
# Make a copy to ensure that we don't accidentally modify in-place
context = setting.copy()
if averages is None:
averages = context.pop(f'{self.name}_averages')
if iti_duration is None:
iti_duration = context.pop(f'{self.name}_iti_duration')
# Somewhat surprisingly it appears to be faster to use factories in the
# queue rather than creating the waveforms for ABR tone pips, even for
# very short signal durations.
#context['fs'] = self.fs
#context['calibration'] = self.calibration
# I'm not in love with this since it requires hooking into the
# manifest system.
factory = initialize_factory(self, self.token, context)
duration = factory.get_duration()
self.queue.append(factory, averages, iti_duration, duration, setting)
def activate(self, offset):
log.debug('Activating output at %d', offset)
super().activate(offset)
self.queue.set_t0(offset/self.fs)
def get_duration(self):
# TODO: add a method to get actual duration from queue.
return np.inf
class SelectorQueuedEpochOutput(QueuedEpochOutput):
selector_name = d_(Unicode('default'))
class ContinuousOutput(BufferedOutput):
def get_next_samples(self, samples):
if self.active:
return self.source.next(samples)
else:
return np.zeros(samples, dtype=np.double)
class DigitalOutput(Output):
pass
class Trigger(DigitalOutput):
duration = d_(Float(0.1))
def fire(self):
if self.engine.configured:
self.engine.fire_sw_do(self.channel.name, duration=self.duration)
class Toggle(DigitalOutput):
state = Bool(False)
def _observe_state(self, event):
if self.engine is not None and self.engine.configured:
self.engine.set_sw_do(self.channel.name, event['value'])
def set_high(self):
self.state = True
def set_low(self):
self.state = False
| mit | 1,338,692,515,982,732,500 | 28.670846 | 81 | 0.604015 | false |
elemel/torn | lib/torn/ik.py | 1 | 1441 | from euclid import *
from math import *
__all__ = ['solve']
def solve(vertices, target):
if len(vertices) == 2:
return solve_one_edge(vertices, target)
elif len(vertices) == 3:
return solve_two_edges(vertices, target)
else:
return vertices
def solve_one_edge(vertices, target):
v1, v2 = vertices
if v1 == target:
return vertices
return v1, v1 + abs(v2 - v1) * (target - v1).normalize()
def solve_two_edges(vertices, target):
v1, v2, v3 = vertices
u = target - v1
d = abs(u)
u1 = v2 - v1
u2 = v3 - v2
d1 = abs(u1)
d2 = abs(u2)
if d == 0:
v3 = v2 - (d2 / d1) * u1
elif d >= d1 + d2:
v2 = v1 + (d1 / d) * u
v3 = v2 + (d2 / d) * u
elif d <= d1 - d2:
v2 = v1 + (d1 / d) * u
v3 = v2 - (d2 / d) * u
elif d <= d2 - d1:
v2 = v1 - (d1 / d) * u
v3 = v2 + (d2 / d) * u
else:
# Closed form solution 2 from "Oh My God, I Inverted Kine!" by
# Jeff Lander.
#
# http://www.darwin3d.com/gamedev/articles/col0998.pdf
a1 = atan2(u.y, u.x)
a2 = acos((u.x ** 2 + u.y ** 2 + d1 ** 2 -
d2 ** 2) / (2 * d1 * d))
# Maintain winding.
if u1.x * u2.y - u2.x * u1.y < 0:
a = a1 + a2
else:
a = a1 - a2
v2 = v1 + d1 * Vector2(cos(a), sin(a))
v3 = target
return v1, v2, v3
| mit | -3,554,647,439,984,454,700 | 24.732143 | 70 | 0.461485 | false |
montylounge/django-sugar | sugar/templatetags/media.py | 1 | 1435 | from django.template import Library, Node
from django.template.loader import render_to_string
from django.contrib.sites.models import Site
from django.conf import settings
import os, urlparse
register = Library()
def _absolute_url(url):
if url.startswith('http://') or url.startswith('https://'):
return url
domain = Site.objects.get_current().domain
return 'http://%s%s' % (domain, url)
@register.simple_tag
def media(filename, flags=''):
"""
Autor: http://softwaremaniacs.org/blog/2009/03/22/media-tag/
{% load media %}
<link rel="stylesheet" href="{% media "css/style.css" %}">
{% media "css/style.css" %} <!-- ...style.css?123456789 -->
{% media "css/style.css" "no-timestamp" %} <!-- ...style.css -->
{% media "images/edit.png" "timestamp" %} <!-- ...edit.png?123456789 -->
{% media "images/edit.png" "absolute" %} <!-- http://example.com/media/edit.png -->
"""
flags = set(f.strip() for f in flags.split(','))
url = urlparse.urljoin(settings.MEDIA_URL, filename)
if 'absolute' in flags:
url = _absolute_url(url)
if (filename.endswith('.css') or filename.endswith('.js')) and 'no-timestamp' not in flags or \
'timestamp' in flags:
fullname = os.path.join(settings.MEDIA_ROOT, filename)
if os.path.exists(fullname):
url += '?%d' % os.path.getmtime(fullname)
return url | bsd-3-clause | 6,945,768,594,678,225,000 | 37.810811 | 99 | 0.611847 | false |
google/mirandum | alerts/main/migrations/0015_auto_20160606_0610.py | 1 | 4393 | # -*- coding: utf-8 -*-
# Copyright 2016 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('main', '0014_session'),
]
operations = [
migrations.AddField(
model_name='alertconfig',
name='animation_in',
field=models.CharField(default=b'fadeIn', max_length=100, null=True, blank=True, choices=[(b'fadeIn', b'Fade In'), (b'fadeInDown', b'Fade In Down'), (b'fadeInDownBig', b'Fade In Down Big'), (b'fadeInLeft', b'Fade In Left'), (b'fadeInLeftBig', b'Fade In Left Big'), (b'fadeInRight', b'Fade In Right'), (b'fadeInRightBig', b'Fade In'), (b'fadeInUp', b'Fade In Up'), (b'fadeInUpBig', b'Fade In Up Big'), (b'zoomIn', b'Zoom In'), (b'zoomInDown', b'Zoom In Down'), (b'zoomInLeft', b'Zoom In Left'), (b'zoomInRight', b'Zoom In Right'), (b'zoomInUp', b'Zoom In Up'), (b'bounceIn', b'Bounce In'), (b'bounceInDown', b'Bounce In Down'), (b'bounceInLeft', b'Bounce In Left'), (b'bounceInRight', b'Bounce In Right'), (b'bounceInUp', b'Bounce In Up'), (b'slideInUp', b'Slide In Up'), (b'slideInDown', b'Slide In Down'), (b'slideInLeft', b'Slide In Left'), (b'slideInRight', b'Slide In Right')]),
preserve_default=True,
),
migrations.AddField(
model_name='alertconfig',
name='animation_out',
field=models.CharField(default=b'fadeOut', max_length=100, null=True, blank=True, choices=[(b'fadeOut', b'Fade Out'), (b'fadeOutDown', b'Fade Out Down'), (b'fadeOutDownBig', b'Fade Out Down Big'), (b'fadeOutLeft', b'Fade Out Left'), (b'fadeOutLeftBig', b'Fade Out Left Big'), (b'fadeOutRight', b'Fade Out Right'), (b'fadeOutRightBig', b'Fade Out'), (b'fadeOutUp', b'Fade Out Up'), (b'fadeOutUpBig', b'Fade Out Up Big'), (b'zoomOut', b'Zoom Out'), (b'zoomOutDown', b'Zoom Out Down'), (b'zoomOutLeft', b'Zoom Out Left'), (b'zoomOutRight', b'Zoom Out Right'), (b'zoomOutUp', b'Zoom Out Up'), (b'bounceOut', b'Bounce Out'), (b'bounceOutDown', b'Bounce Out Down'), (b'bounceOutLeft', b'Bounce Out Left'), (b'bounceOutRight', b'Bounce Out Right'), (b'bounceOutUp', b'Bounce Out Up'), (b'slideOutUp', b'Slide Out Up'), (b'slideOutDown', b'Slide Out Down'), (b'slideOutLeft', b'Slide Out Left'), (b'slideOutRight', b'Slide Out Right')]),
preserve_default=True,
),
migrations.AddField(
model_name='alertconfig',
name='font_effect',
field=models.CharField(default=b'shadow', max_length=100, null=True, blank=True, choices=[(b'shadow', b'Normal Shadow'), (b'anaglyph', b'Anaglyph'), (b'brick-sign', b'Brick Sign'), (b'canvas-print', b'Canvas Print'), (b'crackle', b'Crackle'), (b'decaying', b'Decaying'), (b'destruction', b'Destruction'), (b'distressed', b'Distressed'), (b'distressed-wood', b'Distressed Wood'), (b'emboss', b'Emboss'), (b'fire', b'Fire'), (b'fire-animation', b'Fire Animation'), (b'fragile', b'Fragile'), (b'grass', b'Grass'), (b'ice', b'Ice'), (b'mitosis', b'Mitosis'), (b'neon', b'Neon'), (b'outline', b'Outline'), (b'putting-green', b'Putting Green'), (b'scuffed-steel', b'Scuffed Steel'), (b'splintered', b'Splintered'), (b'static', b'Static'), (b'stonewash', b'Stonewash'), (b'3d', b'3d'), (b'3d-float', b'3d Float'), (b'vintage', b'Vintage'), (b'wallpaper', b'Wallpaper')]),
preserve_default=True,
),
migrations.AddField(
model_name='alertconfig',
name='layout',
field=models.CharField(blank=True, max_length=100, null=True, help_text=b'Alert layout (only available with v2 AlertBox)', choices=[(b'vertical', b'Image above text'), (b'side', b'Image next to text'), (b'above', b'Text on top of image')]),
preserve_default=True,
),
]
| apache-2.0 | 7,792,831,731,491,586,000 | 85.137255 | 941 | 0.644434 | false |
FordyceLab/AcqPack | acqpack/fractioncollector.py | 1 | 3626 | import numpy as np
import pandas as pd
import utils as ut
class FractionCollector:
"""
A high-level wrapper around an XY stage.
"""
def __init__(self, xy):
self.frames = pd.DataFrame(index=['trans', 'position_table'])
self.add_frame('hardware')
self.XY = xy
def add_frame(self, name, trans=np.eye(3,3), position_table=None):
"""
Adds coordinate frame. Frame requires affine transform to hardware coordinates; position_table optional.
:param name: (str) the name to be given to the frame (e.g. hardware)
:param trans: (np.ndarray <- str) xyw affine transform matrix; if string, tries to load delimited file
:param position_table: (None | pd.DataFrame <- str) position_table; if string, tries to load delimited file
"""
if isinstance(trans, str):
trans = ut.read_delim_pd(trans).select_dtypes(['number']).values
if isinstance(position_table, str):
position_table = ut.read_delim_pd(position_table)
assert(isinstance(trans, np.ndarray)) # trans: numpy array of shape (3,3)
assert(trans.shape==(3,3)) # check size
assert(np.array_equal(np.linalg.norm(trans[:-1,:-1]),
np.linalg.norm(np.eye(2,2)))) # Frob norm rotation invariant (no scaling)
assert(trans[-1,-1] != 0) # cannot be singular matrix
# position_table: DataFrame with x,y OR None
if isinstance(position_table, pd.DataFrame):
assert(set(list('xy')).issubset(position_table.columns)) # contains 'x','y' columns
else:
assert(position_table is None)
self.frames[name] = None
self.frames[name].trans = trans
self.frames[name].position_table = position_table
def where(self, frame=None):
"""
Retrieves current hardware (x,y). If frame is specified, transforms hardware coordinates into
frame's coordinates.
:param frame: (str) name of frame to specify transform (optional)
:return: (tup) current position
"""
where = self.XY.where_xy()
if frame is not None:
where += (1,)
x, y, _ = tuple(np.dot(where, np.linalg.inv(self.frames[frame].trans)))
where = x, y
return where
def home(self):
"""
Homes XY axes.
"""
self.XY.home_xy()
# TODO: if no columns specified, transform provided XY to hardware coordinates.
# TODO: default frame?
def goto(self, frame, lookup_columns, lookup_values):
"""
Finds lookup_values in lookup_columns of frame's position_list; retrieves corresponding X,Y
Transforms X,Y to hardware X,Y by frame's transform.
Moves to hardware X,Y.
:param frame: (str) frame that specifies position_list and transform
:param lookup_columns: (str | list) column(s) to search in position_table
:param lookup_values: (val | list) values(s) to find in lookup_columns
"""
trans, position_table = self.frames[frame]
if lookup_columns=='xy':
lookup_values = tuple(lookup_values) + (1,)
xh, yh = np.dot(lookup_values, trans)
else:
xy = tuple(ut.lookup(position_table, lookup_columns, lookup_values)[['x', 'y']].iloc[0])
xyw = xy + (1,) # concatenate for translation
xh, yh, _ = np.dot(xyw, trans) # get hardware coordinates
self.XY.goto_xy(xh, yh)
def exit(self):
"""
Send exit command to XY.
"""
self.XY.exit()
| mit | 6,732,813,930,604,466,000 | 37.168421 | 115 | 0.593767 | false |
juju-solutions/charms.reactive | charms/reactive/relations.py | 1 | 33565 | # Copyright 2014-2017 Canonical Limited.
#
# This file is part of charms.reactive
#
# charms.reactive is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License version 3 as
# published by the Free Software Foundation.
#
# charms.reactive 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 charm-helpers. If not, see <http://www.gnu.org/licenses/>.
import os
import sys
import importlib
from inspect import isclass
from charmhelpers.core import hookenv
from charmhelpers.core import unitdata
from charmhelpers.cli import cmdline
from charms.reactive.flags import get_flags
from charms.reactive.flags import _get_flag_value
from charms.reactive.flags import set_flag
from charms.reactive.flags import clear_flag
from charms.reactive.flags import StateList
from charms.reactive.bus import _append_path
try:
from importlib.metadata import entry_points
except ImportError:
from pkg_resources import iter_entry_points
def entry_points():
group = 'charms.reactive.relation_factory'
return {group: list(iter_entry_points(group))}
__all__ = [
'endpoint_from_name',
'endpoint_from_flag',
'relation_from_flag', # DEPRECATED
'scopes', # DEPRECATED
'RelationBase', # DEPRECATED
'relation_from_state', # DEPRECATED
]
# arbitrary obj instances to use as defaults instead of None
ALL = object()
TOGGLE = object()
def endpoint_from_name(endpoint_name):
"""The object used for interacting with the named relations, or None.
"""
if endpoint_name is None:
return None
factory = relation_factory(endpoint_name)
if factory:
return factory.from_name(endpoint_name)
def relation_from_name(relation_name):
"""
.. deprecated:: 0.6.0
Alias for :func:`endpoint_from_name`
"""
return endpoint_from_name(relation_name)
def endpoint_from_flag(flag):
"""The object used for interacting with relations tied to a flag, or None.
"""
relation_name = None
value = _get_flag_value(flag)
if isinstance(value, dict) and 'relation' in value:
# old-style RelationBase
relation_name = value['relation']
elif flag.startswith('endpoint.'):
# new-style Endpoint
relation_name = flag.split('.')[1]
elif '.' in flag:
# might be an unprefixed new-style Endpoint
relation_name = flag.split('.')[0]
if relation_name not in hookenv.relation_types():
return None
if relation_name:
factory = relation_factory(relation_name)
if factory:
return factory.from_flag(flag)
return None
def relation_from_flag(flag):
"""
.. deprecated:: 0.6.0
Alias for :func:`endpoint_from_flag`
"""
return endpoint_from_flag(flag)
def relation_from_state(state):
"""
.. deprecated:: 0.5.0
Alias for :func:`endpoint_from_flag`
"""
return endpoint_from_flag(state)
class RelationFactory(object):
"""Produce objects for interacting with a relation.
Interfaces choose which RelationFactory is used for their relations
by adding a RelationFactory subclass to
``$CHARM_DIR/hooks/relations/{interface}/{provides,requires,peer}.py``.
This is normally a RelationBase subclass.
"""
_factories = []
@classmethod
def discover(cls):
for ep in entry_points().get('charms.reactive.relation_factory', []):
factory = ep.load()
factory.load()
RelationFactory._factories.append(factory)
@classmethod
def get_factory(cls, relation_name):
for factory in RelationFactory._factories:
if factory.from_name(relation_name):
return factory
return None
@classmethod
def from_name(cls, relation_name):
raise NotImplementedError()
@classmethod
def from_flag(cls, state):
raise NotImplementedError()
def relation_factory(relation_name):
"""Get the RelationFactory for the given relation name.
Looks for a RelationFactory in the first file matching:
``$CHARM_DIR/hooks/relations/{interface}/{provides,requires,peer}.py``
"""
factory = RelationFactory.get_factory(relation_name)
if factory:
return factory
role, interface = hookenv.relation_to_role_and_interface(relation_name)
if not (role and interface):
hookenv.log('Unable to determine role and interface for relation '
'{}'.format(relation_name), hookenv.ERROR)
return None
return _find_relation_factory(_relation_module(role, interface))
def _relation_module(role, interface):
"""
Return module for relation based on its role and interface, or None.
Prefers new location (reactive/relations) over old (hooks/relations).
"""
_append_path(hookenv.charm_dir())
_append_path(os.path.join(hookenv.charm_dir(), 'hooks'))
base_module = 'relations.{}.{}'.format(interface, role)
for module in ('reactive.{}'.format(base_module), base_module):
if module in sys.modules:
break
try:
importlib.import_module(module)
break
except ImportError:
continue
else:
hookenv.log('Unable to find implementation for relation: '
'{} of {}'.format(role, interface), hookenv.ERROR)
return None
return sys.modules[module]
def _find_relation_factory(module):
"""
Attempt to find a RelationFactory subclass in the module.
Note: RelationFactory and RelationBase are ignored so they may
be imported to be used as base classes without fear.
"""
if not module:
return None
# All the RelationFactory subclasses
candidates = [o for o in (getattr(module, attr) for attr in dir(module))
if (o is not RelationFactory and
o is not RelationBase and
isclass(o) and
issubclass(o, RelationFactory))]
# Filter out any factories that are superclasses of another factory
# (none of the other factories subclass it). This usually makes
# the explict check for RelationBase and RelationFactory unnecessary.
candidates = [c1 for c1 in candidates
if not any(issubclass(c2, c1) for c2 in candidates
if c1 is not c2)]
if not candidates:
hookenv.log('No RelationFactory found in {}'.format(module.__name__),
hookenv.WARNING)
return None
if len(candidates) > 1:
raise RuntimeError('Too many RelationFactory found in {}'
''.format(module.__name__))
return candidates[0]
class scopes(object):
"""
These are the recommended scope values for relation implementations.
To use, simply set the ``scope`` class variable to one of these::
class MyRelationClient(RelationBase):
scope = scopes.SERVICE
"""
GLOBAL = 'global'
"""
All connected services and units for this relation will share a single
conversation. The same data will be broadcast to every remote unit, and
retrieved data will be aggregated across all remote units and is expected
to either eventually agree or be set by a single leader.
"""
SERVICE = 'service'
"""
Each connected service for this relation will have its own conversation.
The same data will be broadcast to every unit of each service's conversation,
and data from all units of each service will be aggregated and is expected
to either eventually agree or be set by a single leader.
"""
UNIT = 'unit'
"""
Each connected unit for this relation will have its own conversation. This
is the default scope. Each unit's data will be retrieved individually, but
note that due to how Juju works, the same data is still broadcast to all
units of a single service.
"""
class AutoAccessors(type):
"""
Metaclass that converts fields referenced by ``auto_accessors`` into
accessor methods with very basic doc strings.
"""
def __new__(cls, name, parents, dct):
for field in dct.get('auto_accessors', []):
meth_name = field.replace('-', '_')
meth = cls._accessor(field)
meth.__name__ = meth_name
meth.__module__ = dct.get('__module__')
meth.__doc__ = 'Get the %s, if available, or None.' % field
dct[meth_name] = meth
return super(AutoAccessors, cls).__new__(cls, name, parents, dct)
@staticmethod
def _accessor(field):
def __accessor(self):
return self.get_remote(field)
return __accessor
class RelationBase(RelationFactory, metaclass=AutoAccessors):
"""
A base class for relation implementations.
"""
_cache = {}
scope = scopes.UNIT
"""
Conversation scope for this relation.
The conversation scope controls how communication with connected units
is aggregated into related :class:`Conversations <Conversation>`, and
can be any of the predefined :class:`scopes`, or any arbitrary string.
Connected units which share the same scope will be considered part of
the same conversation. Data sent to a conversation is sent to all units
that are a part of that conversation, and units that are part of a
conversation are expected to agree on the data that they send, whether
via eventual consistency or by having a single leader set the data.
The default scope is :attr:`scopes.UNIT`.
"""
class states(StateList):
"""
This is the set of :class:`States <charms.reactive.bus.State>` that this
relation could set.
This should be defined by the relation subclass to ensure that
states are consistent and documented, as well as being discoverable
and introspectable by linting and composition tools.
For example::
class MyRelationClient(RelationBase):
scope = scopes.GLOBAL
auto_accessors = ['host', 'port']
class states(StateList):
connected = State('{relation_name}.connected')
available = State('{relation_name}.available')
@hook('{requires:my-interface}-relation-{joined,changed}')
def changed(self):
self.set_state(self.states.connected)
if self.host() and self.port():
self.set_state(self.states.available)
"""
pass
auto_accessors = []
"""
Remote field names to be automatically converted into accessors with
basic documentation.
These accessors will just call :meth:`get_remote` using the
:meth:`default conversation <conversation>`. Note that it is highly
recommended that this be used only with :attr:`scopes.GLOBAL` scope.
"""
@classmethod
def _startup(cls):
# update data to be backwards compatible after fix for issue 28
_migrate_conversations()
if hookenv.hook_name().endswith('-relation-departed'):
def depart_conv():
cls(hookenv.relation_type()).conversation().depart()
hookenv.atexit(depart_conv)
def __init__(self, relation_name, conversations=None):
self._relation_name = relation_name
self._conversations = conversations or [Conversation.join(self.scope)]
@property
def relation_name(self):
"""
Name of the relation this instance is handling.
"""
return self._relation_name
@classmethod
def from_state(cls, state):
"""
.. deprecated:: 0.6.1
use :func:`endpoint_from_flag` instead
"""
return cls.from_flag(state)
@classmethod
def from_flag(cls, flag):
"""
Find relation implementation in the current charm, based on the
name of an active flag.
You should not use this method directly.
Use :func:`endpoint_from_flag` instead.
"""
value = _get_flag_value(flag)
if value is None:
return None
relation_name = value['relation']
conversations = Conversation.load(value['conversations'])
return cls.from_name(relation_name, conversations)
@classmethod
def from_name(cls, relation_name, conversations=None):
"""
Find relation implementation in the current charm, based on the
name of the relation.
:return: A Relation instance, or None
"""
if relation_name is None:
return None
relation_class = cls._cache.get(relation_name)
if relation_class:
return relation_class(relation_name, conversations)
role, interface = hookenv.relation_to_role_and_interface(relation_name)
if role and interface:
relation_class = cls._find_impl(role, interface)
if relation_class:
cls._cache[relation_name] = relation_class
return relation_class(relation_name, conversations)
return None
@classmethod
def _find_impl(cls, role, interface):
"""
Find relation implementation based on its role and interface.
"""
module = _relation_module(role, interface)
if not module:
return None
return cls._find_subclass(module)
@classmethod
def _find_subclass(cls, module):
"""
Attempt to find subclass of :class:`RelationBase` in the given module.
Note: This means strictly subclasses and not :class:`RelationBase` itself.
This is to prevent picking up :class:`RelationBase` being imported to be
used as the base class.
"""
for attr in dir(module):
candidate = getattr(module, attr)
if (isclass(candidate) and issubclass(candidate, cls) and
candidate is not RelationBase):
return candidate
return None
def conversations(self):
"""
Return a list of the conversations that this relation is currently handling.
Note that "currently handling" means for the current state or hook context,
and not all conversations that might be active for this relation for other
states.
"""
return list(self._conversations)
def conversation(self, scope=None):
"""
Get a single conversation, by scope, that this relation is currently handling.
If the scope is not given, the correct scope is inferred by the current
hook execution context. If there is no current hook execution context, it
is assume that there is only a single global conversation scope for this
relation. If this relation's scope is not global and there is no current
hook execution context, then an error is raised.
"""
if scope is None:
if self.scope is scopes.UNIT:
scope = hookenv.remote_unit()
elif self.scope is scopes.SERVICE:
scope = hookenv.remote_service_name()
else:
scope = self.scope
if scope is None:
raise ValueError('Unable to determine default scope: no current hook or global scope')
for conversation in self._conversations:
if conversation.scope == scope:
return conversation
else:
raise ValueError("Conversation with scope '%s' not found" % scope)
def set_state(self, state, scope=None):
"""
Set the state for the :class:`Conversation` with the given scope.
In Python, this is equivalent to::
relation.conversation(scope).set_state(state)
See :meth:`conversation` and :meth:`Conversation.set_state`.
"""
self.conversation(scope).set_state(state)
set_flag = set_state
def remove_state(self, state, scope=None):
"""
Remove the state for the :class:`Conversation` with the given scope.
In Python, this is equivalent to::
relation.conversation(scope).remove_state(state)
See :meth:`conversation` and :meth:`Conversation.remove_state`.
"""
self.conversation(scope).remove_state(state)
remove_flag = remove_state
def is_state(self, state, scope=None):
"""
Test the state for the :class:`Conversation` with the given scope.
In Python, this is equivalent to::
relation.conversation(scope).is_state(state)
See :meth:`conversation` and :meth:`Conversation.is_state`.
"""
return self.conversation(scope).is_state(state)
is_flag_set = is_state
def toggle_state(self, state, active=TOGGLE, scope=None):
"""
Toggle the state for the :class:`Conversation` with the given scope.
In Python, this is equivalent to::
relation.conversation(scope).toggle_state(state, active)
See :meth:`conversation` and :meth:`Conversation.toggle_state`.
"""
self.conversation(scope).toggle_state(state, active)
toggle_flag = toggle_state
def set_remote(self, key=None, value=None, data=None, scope=None, **kwdata):
"""
Set data for the remote end(s) of the :class:`Conversation` with the given scope.
In Python, this is equivalent to::
relation.conversation(scope).set_remote(key, value, data, scope, **kwdata)
See :meth:`conversation` and :meth:`Conversation.set_remote`.
"""
self.conversation(scope).set_remote(key, value, data, **kwdata)
def get_remote(self, key, default=None, scope=None):
"""
Get data from the remote end(s) of the :class:`Conversation` with the given scope.
In Python, this is equivalent to::
relation.conversation(scope).get_remote(key, default)
See :meth:`conversation` and :meth:`Conversation.get_remote`.
"""
return self.conversation(scope).get_remote(key, default)
def set_local(self, key=None, value=None, data=None, scope=None, **kwdata):
"""
Locally store some data, namespaced by the current or given :class:`Conversation` scope.
In Python, this is equivalent to::
relation.conversation(scope).set_local(data, scope, **kwdata)
See :meth:`conversation` and :meth:`Conversation.set_local`.
"""
self.conversation(scope).set_local(key, value, data, **kwdata)
def get_local(self, key, default=None, scope=None):
"""
Retrieve some data previously set via :meth:`set_local`.
In Python, this is equivalent to::
relation.conversation(scope).get_local(key, default)
See :meth:`conversation` and :meth:`Conversation.get_local`.
"""
return self.conversation(scope).get_local(key, default)
class Conversation(object):
"""
Converations are the persistent, evolving, two-way communication between
this service and one or more remote services.
Conversations are not limited to a single Juju hook context. They represent
the entire set of interactions between the end-points from the time the
relation is joined until it is departed.
Conversations evolve over time, moving from one semantic state to the next
as the communication progresses.
Conversations may encompass multiple remote services or units. While a
database client would connect to only a single database, that database will
likely serve several other services. On the other hand, while the database
is only concerned about providing a database to each service as a whole, a
load-balancing proxy must consider each unit of each service individually.
Conversations use the idea of :class:`scope` to determine how units and
services are grouped together.
"""
def __init__(self, namespace, units, scope):
self.namespace = namespace
self.units = set(units)
self.scope = scope
@classmethod
def _key(cls, namespace, scope):
return 'reactive.conversations.%s.%s' % (namespace, scope)
@property
def key(self):
"""
The key under which this conversation will be stored.
"""
return self._key(self.namespace, self.scope)
@property
def relation_name(self):
return self.namespace.split(':')[0]
@property
def relation_ids(self):
"""
The set of IDs of the specific relation instances that this conversation
is communicating with.
"""
if self.scope == scopes.GLOBAL:
# the namespace is the relation name and this conv speaks for all
# connected instances of that relation
return hookenv.relation_ids(self.namespace)
else:
# the namespace is the relation ID
return [self.namespace]
@classmethod
def join(cls, scope):
"""
Get or create a conversation for the given scope and active hook context.
The current remote unit for the active hook context will be added to
the conversation.
Note: This uses :mod:`charmhelpers.core.unitdata` and requires that
:meth:`~charmhelpers.core.unitdata.Storage.flush` be called.
"""
relation_name = hookenv.relation_type()
relation_id = hookenv.relation_id()
unit = hookenv.remote_unit()
service = hookenv.remote_service_name()
if scope is scopes.UNIT:
scope = unit
namespace = relation_id
elif scope is scopes.SERVICE:
scope = service
namespace = relation_id
else:
namespace = relation_name
key = cls._key(namespace, scope)
data = unitdata.kv().get(key, {'namespace': namespace, 'scope': scope, 'units': []})
conversation = cls.deserialize(data)
conversation.units.add(unit)
unitdata.kv().set(key, cls.serialize(conversation))
return conversation
def depart(self):
"""
Remove the current remote unit, for the active hook context, from
this conversation. This should be called from a `-departed` hook.
"""
unit = hookenv.remote_unit()
self.units.remove(unit)
if self.units:
unitdata.kv().set(self.key, self.serialize(self))
else:
unitdata.kv().unset(self.key)
@classmethod
def deserialize(cls, conversation):
"""
Deserialize a :meth:`serialized <serialize>` conversation.
"""
return cls(**conversation)
@classmethod
def serialize(cls, conversation):
"""
Serialize a conversation instance for storage.
"""
return {
'namespace': conversation.namespace,
'units': sorted(conversation.units),
'scope': conversation.scope,
}
@classmethod
def load(cls, keys):
"""
Load a set of conversations by their keys.
"""
conversations = []
for key in keys:
conversation = unitdata.kv().get(key)
if conversation:
conversations.append(cls.deserialize(conversation))
return conversations
def set_state(self, state):
"""
Activate and put this conversation into the given state.
The relation name will be interpolated in the state name, and it is
recommended that it be included to avoid conflicts with states from
other relations. For example::
conversation.set_state('{relation_name}.state')
If called from a converation handling the relation "foo", this will
activate the "foo.state" state, and will add this conversation to
that state.
Note: This uses :mod:`charmhelpers.core.unitdata` and requires that
:meth:`~charmhelpers.core.unitdata.Storage.flush` be called.
"""
state = state.format(relation_name=self.relation_name)
value = _get_flag_value(state, {
'relation': self.relation_name,
'conversations': [],
})
if self.key not in value['conversations']:
value['conversations'].append(self.key)
set_flag(state, value)
set_flag = set_state
def remove_state(self, state):
"""
Remove this conversation from the given state, and potentially
deactivate the state if no more conversations are in it.
The relation name will be interpolated in the state name, and it is
recommended that it be included to avoid conflicts with states from
other relations. For example::
conversation.remove_state('{relation_name}.state')
If called from a converation handling the relation "foo", this will
remove the conversation from the "foo.state" state, and, if no more
conversations are in this the state, will deactivate it.
"""
state = state.format(relation_name=self.relation_name)
value = _get_flag_value(state)
if not value:
return
if self.key in value['conversations']:
value['conversations'].remove(self.key)
if value['conversations']:
set_flag(state, value)
else:
clear_flag(state)
remove_flag = remove_state
def is_state(self, state):
"""
Test if this conversation is in the given state.
"""
state = state.format(relation_name=self.relation_name)
value = _get_flag_value(state)
if not value:
return False
return self.key in value['conversations']
is_flag_set = is_state
def toggle_state(self, state, active=TOGGLE):
"""
Toggle the given state for this conversation.
The state will be set ``active`` is ``True``, otherwise the state will be removed.
If ``active`` is not given, it will default to the inverse of the current state
(i.e., ``False`` if the state is currently set, ``True`` if it is not; essentially
toggling the state).
For example::
conv.toggle_state('{relation_name}.foo', value=='foo')
This will set the state if ``value`` is equal to ``foo``.
"""
if active is TOGGLE:
active = not self.is_state(state)
if active:
self.set_state(state)
else:
self.remove_state(state)
toggle_flag = toggle_state
def set_remote(self, key=None, value=None, data=None, **kwdata):
"""
Set data for the remote end(s) of this conversation.
Data can be passed in either as a single dict, or as key-word args.
Note that, in Juju, setting relation data is inherently service scoped.
That is, if the conversation only includes a single unit, the data will
still be set for that unit's entire service.
However, if this conversation's scope encompasses multiple services,
the data will be set for all of those services.
:param str key: The name of a field to set.
:param value: A value to set. This value must be json serializable.
:param dict data: A mapping of keys to values.
:param **kwdata: A mapping of keys to values, as keyword arguments.
"""
if data is None:
data = {}
if key is not None:
data[key] = value
data.update(kwdata)
if not data:
return
for relation_id in self.relation_ids:
hookenv.relation_set(relation_id, data)
def get_remote(self, key, default=None):
"""
Get a value from the remote end(s) of this conversation.
Note that if a conversation's scope encompasses multiple units, then
those units are expected to agree on their data, whether that is through
relying on a single leader to set the data or by all units eventually
converging to identical data. Thus, this method returns the first
value that it finds set by any of its units.
"""
cur_rid = hookenv.relation_id()
departing = hookenv.hook_name().endswith('-relation-departed')
for relation_id in self.relation_ids:
units = hookenv.related_units(relation_id)
if departing and cur_rid == relation_id:
# Work around the fact that Juju 2.0 doesn't include the
# departing unit in relation-list during the -departed hook,
# by adding it back in ourselves.
units.append(hookenv.remote_unit())
for unit in units:
if unit not in self.units:
continue
value = hookenv.relation_get(key, unit, relation_id)
if value:
return value
return default
def set_local(self, key=None, value=None, data=None, **kwdata):
"""
Locally store some data associated with this conversation.
Data can be passed in either as a single dict, or as key-word args.
For example, if you need to store the previous value of a remote field
to determine if it has changed, you can use the following::
prev = conversation.get_local('field')
curr = conversation.get_remote('field')
if prev != curr:
handle_change(prev, curr)
conversation.set_local('field', curr)
Note: This uses :mod:`charmhelpers.core.unitdata` and requires that
:meth:`~charmhelpers.core.unitdata.Storage.flush` be called.
:param str key: The name of a field to set.
:param value: A value to set. This value must be json serializable.
:param dict data: A mapping of keys to values.
:param **kwdata: A mapping of keys to values, as keyword arguments.
"""
if data is None:
data = {}
if key is not None:
data[key] = value
data.update(kwdata)
if not data:
return
unitdata.kv().update(data, prefix='%s.%s.' % (self.key, 'local-data'))
def get_local(self, key, default=None):
"""
Retrieve some data previously set via :meth:`set_local` for this conversation.
"""
key = '%s.%s.%s' % (self.key, 'local-data', key)
return unitdata.kv().get(key, default)
def _migrate_conversations(): # noqa
"""
Due to issue #28 (https://github.com/juju-solutions/charms.reactive/issues/28),
conversations needed to be updated to be namespaced per relation ID for SERVICE
and UNIT scope. To ensure backwards compatibility, this updates all convs in
the old format to the new.
TODO: Remove in 2.0.0
"""
for key, data in unitdata.kv().getrange('reactive.conversations.').items():
if 'local-data' in key:
continue
if 'namespace' in data:
continue
relation_name = data.pop('relation_name')
if data['scope'] == scopes.GLOBAL:
data['namespace'] = relation_name
unitdata.kv().set(key, data)
else:
# split the conv based on the relation ID
new_keys = []
for rel_id in hookenv.relation_ids(relation_name):
new_key = Conversation._key(rel_id, data['scope'])
new_units = set(hookenv.related_units(rel_id)) & set(data['units'])
if new_units:
unitdata.kv().set(new_key, {
'namespace': rel_id,
'scope': data['scope'],
'units': sorted(new_units),
})
new_keys.append(new_key)
unitdata.kv().unset(key)
# update the states pointing to the old conv key to point to the
# (potentially multiple) new key(s)
for flag in get_flags():
value = _get_flag_value(flag)
if not value:
continue
if key not in value['conversations']:
continue
value['conversations'].remove(key)
value['conversations'].extend(new_keys)
set_flag(flag, value)
@cmdline.subcommand()
def relation_call(method, relation_name=None, flag=None, state=None, *args):
"""Invoke a method on the class implementing a relation via the CLI"""
if relation_name:
relation = relation_from_name(relation_name)
if relation is None:
raise ValueError('Relation not found: %s' % relation_name)
elif flag or state:
relation = relation_from_flag(flag or state)
if relation is None:
raise ValueError('Relation not found: %s' % (flag or state))
else:
raise ValueError('Must specify either relation_name or flag')
result = getattr(relation, method)(*args)
if isinstance(relation, RelationBase) and method == 'conversations':
# special case for conversations to make them work from CLI
result = [c.scope for c in result]
return result
hookenv.atstart(RelationBase._startup)
RelationFactory.discover()
| apache-2.0 | -2,251,918,463,404,787,500 | 34.556144 | 98 | 0.623834 | false |
robertnishihara/ray | python/ray/signature.py | 1 | 5787 | import inspect
from inspect import Parameter
import logging
from ray.utils import is_cython
# Logger for this module. It should be configured at the entry point
# into the program using Ray. Ray provides a default configuration at
# entry/init points.
logger = logging.getLogger(__name__)
# This dummy type is also defined in ArgumentsBuilder.java. Please keep it
# synced.
DUMMY_TYPE = b"__RAY_DUMMY__"
def get_signature(func):
"""Get signature parameters.
Support Cython functions by grabbing relevant attributes from the Cython
function and attaching to a no-op function. This is somewhat brittle, since
inspect may change, but given that inspect is written to a PEP, we hope
it is relatively stable. Future versions of Python may allow overloading
the inspect 'isfunction' and 'ismethod' functions / create ABC for Python
functions. Until then, it appears that Cython won't do anything about
compatability with the inspect module.
Args:
func: The function whose signature should be checked.
Returns:
A function signature object, which includes the names of the keyword
arguments as well as their default values.
Raises:
TypeError: A type error if the signature is not supported
"""
# The first condition for Cython functions, the latter for Cython instance
# methods
if is_cython(func):
attrs = [
"__code__", "__annotations__", "__defaults__", "__kwdefaults__"
]
if all(hasattr(func, attr) for attr in attrs):
original_func = func
def func():
return
for attr in attrs:
setattr(func, attr, getattr(original_func, attr))
else:
raise TypeError(
f"{func!r} is not a Python function we can process")
return inspect.signature(func)
def extract_signature(func, ignore_first=False):
"""Extract the function signature from the function.
Args:
func: The function whose signature should be extracted.
ignore_first: True if the first argument should be ignored. This should
be used when func is a method of a class.
Returns:
List of Parameter objects representing the function signature.
"""
signature_parameters = list(get_signature(func).parameters.values())
if ignore_first:
if len(signature_parameters) == 0:
raise ValueError("Methods must take a 'self' argument, but the "
f"method '{func.__name__}' does not have one.")
signature_parameters = signature_parameters[1:]
return signature_parameters
def flatten_args(signature_parameters, args, kwargs):
"""Validates the arguments against the signature and flattens them.
The flat list representation is a serializable format for arguments.
Since the flatbuffer representation of function arguments is a list, we
combine both keyword arguments and positional arguments. We represent
this with two entries per argument value - [DUMMY_TYPE, x] for positional
arguments and [KEY, VALUE] for keyword arguments. See the below example.
See `recover_args` for logic restoring the flat list back to args/kwargs.
Args:
signature_parameters (list): The list of Parameter objects
representing the function signature, obtained from
`extract_signature`.
args: The non-keyword arguments passed into the function.
kwargs: The keyword arguments passed into the function.
Returns:
List of args and kwargs. Non-keyword arguments are prefixed
by internal enum DUMMY_TYPE.
Raises:
TypeError: Raised if arguments do not fit in the function signature.
Example:
>>> flatten_args([1, 2, 3], {"a": 4})
[None, 1, None, 2, None, 3, "a", 4]
"""
reconstructed_signature = inspect.Signature(
parameters=signature_parameters)
try:
reconstructed_signature.bind(*args, **kwargs)
except TypeError as exc: # capture a friendlier stacktrace
raise TypeError(str(exc)) from None
list_args = []
for arg in args:
list_args += [DUMMY_TYPE, arg]
for keyword, arg in kwargs.items():
list_args += [keyword, arg]
return list_args
def recover_args(flattened_args):
"""Recreates `args` and `kwargs` from the flattened arg list.
Args:
flattened_args: List of args and kwargs. This should be the output of
`flatten_args`.
Returns:
args: The non-keyword arguments passed into the function.
kwargs: The keyword arguments passed into the function.
"""
assert len(flattened_args) % 2 == 0, (
"Flattened arguments need to be even-numbered. See `flatten_args`.")
args = []
kwargs = {}
for name_index in range(0, len(flattened_args), 2):
name, arg = flattened_args[name_index], flattened_args[name_index + 1]
if name == DUMMY_TYPE:
args.append(arg)
else:
kwargs[name] = arg
return args, kwargs
def _convert_from_parameter_kind(kind):
if kind == Parameter.POSITIONAL_ONLY:
return 0
if kind == Parameter.POSITIONAL_OR_KEYWORD:
return 1
if kind == Parameter.VAR_POSITIONAL:
return 2
if kind == Parameter.KEYWORD_ONLY:
return 3
if kind == Parameter.VAR_KEYWORD:
return 4
def _convert_to_parameter_kind(value):
if value == 0:
return Parameter.POSITIONAL_ONLY
if value == 1:
return Parameter.POSITIONAL_OR_KEYWORD
if value == 2:
return Parameter.VAR_POSITIONAL
if value == 3:
return Parameter.KEYWORD_ONLY
if value == 4:
return Parameter.VAR_KEYWORD
| apache-2.0 | -1,852,312,170,600,221,700 | 32.258621 | 79 | 0.654398 | false |
FabriceSalvaire/Musica | other-examples/audio/generate-wav-tone.py | 1 | 7254 | ####################################################################################################
#
# Musica - A Music Theory Package for Python
# Copyright (C) 2017 Fabrice Salvaire
#
# 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/>.
#
####################################################################################################
#! /usr/bin/env python
####################################################################################################
# https://en.wikipedia.org/wiki/WAV
# https://fr.wikipedia.org/wiki/Waveform_Audio_File_Format
####################################################################################################
import argparse
import wave
import numpy as np
####################################################################################################
class ToneGenerator:
##############################################
def __init__(self,
frequency=440, # Hz LA3 A4
amplitude=1.,
):
self._frequency = frequency
self._amplitude = amplitude
##############################################
def generate(self, times):
pulsation = 2 * np.pi * self._frequency
pcm = self._amplitude * np.sin(pulsation * times)
return pcm
####################################################################################################
class WavFile:
##############################################
def __init__(self,
sample_rate=44100, # Hz
number_of_bits=16,
number_of_channels=2,
duration=1, # s
rise_time=100, # ms
fall_time=100,
):
self._sample_rate = sample_rate
self._number_of_bits = number_of_bits
self._number_of_channels = number_of_channels
self._duration = duration
self._rise_time = rise_time
self._fall_time = fall_time
self._sampling_period = 1 / self._sample_rate
##############################################
def make_t(self, i_start, i_stop):
# stop = start + size * self._sampling_period
# times = np.arange(start, stop, self._sampling_period)
# return times[:size]
# return np.arange(start, stop, self._sampling_period)
return np.arange(i_start, i_stop) * self._sampling_period
##############################################
def encode_frames(self, pcm, to_stereo=False):
if self._number_of_bits:
dtype = '<i2'
else:
raise NotImplementedError
mono_frames = np.array(pcm, dtype=dtype)
if to_stereo:
stereo_frames = np.zeros(2 * mono_frames.size, dtype=dtype)
stereo_frames[0:-1:2] = mono_frames
stereo_frames[1::2] = mono_frames
frames = stereo_frames
else:
frames = mono_frames
return frames.tobytes('C')
##############################################
def make_wave(self, path, tone_generator):
wave_file = wave.open(path, 'wb')
sample_width = self._number_of_bits // 8
number_of_frames = int(self._sample_rate * self._duration)
# (nchannels, sampwidth, framerate, nframes, comptype, compname)
wave_file.setparams((self._number_of_channels,
sample_width,
self._sample_rate,
number_of_frames,
'NONE',
'not compressed'))
# 16-bit = 32767
amplitude_max = 2 ** self._number_of_bits // 2 - 1
chunk_size = 10000
time_window = chunk_size * self._sampling_period
for chunk in range(number_of_frames // 1000 + 2):
i_start = chunk * chunk_size
i_stop = i_start + chunk_size
start = i_start * self._sampling_period
stop = min(i_stop * self._sampling_period, self._duration)
i_stop = int(stop / self._sampling_period)
times = self.make_t(i_start, i_stop)
# print(chunk, i_start, i_stop, stop, times)
pcm = tone_generator.generate(times)
if start < self._rise_time:
pcm *= np.minimum(times / self._rise_time, np.ones(times.size))
if stop > self._duration - self._fall_time:
pcm *= np.minimum(- (times - self._duration) / self._fall_time, np.ones(times.size))
pcm *= amplitude_max
frames = self.encode_frames(pcm, to_stereo=self._number_of_channels == 2)
wave_file.writeframes(frames) # writeframesraw
if stop == self._duration:
break
wave_file.close()
####################################################################################################
if __name__ == "__main__":
# cut at 14.7 kHz ???
argument_parser = argparse.ArgumentParser()
argument_parser.add_argument('-r', '--rate', help="Sample rate in Hz",
type=int, default=44100)
argument_parser.add_argument('-b', '--bits', help="Number of bits in each sample",
type=int, choices=(16,), default=16)
argument_parser.add_argument('-c', '--channels', help="Number of channels to produce",
type=int, default=2)
argument_parser.add_argument('-t', '--time', help="Duration of the wave in ms.",
type=float, default=1.)
argument_parser.add_argument('-rt', '--rise-time', help="Rise time in ms.",
type=float, default=100.)
argument_parser.add_argument('-ft', '--fall-time', help="Fall time is ms.",
type=float, default=100.)
argument_parser.add_argument('-a', '--amplitude', help="Amplitude of the wave on a scale of 0.0-1.0.",
type=float, default=1,)
argument_parser.add_argument('-f', '--frequency', help="Frequency of the wave in Hz",
type=float, default=440.0) # LA3 A4
argument_parser.add_argument('filename', help="The file to generate.")
args = argument_parser.parse_args()
wav_file = WavFile(
sample_rate=args.rate,
number_of_bits=args.bits,
number_of_channels=args.channels,
duration=args.time / 1000,
rise_time=args.rise_time / 1000,
fall_time=args.fall_time / 1000,
)
tone_generator = ToneGenerator(
frequency=args.frequency,
amplitude=args.amplitude,
)
wav_file.make_wave(args.filename, tone_generator)
| gpl-3.0 | 8,334,232,289,626,942,000 | 34.73399 | 106 | 0.489109 | false |
hendrikwout/pynacolada | old/pynacolada/pynacolada.py | 1 | 59125 | from operator import itemgetter,mul
import numpy as np
from netcdf import netcdf_file
import sys
from Scientific.IO import NetCDF
from ncdfextract import ncgettypecode
from ncdfproc import nccopydimension,nccopyattrvar
class SomeError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
def ncvartypeoffset(ncfile,var):
""" purpose: get binary data type and offset of a variable in netcdf file
unfortunately, getting these properties are not explicitely implemented in scipy, but most of this code is stolen from scipy: /usr/lib/python2.7/dist-packages/scipy/io/netcdf.py
ncfile is a scipy.io.netcdf.netcdf_file
var variable we want to calculate the offset from
"""
oripos=ncfile.fp.tell()
ncfile.fp.seek(0)
magic = ncfile.fp.read(3)
ncfile.__dict__['version_byte'] = np.fromstring(ncfile.fp.read(1), '>b')[0]
# Read file headers and set data.
ncfile._read_numrecs()
ncfile._read_dim_array()
ncfile._read_gatt_array()
header = ncfile.fp.read(4)
count = ncfile._unpack_int()
vars = []
for ic in range(count):
vars.append(list(ncfile._read_var()))
ivar = np.where(np.array(vars) == var)[0][0]
ncfile.fp.seek(oripos)
return vars[ivar][6] , vars[ivar][7]
def rwicecube(filestream,shp,refiter,dimiter,dimpos,refnoiter,dimnoiter,icecube,vtype,vsize,voffset,rwchsize,mode):
"""
read or write data icecube from binary data and put it in an array
filestream: binary file reference
shp: shape of the filestream
refiter: reference to dimensions over which no slice is performed
pos: current index position of the non-sliced dimensions
"""
# e.g. shp = (200,100,50,50,20)
# refiter = (1,3,4)
# dimpos = (5,10,9)
# extend so that structured arrays are read at once
lennoiter = long(1)
for irefnoiter,erefnoiter in enumerate(refnoiter):
lennoiter = lennoiter*len(dimnoiter[irefnoiter])
fpos = 0
# e.g. fpos = (9)+ 20*(10) + 50*50*20*(5)
for idimpos,edimpos in enumerate(dimpos):
curadd = np.mod(dimiter[idimpos][np.mod(edimpos,len(dimiter[idimpos]))],shp[refiter[idimpos]])
#e.g. if edimpos == (5): curadd = 50*50*20*(5)
# exclude trivial special case of only 1 iteration step
# --> in that case fpos is just zero.
if refiter > [-1]:
if ((refiter[idimpos] + 1) < len(shp)):
for i in range(refiter[idimpos] + 1,len(shp)) :
curadd = curadd * shp[i]
fpos = fpos + curadd
# Initialize (for reading) or prepare (for writing) icecube array
if mode == 'read':
icecube = np.zeros((lennoiter,),dtype=vtype)*np.nan
elif mode == 'write':
icecube = np.reshape(icecube,(lennoiter,))
dimnoiterpos = [0]*len(dimnoiter)
j = 0
while j < lennoiter:
fposicecube = fpos
for idimpos,edimpos in enumerate(dimnoiterpos):
curadd = np.mod(dimnoiter[idimpos][np.mod(edimpos,len(dimnoiter[idimpos]))],shp[refnoiter[idimpos]])
# e.g. fposicecube = (1)*52
# e.g. fposicecube = (9)+ 20*(10) + 50*50*20*(5)
if ((refnoiter[idimpos] + 1) < len(shp)):
for i in range(refnoiter[idimpos] + 1,len(shp)) :
curadd = curadd * shp[i]
fposicecube = fposicecube + curadd
filestream.seek(voffset+vsize*fposicecube)
if mode == 'read':
temp = np.fromfile(filestream,dtype='>'+vtype[1],count=rwchsize)
# temp.byteswap(True)
icecube[j:(j+rwchsize)] = temp
elif mode == 'write':
temp = np.array(icecube[j:(j+rwchsize)],dtype='>'+vtype[1])
filestream.write(temp)
# go to next data strip
if dimnoiterpos != []:
# rwchsize: allow reading of chunks for the inner dimensions
dimnoiterpos[-1] = dimnoiterpos[-1] + rwchsize
for idimidx,edimidx in reversed(list(enumerate(dimnoiterpos))):
if idimidx > 0:
while dimnoiterpos[idimidx] >= len(dimnoiter[idimidx]):
dimnoiterpos[idimidx-1] = dimnoiterpos[idimidx-1] + 1
dimnoiterpos[idimidx] -= len(dimnoiter[idimidx])
j = j+rwchsize
icecube.shape = [len(e) for e in dimnoiter]
if mode == 'read':
return icecube
def writeicecubeps(fstream,shp,refiter,dimiter,dimiterpos,refnoiter,dimnoiter,data,vtype,vsize,voffset,rwchsize):
"""
write an icecube and perform an in-memory Post Swap of dimensions before (very fast)
hereby, we acquire the order of the icecube dimensions
"""
refnoitersort,trns,dimnoitersort = zip(*sorted(zip(refnoiter,range(len(refnoiter)),dimnoiter),key=itemgetter(0,1)))
rwicecube(fstream,shp,refiter,dimiter,dimiterpos,refnoitersort,dimnoitersort,np.transpose(data,trns),vtype,vsize,voffset,rwchsize,'write')
def readicecubeps(fstream,shp,refiter,dimiter,dimiterpos,refnoiter,dimnoiter,vtype,vsize,voffset,rwchsize):
"""
read an icecube by sorting the indices (highest at the back).
perform an in-memory Post Swap of dimensions (very fast) to compensate for the sorting.
we allow reading in chunks according to the inner dimensions. They will be mostly there because we allow an max-icecubesize
"""
refnoitersort,trns,dimnoitersort = zip(*sorted(zip(refnoiter,range(len(refnoiter)),dimnoiter),key=itemgetter(0,1)))
# print 'shp',shp,refnoitersort,[len(e) for e in dimnoitersort],refiter
if str(type(fstream))[7:11] == 'list':
# this statement assumes that the first dimension of the datastream represents the 'listing' of the files
if refnoitersort[0] == 0:
# print([len(fstream)]+list([len(e) for e in dimnoitersort[1:]]))
icecube = np.zeros([len(fstream)]+list([len(e) for e in dimnoitersort[1:]]))
# icecube = np.zeros([len(fstream)]+list(dimnoitersort[1:]))
refiterred = list(refiter); refiterred = [e -1 for e in refiterred]
refnoitersortred = list(refnoitersort[1:]); refnoitersortred = [e - 1 for e in refnoitersortred]
dimnoitersortred = list(dimnoitersort[1:])
shpred = list(shp[1:])
# print 'shpred',shpred,refnoitersortred,[len(e) for e in dimnoitersortred],refiterred
for ifn,efn in enumerate(fstream):
tfile = open(fstream[ifn],'r')
icecube[ifn] =rwicecube(tfile,shpred,refiterred,dimiter,dimiterpos,refnoitersortred,dimnoitersortred,None,vtype,vsize,voffset,rwchsize,'read')
tfile.close()
elif 0 in refiter:
irefiter = refiter.index(0)
ifn = dimiterpos[irefiter]
tfile = open(fstream[ifn],'r')
refiterred = list(refiter); refiterred.pop(irefiter); refiterred = [ e-1 for e in refiterred]
dimiterred = list(dimiter); dimiterred.pop(irefiter)
dimiterposred = list(dimiterpos);dimiterposred.pop(irefiter)
shpred = list(shp[1:])
refnoitersortred = list(refnoiter); refnoitersortred = [e-1 for e in refnoitersortred]
icecube =rwicecube(tfile,shpred,refiterred,dimiterred,dimiterposred,refnoitersortred,dimnoitersort,None,vtype,vsize,voffset,rwchsize,'read')
tfile.close()
else:
icecube =rwicecube(fstream,shp,refiter,dimiter,dimiterpos,refnoitersort,dimnoitersort,None,vtype,vsize,voffset,rwchsize,'read')
# build the 'inverse permutation' operator for tranposition before writeout
inv = range(len(trns))
for itrns, etrns in enumerate(trns):
inv[etrns] = itrns
return np.transpose(icecube,inv)
# we kunnen eens proberen om een variabele aan te maken met een vooraf gespecifieerde dimensie!
def pcd(func,dnamsel,datin,datout,appenddim = False, maxmembytes = 10000000, forcearray=False):
""" purpose (see also README.md): process binary NetCDF data streams
func: the function/analysis to be applied on the data input streams
specified below. The arguments of func correspond to the respective
data input streams. The output needs to be a numpy.array(), or a list
of numpy.array() of which each item corresponds to the data output
streams specified below.
dnamsel: the dimensions on which the function needs to be applied. The
function will be repeated along the other dimensions
datin: list of data input variables/streams e.g.
[{'file':ncfile,'varname':'T',...},{'file':ncfile2,'varname':'P',...}]
possible dictionary keywords hereby:
- 'file': <pointer to Scientific.IO.NetCDF.NetCDFFile('filename','r')>, or a list of filenames that represent NetCDF files all with exactly the same (NetCDF) data structure
- 'varname': NetCDF variable
- 'daliases' (optional): aliases for dimensions to 'align' dimensions
for different data input variables
- 'predim' (optional): when 'file' is a filename list,. 'predim' will
be the name of the dimension that represents the
filelist. When not specified, the outer
dimension of the netcdf files will be expanded
only if it appears to have a length of 1. In all
other cases, the name predim<0,1/2/3>... will be
taken as extra dimensions.
- 'dsel': select a subset of the data by specifying dimension indices,
for example {'level' : range(0,5,1), 'lat' : range(50,60,1),
'lon' : range(70,80,1)} will select a subspace of the first 5
levels, and a inner horizontal domain.
datout: list of data output data variables/streams, in a similar fashion
as datin
appenddim: append dnamsel with the inner dimensions of the data input
streams when possible. This will generally lead to an increased
performance. This option needs be supported by the func.
maxmembytes: the maximum amount of bytes that is allowed for the buffers to be read/written from/to the input/output data streams.
"""
# track the dimensions to be selected when multiples are given
dnamseldef = []
for ednamsel in dnamsel:
if ((type(ednamsel).__name__ == 'tuple') | (type(ednamsel).__name__ == 'list')):
dnamseldef.append(ednamsel[0])
for idatin,edatin in reversed(list(enumerate(datin))):
ncfn = None
if type(datin[idatin]['file']).__name__ == 'list':
ncfn = datin[idatin]['file'][0]
# we assume a netcdf file
elif type(datin[idatin]['file']).__name__ == 'NetCDFFile':
# obtain file name from open netcdf!! very nasty!!!
ncfn = str(datin[idatin]['file'])[19:(str(datin[idatin]['file']).index("'",19))]
# we assume a file name
elif type(datin[idatin]['file']).__name__ == 'str':
ncfn = datin[idatin]['file']
nctemp = netcdf_file(ncfn,'r')
for edim in nctemp.variables[datin[idatin]['varname']].dimensions:
if edim in ednamsel:
dnamseldef[-1] = str(edim)
nctemp.close()
else:
dnamseldef.append(ednamsel)
# obtain definitions of the variable stream input
vsdin = [] # input variable stream definitions
for idatin,edatin in enumerate(datin):
# read in scipy.netcdf mode to obtain varariable offsets
vsdin.append(dict())
if type(datin[idatin]['file']).__name__ == 'list':
ncfn = datin[idatin]['file'][0]
nctemp = netcdf_file(ncfn,'r')
vsdin[idatin]['dnams'] = []
for idim in range(len(nctemp.variables[datin[idatin]['varname']].dimensions)):
edim = nctemp.variables[datin[idatin]['varname']].dimensions[idim]
if 'daliases' in datin[idatin]:
if edim in datin[idatin]['daliases']:
edim = datin[idatin]['daliases'][edim]
vsdin[idatin]['dnams'].append(str(edim))
#print '1dnams', idatin,vsdin[idatin]['dnams']
# this statement could be a problem when defining daliases for the file-list dimension?!!!
predim = None
if 'predim' in datin[idatin]:
predim = datin[idatin]['predim']
if ((max(nctemp.variables[datin[idatin]['varname']].shape[0],1) == 1) & ((predim == None) | (nctemp.variables[datin[idatin]['varname']].dimensions[0] == predim))):
# we expand the first dimension (which only has length 1 per file)
vsdin[idatin]['dims'] = [len(datin[idatin]['file'])]+list(nctemp.variables[datin[idatin]['varname']].shape[1:])
else:
# we add a new dimension # warning! uncatched problems can occur when predim0 already exists
if predim == None:
predim = 'predim0'
idimextra = 0
while predim in vsdin[idatin]['dnams']:
predim = 'predim'+str(idimextra)
idimextra = idimextra + 1
vsdin[idatin]['dnams'].insert(0,predim)
vsdin[idatin]['dims'] = [len(datin[idatin]['file'])]+list(nctemp.variables[datin[idatin]['varname']].shape[:])
#print '2dnams', idatin,vsdin[idatin]['dnams']
else:
# we assume a netcdf file
if type(datin[idatin]['file']).__name__ == 'NetCDFFile':
# obtain file name from open netcdf!! very nasty!!!
ncfn = str(datin[idatin]['file'])[19:(str(datin[idatin]['file']).index("'",19))]
# we assume a file name
elif type(datin[idatin]['file']).__name__ == 'str':
ncfn = datin[idatin]['file']
else:
raise SomeError("Input file "+ str(datin[idatin]) + " ("+str(idatin)+") could not be recognized.")
nctemp = netcdf_file(ncfn,'r')
vsdin[idatin]['dnams'] = []
for idim in range(len(nctemp.variables[datin[idatin]['varname']].dimensions)):
edim = nctemp.variables[datin[idatin]['varname']].dimensions[idim]
if 'daliases' in datin[idatin]:
if edim in datin[idatin]['daliases']:
edim = datin[idatin]['daliases'][edim]
vsdin[idatin]['dnams'].append(str(edim))
vsdin[idatin]['dims'] = list(nctemp.variables[datin[idatin]['varname']].shape)
vsdin[idatin]['itemsize'] = nctemp.variables[datin[idatin]['varname']].itemsize()
vsdin[idatin]['dtype'] = nctemp.variables[datin[idatin]['varname']]._dtype
vsdin[idatin]['voffset'] = nctemp.variables[datin[idatin]['varname']]._voffset
# dselmarker
vsdin[idatin]['dsel'] = [range(e) for e in vsdin[idatin]['dims']]
if 'dsel' in datin[idatin]:
# cropped dimensions
for edcrop in datin[idatin]['dsel']:
if edcrop in vsdin[idatin]['dnams']:
vsdin[idatin]['dsel'][vsdin[idatin]['dnams'].index(edcrop)] = list(datin[idatin]['dsel'][edcrop])
else:
print("Warning, dimension '"+ str(edcrop) + "' not in netcdf variable '"+ncfn+ "("+datin[idatin]['varname']+")'.")
nctemp.close()
# obtain definitions of the variable stream output
vsdout = [] # output variable stream definitions
for idatout,edatout in enumerate(datout):
vsdout.append(dict())
if edatout['varname'] in edatout['file'].variables:
vsdout[idatout]['dnams'] = []
for idim,edim in enumerate(datout[idatout]['file'].variables[datout[idatout]['varname']].dimensions):
vsdout[idatout]['dnams'].append(str(edim))
# we assume a netcdf file
if type(datout[idatout]['file']).__name__ == 'NetCDFFile':
# obtain file name from open netcdf!! very nasty!!!
ncfn = str(datout[idatout]['file'])[19:(str(datout[idatout]['file']).index("'",19))]
# we assume a file name
elif type(datout[idatout]['file']).__name__ == 'str':
ncfn = datout[idatout]['file']
else:
raise SomeError("Input file "+ str(datout[idatout]) + " ("+str(idatout)+") could not be recognized.")
datout[idatout]['file'].sync()
nctemp = netcdf_file(ncfn,'r')
vsdout[idatout]['dims'] = [max(e,1) for e in nctemp.variables[datout[idatout]['varname']].shape]
# dselmarker
vsdout[idatout]['dsel'] = [range(e) for e in vsdout[idatout]['dims']]
vsdout[idatout]['itemsize'] = nctemp.variables[datout[idatout]['varname']].itemsize()
vsdout[idatout]['dtype']= nctemp.variables[datout[idatout]['varname']]._dtype
vsdout[idatout]['voffset'] = nctemp.variables[datout[idatout]['varname']]._voffset
nctemp.close()
#datout[idatout]['file'] = NetCDF.NetCDFFile(ncfn,'a')
else:
# the variable doesn't exists (we will create it afterwards)
vsdout[idatout]['dnams'] = None
vsdout[idatout]['dims'] = None
# dselmarker
vsdout[idatout]['dsel'] = None
vsdout[idatout]['itemsize'] = None
vsdout[idatout]['dtype'] = None
# collecting the involved dimensions (will be considered as the standard output dimensions)
dnamsstd = [] # standard output dimensions: list of all output dimensions: this is collected from the input dimensions, the output dimensions and the selected/processed dimensions
dimsstd = [] # maximum length of an output dimension
idimsstd = 0
for ivsdin,evsdin in enumerate(vsdin):
dnaminlast = None
idx = 0
for idnam,ednam in reversed(list(enumerate(evsdin['dnams']))):
if ednam not in dnamsstd:
# In dnamsstd, ednam should be just after the dimensions preceding ednams in dnams
# # actually, we also want that, in dnamsstd, ednam should be just before the dimensions succeeding ednams in dnams. Sometimes, this is not possible at the same time. But it will be the case if that is possible when applying one of the criteria
idx = 0
# implement this also below, I mean that
for idnam2,ednam2 in enumerate(dnamsstd):
if ednam2 in evsdin['dnams'][0:(idnam+1)]:
idx = max(idx ,dnamsstd.index(ednam2) + 1)
dnamsstd.insert(idx ,ednam)
if ednam not in dnamseldef:
# dselmarker
if vsdin[ivsdin]['dsel'][idnam] != False: # type(edim).__name__ == 'list':
dimsstd.insert(idx ,int(len(vsdin[ivsdin]['dsel'][idnam])))
else:
dimsstd.insert(idx ,int(vsdin[ivsdin]['dims'][idnam]))
else:
# In this case, wait for assigning the output dimensions. This actually depends on the specified function
dimsstd.insert(idx ,None)
else:
if ((len(vsdin[ivsdin]['dsel'][idnam]) != 1) & (dimsstd[dnamsstd.index(ednam)] != 1) & \
# we allow non-equal dimension lengths, as long as the dimension is covered/captured by the function
# maybe still allow non-equal dimension length not covered by the function????
(dimsstd[dnamsstd.index(ednam)] != None) & \
(len(vsdin[ivsdin]['dsel'][idnam]) != dimsstd[dnamsstd.index(ednam)])):
print(vsdin[ivsdin]['dims'][idnam])
print(vsdin[ivsdin]['dims'][idnam])
raise SomeError("The corresponding output dnamensions (index: "+str(dnamsstd.index(ednam))+") of the input variable "+str(ivsdin)+ " "+ str(idnam)+ " "+" have a different length and not equal to 1.")
else:
# None means it's considered by the function
if (dimsstd[dnamsstd.index(ednam)] != None):
# dselmarker
if vsdin[ivsdin]['dsel'][idnam] != False:
dimsstd[dnamsstd.index(ednam)] = max(dimsstd[dnamsstd.index(ednam)],len(vsdin[ivsdin]['dsel'][idnam]))
else:
dimsstd[dnamsstd.index(ednam)] = max(dimsstd[dnamsstd.index(ednam)],vsdin[ivsdin]['dims'][idnam])
# add the missing dimensions selected for the function.
idnam = 0
# TODO: the position of this dimension needs to be accordence to the
# dimension-order suggested by the input(output?) netcdf files!
for idnamseldef,ednamseldef in enumerate(dnamseldef):
if ednamseldef not in dnamsstd:
dnamsstd.insert(idnam,ednamseldef)
dimsstd.insert(idnam,None) # to be defined from the function
idnam = idnam +1
else:
idnam = dnamsstd.index(ednam)+1
#print ("dimsstd", dimsstd)
# dimsstd: list the specific output dimensions
# if function dimension: data output dimension should be the same as the function output dimension, but this should be checked afterwards.
# if not function dimension:
# # look what's the output dimension like. If the dimension is not in the output variable, we add a dummy 1-dimension
# we need to create/list adimsstd also before!! And then append them with the missing dimensions, as dummy 1-dimensions. If that is not sufficient, we will just get an error message.
# get references to the standard output dimensions on which the function is applied
refdfuncstd = []
for idnamseldef,ednamseldef in enumerate(dnamseldef):
refdfuncstd.append(dnamsstd.index(ednamseldef))
# all standard output dimensions (cfr. dimsstd, dnamsstd) are now collected...
# add the standard output dimensions that are missing in each seperate input variable as a dummy 1-dimension
for ivsdin,evsdin in enumerate(vsdin):
idnam = 0
# the dimension of the list should always the first dimension! This is assumed in the rwicecube (see statement 'if refnoitersort[0] == 0:')
if type(datin[idatin]['file']).__name__ == 'list':
idnam = 1
for idnamsstd,ednamsstd in enumerate(dnamsstd):
if ednamsstd not in vsdin[ivsdin]['dnams']:
vsdin[ivsdin]['dnams'].insert(idnam,ednamsstd)
vsdin[ivsdin]['dims'].insert(idnam,1)
vsdin[ivsdin]['dsel'].insert(idnam,False)
# dselmarker
idnam = idnam + 1
else:
idnam = vsdin[ivsdin]['dnams'].index(ednamsstd) + 1
# do the same for the data output variables
# # vsdin[ivsdin]['refdstd']: references of data stream dimensions (vsdin[..]['dnams'] to the standard dimensions (dnamsstd)
for ivsdin,evsdin in enumerate(vsdin):
vsdin[ivsdin]['refdstd']= list([])
for idim,edim in enumerate(vsdin[ivsdin]['dnams']):
vsdin[ivsdin]['refdstd'].append(dnamsstd.index(edim))
for ivsdout,evsdout in enumerate(vsdout):
if vsdout[ivsdout]['dnams'] == None:
vsdout[ivsdout]['dnams'] = dnamsstd
# adimfuncin: the input dimensions of the function based on the refdfuncstd
# adimfuncin: the dimensions of the function input
# adimfuncin = np.zeros((len(vsdin),len(refdfuncstd)),dtype='int32') - 1
for ivsdout in range(len(vsdout)):
if vsdout[ivsdout]['dnams'] == None:
vsdout[ivsdout]['dnams'] == dnamsstd
# vsdout[..]['refdstd']: references of data stream dimensions (vsdout[..]['dnams'] to the standard dimensions (dnamsstd)
for ivsdout,evsdout in enumerate(vsdout):
vsdout[ivsdout]['refdstd'] = list([])
for idim,edim in enumerate(vsdout[ivsdout]['dnams']):
vsdout[ivsdout]['refdstd'].append(dnamsstd.index(edim))
# arefdfuncout: references of the function dimensions to the data output stream dimensions
arefdfuncout = []
for ivsdout,evsdout in enumerate(vsdout):
arefdfuncout.append([])
for idnamseldef,ednamseldef in enumerate(dnamseldef):
arefdfuncout[ivsdout].append(vsdout[ivsdout]['dnams'].index(ednamseldef))
# is arefdfuncout[ivsdout][irefdfuncout] == vsdout[ivsdout]['refdstd'].index(erefdfuncstd) ???
# arefdfuncin: references of the function dimensions to the data input stream dimensions
arefdfuncin = []
for ivsdin,evsdin in enumerate(vsdin):
arefdfuncin.append([])
for idnamseldef,ednamseldef in enumerate(dnamseldef):
arefdfuncin[ivsdin].append(vsdin[ivsdin]['dnams'].index(ednamseldef))
adimfuncin = []
alendfuncin = []
for ivsdin,evsdin in enumerate(vsdin):
alendfuncin.append(1)
adimfuncin.append([])
for irefdfuncstd,erefdfuncstd in enumerate(refdfuncstd):
# dselmarker
# edim = evsdin['dims'][vsdin[ivsdin]['refdstd'].index(erefdfuncstd)]
if evsdin['dsel'][vsdin[ivsdin]['refdstd'].index(erefdfuncstd)] != False:
adimfuncin[ivsdin].append(list(evsdin['dsel'][vsdin[ivsdin]['refdstd'].index(erefdfuncstd)]))
else:
adimfuncin[ivsdin].append(range(evsdin['dims'][vsdin[ivsdin]['refdstd'].index(erefdfuncstd)]))
alendfuncin[ivsdin] = alendfuncin[ivsdin]*len(adimfuncin[ivsdin][irefdfuncstd])
# 'probe' function output dimensions
dummydat = []
shapein = []
for ivsdin,evsdin in enumerate(vsdin):
shapein.append([len(e) for e in adimfuncin[ivsdin]])
# if shapein[ivsdin] == tuple():
# if forcenum and (not forcearray):
# # to do: make it
# if appenddim == True:
# dummydat.append(0.)
# else:
# raise SomeError('we can not force to be numeric if the option appenddim is switched on')
# else:
# np.zeros(shapein[ivsdin])
# we are in the special case of an extra dimension to be added to the input
if (list() in shapein) and (forcearray):
for ivsdin,evsdin in enumerate(vsdin):
dummydat.append(np.zeros([1]+shapein[ivsdin]))
else:
for ivsdin,evsdin in enumerate(vsdin):
dummydat.append(np.zeros(shapein[ivsdin]))
ddout = func(*dummydat)
if (type(ddout).__name__ == 'tuple'):
ddout = list(ddout)
if (type(ddout).__name__ != 'list'):
ddout = list([ddout])
# obtain output data type. If not specified, we obtain it from the function output.
# meanwhile, check whether the number of input dimensions are the same as the number of output dimensions.
if len(ddout) != len(vsdout):
raise SomeError('the amount of output variables in from '+ str(func) + ' ('+str(len(ddout))+') is not the same as specified ('+str(len(vsdout))+')')
for iddout in range(len(ddout)):
if type(ddout[iddout] ) != np.ndarray:
ddout[iddout] = np.array(ddout[iddout])
# we are in the special case of an extra dimension to be added to the input -> so we remove it again
if (list() in shapein) and (forcearray):
if len(ddout[iddout].shape) > 1:
ddout[iddout].shape = ddout[iddout].shape[1:]
else:
ddout[iddout].shape = []
if (len(np.array(ddout[iddout]).shape) != len(adimfuncin[ivsdin])):
raise SomeError('The amount of input ('+str(len(adimfuncin[ivsdin]))+') and output dimensions ('+str(len(ddout[iddout].shape))+') of function is not the same')
if vsdout[iddout]['dims'] == None:
vsdout[iddout]['dims'] = list(dimsstd)
# overwrite dimensions with the function output dimensions
for irefdfuncout,erefdfuncout in enumerate(arefdfuncout[iddout]):
vsdout[iddout]['dims'][erefdfuncout] = ddout[iddout].shape[irefdfuncout]
vsdout[iddout]['dsel'] = [range(e) for e in vsdout[iddout]['dims']] # Added for consistency with input dimensions. As output dimension, it is not really used.
if vsdout[iddout]['dtype'] == None:
# output netcdf variable does not exist... creating
# why does this needs to be little endian????
vsdout[iddout]['dtype'] = '>'+ncgettypecode(ddout[iddout].dtype)
# try to copy dimension from data input
for idnams,ednams in enumerate(vsdout[iddout]['dnams']):
if ednams not in datout[iddout]['file'].dimensions:
dimensionfound = False
idatin = 0
while ((not dimensionfound) & (idatin < (len(datin) ))):
templopen = False
# try to copy the dimension from the input data
if type(datin[idatin]['file']).__name__ == 'NetCDFFile':
nctemplate = datin[idatin]['file']
elif type(datin[idatin]['file']).__name__ == 'str':
nctemplate = NetCDF.NetCDFFile(datin[idatin]['file'],'r')
templopen = True
elif type(datin[idatin]['file']).__name__ == 'list':
nctemplate = NetCDF.NetCDFFile(datin[idatin]['file'][0],'r')
templopen = True
else:
raise SomeError("Input file "+ str(datin[idatin]) + " ("+str(idatin)+") could not be recognized.")
if ednams in nctemplate.dimensions:
# dselmarker
if vsdin[idatin]['dsel'][idnams] != False: # type(edim).__name__ == 'list':
if (vsdout[iddout]['dims'][idnams] == len(vsdin[idatin]['dsel'][idnams])):
datout[iddout]['file'].createDimension(ednams,vsdout[iddout]['dims'][idnams])
if ednams in nctemplate.variables:
datout[iddout]['file'].createVariable(ednams,nctemplate.variables[ednams].typecode(),(ednams,))
datout[iddout]['file'].variables[ednams][:] = np.array(nctemplate.variables[ednams][:])[vsdin[idatin]['dsel'][idnams]]
nccopyattrvar(nctemplate,datout[iddout]['file'],varin=ednams,)
dimensionfound = True
else:
if (vsdout[iddout]['dims'][idnams] == nctemplate.dimensions[ednams]):
nccopydimension(nctemplate,datout[iddout]['file'], ednams)
dimensionfound = True
if templopen:
nctemplate.close()
idatin = idatin + 1
if dimensionfound == False:
datout[iddout]['file'].createDimension(ednams,vsdout[iddout]['dims'][idnams])
# if a template file needed to be opened, close it again
# check here whether the output dimensions are ok , otherwise make alternative dimensions
dnams = []
for idim,edim in enumerate(vsdout[iddout]['dims']):
if (vsdout[iddout]['dims'][idim] == datout[iddout]['file'].dimensions[vsdout[iddout]['dnams'][idim]]):
dnams.append(vsdout[iddout]['dnams'][idim])
else:
# if (vsdout[iddout]['dims'][idim] == 1):
# # if dimension is one, just remove it
# vsdout[iddout]['dims'].pop(idim)
# else:
dnams.append(vsdout[iddout]['dnams'][idim])
# else, make a new alternative dimension with a similar name
dnamidx = -1
while (dnams[idim] in datout[iddout]['file'].dimensions):
dnamidx = dnamidx + 1
dnams[idim] = str(vsdout[iddout]['dnams'][idim])+'_'+str(dnamidx)
datout[iddout]['file'].createDimension(dnams[idim],vsdout[iddout]['dims'][idim])
vsdout[iddout]['dnams'] = dnams
datout[iddout]['file'].createVariable(datout[iddout]['varname'],vsdout[iddout]['dtype'][1],tuple(vsdout[iddout]['dnams']))
# we should check this at the time the dimensions are not created
if (vsdout[iddout]['dims'] != list(datout[iddout]['file'].variables[datout[iddout]['varname']].shape)):
raise SomeError("dimensions of output file ( "+str(vsdout[iddout]['dims'])+"; "+ str(vsdout[iddout]['dnams'])+") do not correspond with intended output dimension "+str(datout[iddout]['file'].variables[datout[iddout]['varname']].shape)+"; "+str(datout[iddout]['file'].variables[datout[iddout]['varname']].dimensions))
for idatin,edatin in enumerate(datin):
if type(datin[idatin]['file']).__name__ == 'NetCDFFile':
# obtain file pointer!! very nasty!!
ncfn = str(datin[idatin]['file'])[19:(str(datin[idatin]['file']).index("'",19))]
vsdin[idatin]['fp'] = open(ncfn,'r')
elif type(datin[idatin]['file']).__name__ == 'str':
ncfn = datin[idatin]['file']
vsdin[idatin]['fp'] = open(ncfn,'r')
elif type(datin[idatin]['file']).__name__ == 'list':
# !!!!!if series/list of file names, then the file poniters will open when at read-time
ncfn = datin[idatin]['file']
vsdin[idatin]['fp'] = datin[idatin]['file']
else:
raise SomeError("Input file "+ str(datin[idatin]) + " ("+str(idatin)+") could not be recognized.")
for idatout,edatout in enumerate(datout):
# obtain file pointer!! very nasty!!
datout[idatout]['file'].flush()
ncfn = str(datout[idatout]['file'])[19:(str(datout[idatout]['file']).index("'",19))]
vsdout[idatout]['fp'] = open(ncfn,'r+')
# in order to discover variable offsets
nctemp = netcdf_file(ncfn,'r')
vsdout[idatout]['itemsize'] = nctemp.variables[datout[idatout]['varname']].itemsize()
vsdout[idatout]['voffset'] = nctemp.variables[datout[idatout]['varname']]._voffset
nctemp.close()
# # bugfix 2013-11-26: this paragraph is replaced by the one below (analogous to the 'construction' of adimfuncin
# # next: check whether the output variable dimensions (if already present) are not too large, otherwise raise error. + Construct final output dimension specs
# adimfuncout = [[None]*len(refdfuncstd)]*(len(vsdout))
# alendfuncout = []
# for ivsdout,evsdout in enumerate(vsdout):
# alendfuncout.append(1)
# for irefdfuncstd,erefdfuncstd in enumerate(refdfuncstd):
# # dselmarker
# # edim = evsdout['dims'][vsdout[ivsdout]['refdstd'].outdex(erefdfuncstd)]
# if evsdout['dsel'][vsdout[ivsdout]['refdstd'].index(erefdfuncstd)] != False:
# adimfuncout[ivsdout][irefdfuncstd] = evsdout['dsel'][vsdout[ivsdout]['refdstd'].index(erefdfuncstd)]
# else:
# adimfuncout[ivsdout][irefdfuncstd] = range(evsdout['dims'][vsdout[ivsdout]['refdstd'].index(erefdfuncstd)])
# alendfuncout[ivsdout] = alendfuncout[ivsdout]*len(adimfuncout[ivsdout][irefdfuncstd])
adimfuncout = []
alendfuncout = []
for ivsdout,evsdout in enumerate(vsdout):
alendfuncout.append(1)
adimfuncout.append([])
for irefdfuncstd,erefdfuncstd in enumerate(refdfuncstd):
# dselmarker
# edim = evsdout['dims'][vsdout[ivsdout]['refdstd'].index(erefdfuncstd)]
if evsdout['dsel'][vsdout[ivsdout]['refdstd'].index(erefdfuncstd)] != False:
adimfuncout[ivsdout].append(list(evsdout['dsel'][vsdout[ivsdout]['refdstd'].index(erefdfuncstd)]))
else:
adimfuncout[ivsdout].append(range(evsdout['dims'][vsdout[ivsdout]['refdstd'].index(erefdfuncstd)]))
alendfuncout[ivsdout] = alendfuncout[ivsdout]*len(adimfuncout[ivsdout][irefdfuncstd])
# arefsin: references of the standard dimensions to the data stream dimensions
arefsin = []
for ivsdin,evsdin in enumerate(vsdin):
arefsin.append([None]*len(vsdin[ivsdin]['refdstd']))
# loop over the data stream dimensions
for irefdstd,erefdstd in enumerate(vsdin[ivsdin]['refdstd']):
arefsin[ivsdin][erefdstd] = irefdstd
# arefsout: references of the standard dimensions to the data stream dimensions
arefsout = []
for ivsdout,evsdout in enumerate(vsdout):
arefsout.append([None]*len(vsdout[ivsdout]['refdstd']))
# loop over the data stream dimensions
for irefdstd,erefdstd in enumerate(vsdout[ivsdout]['refdstd']):
arefsout[ivsdout][erefdstd] = irefdstd
#print ("dnamsstd", dnamsstd)
if appenddim == True:
membytes = 0
# dsellen = len(dnamseldef)
# a temporary copy of alenfunc*
alendfuncin_tmp = list(alendfuncin)
alendfuncout_tmp = list(alendfuncout)
# we try will to read the data in even larger icecubes to reduce disk access!
idnam = len(dnamsstd) - 1
cont = True
maxarefdfunc = len(refdfuncstd)
while ((idnam >= maxarefdfunc) & (membytes <= maxmembytes) & cont):
# while loop quite extensive but does what is should-> should be reduced and simplified
cont = False # only continue to the next loop if idnam+1 (in previous loop) was (inserted) in refdfuncstd
ednam = dnamsstd[idnam]
if idnam not in refdfuncstd:
for ivsdin,evsdin in enumerate(vsdin):
# dselmarker
if vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]] != False:
alendfuncin_tmp[ivsdin] = alendfuncin_tmp[ivsdin] *len(vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]])
else:
alendfuncin_tmp[ivsdin] = alendfuncin_tmp[ivsdin] *vsdin[ivsdin]['dims'][arefsin[ivsdin][idnam]]
for ivsdout,evsdout in enumerate(vsdout):
alendfuncout_tmp[ivsdout] = alendfuncout_tmp[ivsdout] *vsdout[ivsdout]['dims'][arefsout[ivsdout][idnam]]
# recalculate the amount of bytes
tmpmembytes = 0
for ivsdin,evsdin in enumerate(vsdin):
tmpmembytes = tmpmembytes + alendfuncin_tmp[ivsdin] * vsdin[ivsdin]['itemsize']
for ivsdout,evsdout in enumerate(vsdout):
tmpmembytes = tmpmembytes + alendfuncout_tmp[ivsdout] * vsdout[ivsdout]['itemsize']
# if used memory still below threshold, we add it to the current dimension to the icecubes
if tmpmembytes <= maxmembytes:
refdfuncstd.insert(maxarefdfunc,idnam)
for ivsdin,evsdin in enumerate(vsdin):
# arefdfuncin: references of the function dimensions to the data input stream dimensions
arefdfuncin[ivsdin].insert(maxarefdfunc, arefsin[ivsdin][idnam])
if vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]] != False:
adimfuncin[ivsdin].insert(maxarefdfunc,vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]])
alendfuncin[ivsdin] = alendfuncin[ivsdin] *len(vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]])
else:
adimfuncin[ivsdin].insert(maxarefdfunc,range(vsdin[ivsdin]['dims'][arefsin[ivsdin][idnam]]))
alendfuncin[ivsdin] = alendfuncin[ivsdin] *vsdin[ivsdin]['dims'][arefsin[ivsdin][idnam]]
for ivsdout,evsdout in enumerate(vsdout):
arefdfuncout[ivsdout].insert(maxarefdfunc, arefsout[ivsdout][idnam])
adimfuncout[ivsdout].insert(maxarefdfunc,range(vsdout[ivsdout]['dims'][arefsout[ivsdout][idnam]]))
alendfuncout[ivsdout] = alendfuncout[ivsdout] *vsdout[ivsdout]['dims'][arefsout[ivsdout][idnam]]
# recalculate the amount of bytes
membytes = 0
for ivsdin,evsdin in enumerate(vsdin):
membytes = membytes + alendfuncin[ivsdin] * vsdin[ivsdin]['itemsize']
for ivsdout,evsdout in enumerate(vsdout):
membytes = membytes + alendfuncout[ivsdout] * vsdout[ivsdout]['itemsize']
cont = True
# if used memory still below threshold, we add it to the current dimension to the icecubes
else:
cont = True
idnam = idnam - 1
refdnoiterstd = list(refdfuncstd)
alendnoiterin = list(alendfuncin)
adimnoiterin = []
arefdnoiterin = []
for ivsdin,evsdin in enumerate(vsdin):
adimnoiterin.append(list(adimfuncin[ivsdin]))
arefdnoiterin.append(list(arefdfuncin[ivsdin]))
alendnoiterout = list(alendfuncout)
adimnoiterout = []
arefdnoiterout = []
for ivsdout,evsdout in enumerate(vsdout):
adimnoiterout.append(list(adimfuncout[ivsdout]))
arefdnoiterout.append(list(arefdfuncout[ivsdout]))
# membytes: minimum total memory that will be used. We will the increase usage when possible/allowed.
membytes = 0
for ivsdin,evsdin in enumerate(vsdin):
membytes = membytes + alendfuncin[ivsdin] * vsdin[ivsdin]['itemsize']
for ivsdout,evsdout in enumerate(vsdout):
membytes = membytes + alendfuncout[ivsdout] * vsdout[ivsdout]['itemsize']
if membytes > maxmembytes:
print ('Warning, used memory ('+str(membytes)+') exceeds maximum memory ('+str(maxmembytes)+').')
else:
# a temporary copy of alennoiter*
alendnoiterin_tmp = list(alendnoiterin)
alendnoiterout_tmp = list(alendnoiterout)
# we try will to read the data in even larger icecubes to reduce disk access!
idnam = len(dnamsstd) - 1
cont = True
while ((idnam >= 0) & (membytes <= maxmembytes) & cont):
# while loop quite extensive but does what is should-> should be reduced and simplified
cont = False # only continue to the next loop if idnam+1 (in previous loop) was (inserted) in refdnoiterstd
if idnam not in refdnoiterstd:
for ivsdin,evsdin in enumerate(vsdin):
# dselmarker
if vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]] != False:
alendnoiterin_tmp[ivsdin] = alendnoiterin_tmp[ivsdin] *len(vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]])
else:
alendnoiterin_tmp[ivsdin] = alendnoiterin_tmp[ivsdin] *vsdin[ivsdin]['dims'][arefsin[ivsdin][idnam]]
for ivsdout,evsdout in enumerate(vsdout):
alendnoiterout_tmp[ivsdout] = alendnoiterout_tmp[ivsdout] *vsdout[ivsdout]['dims'][arefsout[ivsdout][idnam]]
# recalculate the amount of bytes
tmpmembytes = 0
for ivsdin,evsdin in enumerate(vsdin):
tmpmembytes = tmpmembytes + alendnoiterin_tmp[ivsdin] * vsdin[ivsdin]['itemsize']
for ivsdout,evsdout in enumerate(vsdout):
tmpmembytes = tmpmembytes + alendnoiterout_tmp[ivsdout] * vsdout[ivsdout]['itemsize']
# if used memory still below threshold, we add it to the current dimension to the icecubes
if tmpmembytes <= maxmembytes:
refdnoiterstd.insert(0,idnam)
for ivsdin,evsdin in enumerate(vsdin):
arefdnoiterin[ivsdin].insert(0, arefsin[ivsdin][idnam])
if vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]] != False:
adimnoiterin[ivsdin].insert(0,vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]])
alendnoiterin[ivsdin] = alendnoiterin[ivsdin] *len(vsdin[ivsdin]['dsel'][arefsin[ivsdin][idnam]])
else:
adimnoiterin[ivsdin].insert(0,range(vsdin[ivsdin]['dims'][arefsin[ivsdin][idnam]]))
alendnoiterin[ivsdin] = alendnoiterin[ivsdin] *vsdin[ivsdin]['dims'][arefsin[ivsdin][idnam]]
for ivsdout,evsdout in enumerate(vsdout):
arefdnoiterout[ivsdout].insert(0, arefsout[ivsdout][idnam])
adimnoiterout[ivsdout].insert(0,range(vsdout[ivsdout]['dims'][arefsout[ivsdout][idnam]]))
alendnoiterout[ivsdout] = alendnoiterout[ivsdout] *vsdout[ivsdout]['dims'][arefsout[ivsdout][idnam]]
#dnamseldefnoiter.insert(0,dnamsstd[idnam])
# recalculate the amount of bytes
membytes = 0
for ivsdin,evsdin in enumerate(vsdin):
membytes = membytes + alendnoiterin[ivsdin] * vsdin[ivsdin]['itemsize']
for ivsdout,evsdout in enumerate(vsdout):
membytes = membytes + alendnoiterout[ivsdout] * vsdout[ivsdout]['itemsize']
cont = True
# if used memory still below threshold, we add it to the current dimension to the icecubes
else:
cont = True
idnam = idnam - 1
# adimnoiterin[ivsdin,irefdnoiterstd] = evsdin['dims'][vsdin[ivsdin]['refdstd'].index(erefdnoiterstd)]
# arefdfuncin: references of the function dimensions to the data input stream dimensions
# arefdnoiterin: references of the icecube dimensions to the data input stream dimensions
# # vsdin[ivsdin]['refdstd']: references of data stream dimensions (vsdin[..]['dnams'] to the standard dimensions (dnamsstd)
# dnamseldefnoiter: references
# print ('dims in:',vsdin[ivsdin]['dims'])
# print ('dnams in:',vsdin[ivsdin]['dnams'])
# print ('dims out:',vsdout[ivsdin]['dims'])
# print ('dnams out:',vsdout[ivsdin]['dnams'])
# guess from residual dimensions that are not in refnoiterin
refditerstd = []
dimiterstd = []
for idim,edim in enumerate(dimsstd):
if idim not in refdnoiterstd:
refditerstd.append(idim)
dimiterstd.append(edim)
if refditerstd == []:
refditerstd = [-1]
dimiterstd = [1]
# guess from residual dimensions that are not in refnoiterin
arefditerin = []
adimiterin = []
for ivsdin,evsdin in enumerate(vsdin):
arefditerin.append([])
adimiterin.append([])
for idim,edim in enumerate(vsdin[ivsdin]['dims']):
if idim not in arefdnoiterin[ivsdin]:
arefditerin[ivsdin].append(idim)
if vsdin[ivsdin]['dsel'][idim] != False:
adimiterin[ivsdin].append(vsdin[ivsdin]['dsel'][idim])
else:
adimiterin[ivsdin].append(range(edim))
if arefditerin[ivsdin] == []:
arefditerin[ivsdin] = [-1]
adimiterin[ivsdin] = [range(1)]
# guess from residual dimensions that are not in refnoiterin
arefditerout = []
adimiterout = []
for ivsdout,evsdout in enumerate(vsdout):
arefditerout.append([])
adimiterout.append([])
for idim,edim in enumerate(vsdout[ivsdout]['dims']):
if idim not in arefdnoiterout[ivsdout]:
arefditerout[ivsdout].append(idim)
if vsdout[ivsdout]['dsel'][idim] != False:
adimiterout[ivsdout].append(vsdout[ivsdout]['dsel'][idim])
else:
adimiterout[ivsdout].append(range(edim))
if arefditerout[ivsdout] == []:
arefditerout[ivsdout] = [-1]
adimiterout[ivsdout] = [range(1)]
dimitermax = []
for iref,eref in enumerate(refditerstd):
dimitermax.append(1)
for ivsdin,evsdin in enumerate(vsdin):
dimitermax[iref] = max(dimitermax[iref],len(adimiterin[ivsdin][iref]))
for ivsdout,evsdout in enumerate(vsdout):
dimitermax[iref] = max(dimitermax[iref],len(adimiterout[ivsdout][iref]))
rwchunksizein = [1]*len(vsdin)
for ivsdin,evsdin in enumerate(vsdin):
idim = len(vsdin[ivsdin]['dims'])-1
while ((idim in arefdnoiterin[ivsdin]) & (idim >= 0) & (vsdin[ivsdin]['dsel'][idim] == range(vsdin[ivsdin]['dims'][idim])) & ((type(datin[ivsdin]['file']).__name__ != 'list') | (idim != 0))):
# The inner dimensions just have to be referenced so not in correct order. We know that they will be read in the correct order in the end
rwchunksizein[ivsdin] = rwchunksizein[ivsdin]*vsdin[ivsdin]['dims'][idim]
idim = idim - 1
#print ("rwchunksizein", rwchunksizein)
rwchunksizeout = [1]*len(vsdout)
for ivsdout,evsdout in enumerate(vsdout):
idim = len(vsdout[ivsdout]['dims']) -1
while ((idim in arefdnoiterout[ivsdout]) & (idim >= 0)):
# The inner dimensions just have to be referenced so not in correct order. We know that they will be read in the correct order in the end
rwchunksizeout[ivsdout] = rwchunksizeout[ivsdout]*vsdout[ivsdout]['dims'][idim]
idim = idim - 1
#print ("rwchunksizein",rwchunksizeout)
adimnoapplyout = []
for ivsdout,evsdout in enumerate(vsdout):
adimnoapplyout.append([])
for irefdnoiterout in range(len(arefdnoiterout[ivsdout])-len(arefdfuncout[ivsdout])):
adimnoapplyout[ivsdout].append(adimnoiterout[ivsdout][irefdnoiterout])
if adimnoapplyout[ivsdout] == []:
adimnoapplyout[ivsdout] = [range(1)]
adimnoapplyin = []
for ivsdin,evsdin in enumerate(vsdin):
adimnoapplyin.append([])
for irefdnoiterin in range(len(arefdnoiterin[ivsdin])-len(arefdfuncin[ivsdin])):
adimnoapplyin[ivsdin].append(adimnoiterin[ivsdin][irefdnoiterin])
if adimnoapplyin[ivsdin] == []:
adimnoapplyin[ivsdin] = [range(1)]
dimnoapplymax = []
for iref in range(len(arefdnoiterout[ivsdout])-len(arefdfuncout[ivsdout])):
dimnoapplymax.append(1)
for ivsdin,evsdin in enumerate(vsdin):
dimnoapplymax[iref] = max(dimnoapplymax[iref],len(adimnoapplyin[ivsdin][iref]))
for ivsdout,evsdout in enumerate(vsdout):
dimnoapplymax[iref] = max(dimnoapplymax[iref],len(adimnoapplyout[ivsdout][iref]))
if dimnoapplymax == []:
dimnoapplymax = [1]
lennoapplymax = reduce(mul,dimnoapplymax)
lenitermax = reduce(mul,dimitermax)
dimiterpos = [0]*len(dimitermax)
sys.stdout.write(str(0)+'/'+str(lenitermax))
for j in range(lenitermax):
# reading icecube, rearranged in the order of dimensions specified by arefnoiterin
dataicecubein = []
for ivsdin,evsdin in enumerate(vsdin):
# dataicecubein.append(np.zeros((elendnoiterin,),dtype=vsdin[ilendnoiterin]['dtype']))
# if ((refiter == 0) & (type(vsdin[ivsdin]['fp']) == 'list'):
# dataicecubein.append(np.zeros(
dataicecubein.append(np.array(readicecubeps(\
vsdin[ivsdin]['fp'],\
vsdin[ivsdin]['dims'],\
arefditerin[ivsdin],\
adimiterin[ivsdin],\
dimiterpos,\
arefdnoiterin[ivsdin],\
adimnoiterin[ivsdin],\
vsdin[ivsdin]['dtype'],\
vsdin[ivsdin]['itemsize'],\
vsdin[ivsdin]['voffset'],\
rwchunksizein[ivsdin],\
), dtype=vsdin[ivsdin]['dtype']).ravel())
dataicecubeout = []
for ilendnoiterout,elendnoiterout in enumerate(alendnoiterout):
dataicecubeout.append(np.zeros((elendnoiterout,),dtype=vsdout[ilendnoiterout]['dtype'][1]))
dimnoapplypos = [0]*len(dimnoapplymax)
k = 0
sys.stdout.write(' '+'('+str(0)+'/'+str(lennoapplymax)+')')
for k in range(lennoapplymax):
# actually, this is just the end of the file output already written
ahunkin = []
shapein = []
for ivsdin, evsdin in enumerate(vsdin):
pos = 0
# e.g. pos = (9)+ 20*(10) + 50*50*20*(5)
for idimpos,edimpos in enumerate(dimnoapplypos):
curadd = np.mod(edimpos,len(adimnoapplyin[ivsdin][idimpos]))
#e.g. if edimpos == (5): curadd = 50*50*20*(5)
if ((idimpos + 1) < len(arefdnoiterin[ivsdin])):
for i in range(idimpos + 1,len(arefdnoiterin[ivsdin])) :
# here, we assume that the dimensions of the chunk are already in the order considered by adimsnoiter(out) etc. (cfr. preceeded transposition in readicecubeps)
curadd = curadd * len(adimnoiterin[ivsdin][i])
# curaddout = curaddout * dimnoiteroutref[i]
pos = pos + curadd
ahunkin.append(dataicecubein[ivsdin][pos:(pos+alendfuncin[ivsdin])])
shapein.append([len(e) for e in adimfuncin[ivsdin]])
#ahunkin[ivsdin].shape = [len(e) for e in adimfuncin[ivsdin]]
# we are in the special case of an extra dimension to be prepended to the input
if (list() in shapein) and (forcearray):
for ivsdin,evsdin in enumerate(vsdin):
ahunkin[ivsdin].shape = [1]+shapein[ivsdin]
else:
for ivsdin,evsdin in enumerate(vsdin):
ahunkin[ivsdin].shape = shapein[ivsdin]
# apply the function
ahunkout = func(*ahunkin)
if (type(ahunkout).__name__ == 'tuple'):
ahunkout = list(ahunkout)
if (type(ahunkout).__name__ != 'list'):
ahunkout = list([ahunkout])
for ihunkout in range(len(ahunkout)):
ahunkout[ihunkout] = np.array(ahunkout[ihunkout])
# e.g. posout = (9)+ 20*(10) + 50*50*20*(5)
# we are in the special case of an extra dimension to be prepended to the input -> so we remove this dimension again
if (list() in shapein) and (forcearray):
if len(ahunkout[iddout].shape) > 1:
ahunkout[iddout].shape = ahunkout[iddout].shape[1:]
else:
ahunkout[iddout].shape = []
posout = 0
for idimpos,edimpos in enumerate(dimnoapplypos):
curadd = np.mod(edimpos,len(adimnoapplyout[ihunkout][idimpos]))
#e.g. if edimpos == (5): curadd = 50*50*20*(5)
if ((idimpos + 1) < len(arefdnoiterout[ihunkout])):
for i in range(idimpos + 1,len(arefdnoiterout[ihunkout])) :
# here, we assume that the idims are in the intended order (cfr. subsequent transposition in writeicecubeps)
curadd = curadd * len(adimnoiterout[ihunkout][i])
# curaddout = curaddout * dimnoiteroutref[i]
posout = posout + curadd
dataicecubeout[ihunkout][posout:(posout+alendfuncout[ihunkout])] = np.array(ahunkout[ihunkout].ravel(),dtype=vsdout[ihunkout]['dtype'][1])
# go to next data slice
dimnoapplypos[-1] = dimnoapplypos[-1] + 1
for idimidx,edimidx in reversed(list(enumerate(dimnoapplypos))):
# # alternative (makes 'dimiter' redundant)
# if dimiterpos[idimidx] == shp[refiter[idimidx]]:
if idimidx > 0:
if dimnoapplypos[idimidx] == dimnoapplymax[idimidx]:
dimnoapplypos[idimidx-1] = dimnoapplypos[idimidx-1] + 1
dimnoapplypos[idimidx] = 0
sys.stdout.write ('\b'*(len('('+str(k)+'/'+str(lennoapplymax)+')')))
sys.stdout.write ('('+str(k+1)+'/'+str(lennoapplymax)+')')
# if lennoapplymax == 1:
# sys.stdout.write ('\b'*(len('('+str(k)+'/'+str(lennoapplymax)+')')))
# sys.stdout.write ('('+str(k+1)+'/'+str(lennoapplymax)+')')
for idimsout in range(len(dataicecubeout)):
dataicecubeout[idimsout].shape = [len(e) for e in adimnoiterout[idimsout]]
for ivsdout in range(len(vsdout)):
writeicecubeps(\
vsdout[ivsdout]['fp'],
vsdout[ivsdout]['dims'],\
arefditerout[ivsdout],\
adimiterout[ivsdout],\
dimiterpos,\
arefdnoiterout[ivsdout],\
adimnoiterout[ivsdout],\
dataicecubeout[ivsdout],\
vsdout[ivsdout]['dtype'],\
vsdout[ivsdout]['itemsize'],\
vsdout[ivsdout]['voffset'],\
rwchunksizeout[ivsdout])
# go to next data slice
dimiterpos[-1] = dimiterpos[-1] + 1
for idimidx,edimidx in reversed(list(enumerate(dimiterpos))):
# # alternative (makes 'dimiter' redundant)
# if dimiterpos[idimidx] == shp[refiter[idimidx]]:
if dimiterpos[idimidx] == dimitermax[idimidx]:
if idimidx > 0:
dimiterpos[idimidx-1] = dimiterpos[idimidx-1] + 1
dimiterpos[idimidx] = 0
sys.stdout.write ('\b \b'*(len('('+str(k+1)+'/'+str(lennoapplymax)+')')))
sys.stdout.write ('\b \b'*4)
sys.stdout.write ('\b \b'*len(str(j)+'/'+str(lenitermax)))
sys.stdout.write (str(j+1)+'/'+str(lenitermax))
for ivsdin,evsdin in enumerate(vsdin):
if type(vsdin[ivsdin]['fp']).__name__ == 'file':
vsdin[ivsdin]['fp'].close()
for ivsdout,evsdout in enumerate(vsdout):
vsdout[ivsdout]['fp'].close()
print(' ')
| gpl-3.0 | -6,246,336,281,871,507,000 | 51.979391 | 332 | 0.582512 | false |
gaufung/LMDI | Figures/app.py | 1 | 5703 | import numpy as np
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties, findfont
from matplotlib.legend_handler import HandlerPatch
import matplotlib.patches as mpatches
import matplotlib as mpl
from matplotlib import cm
import xlrd
from config import SHEET_INDEX, ROW_START, ROW_END, COLUMN_START, COLUMN_END,FILE_NAME
from model import Unit
plt.rcParams["font.family"] = "Calibri"
fp = FontProperties(family='Calibri')
font = findfont(fp)
#color handlermap
#cmap = plt.cm.jet
# extract all colors from the .jet map
# cmaplist = [cmap(i) for i in range(cmap.N)]
# # force the first color entry to be grey
# cmaplist[0] = (.5,.5,.5,1.0)
# # create the new map
# cmap = cmap.from_list('Custom cmap', cmaplist, cmap.N)
# bounds = np.linspace(0,20,21)
# norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
class MplColorHelper:
def __init__(self, cmap_name, start_val, stop_val):
self.cmap_name = cmap_name
self.cmap = plt.get_cmap(cmap_name)
self.norm = mpl.colors.Normalize(vmin=start_val, vmax=stop_val)
self.scalarMap = cm.ScalarMappable(norm=self.norm, cmap=self.cmap)
def get_rgb(self, val):
return self.scalarMap.to_rgba(val)
col = MplColorHelper('rainbow',0,10)
class HandlerSquare(HandlerPatch):
def create_artists(self, legend, orig_handle,
xdescent, ydescent, width, height, fontsize, trans):
center = xdescent + 0.5 * (width - height), ydescent
p = mpatches.Rectangle(xy=center, width=height,
height=height, angle=0.0)
self.update_prop(p, orig_handle, legend)
p.set_transform(trans)
return [p]
def read_data():
workbook = xlrd.open_workbook(FILE_NAME)
sheet = workbook.sheets()[0]
result = []
yct = []
for row_idx in range(ROW_START,ROW_END+1):
row = sheet.row_values(row_idx)[COLUMN_START:COLUMN_END+1]
result.append(Unit(row[0], float(row[1]), float(row[2]), col.get_rgb(float(row[1]))))
yct.append(float(row[1]))
for item in result:
if '%.2f' % item.yct == '7.29':
item._color=col.get_rgb(8.0)
if '%.2f' % item.yct == '6.02':
item._color=col.get_rgb(7.5)
if '%.2f' % item.yct == '5.55':
item._color=col.get_rgb(7)
if '%.2f' % item.yct == '5.17':
item._color=col.get_rgb(6.5)
if '%.2f' % item.yct == '4.59':
item._color=col.get_rgb(6)
if '%.2f' % item.yct == '4.47':
item._color=col.get_rgb(5.5)
if '%.2f' % item.yct == '4.36':
item._color=col.get_rgb(5)
if '%.2f' % item.yct == '4.42':
item._color=col.get_rgb(4.5)
# yct = sorted(yct)
# dic={}
# for idx,value in enumerate(yct):
# dic[value]=idx
# for item in result:
# item._color=col.get_rgb(dic[item.yct])
return result
def _print(data):
for item in data:
print(item.name,item.yct,item.pei, item.color)
def _bottom(data, current_idx, is_yct=True):
pass
def stack_values(data1, data2):
result1 = [0.0]
result2 = [0.0]
for item1,item2 in zip(data1, data2):
result1.append(result1[-1]+item1.yct)
result2.append(result2[-1]+item2.pei)
return result1, result2
def draw():
row_data = read_data()
data_by_yct = sorted(row_data, key=lambda unit: unit.yct, reverse=True)
data_by_pei = sorted(row_data, key=lambda unit: unit.pei, reverse=True)
stack1, stack2 = stack_values(data_by_yct, data_by_pei)
index = 0.5
bw = 0.5
plt.figure(figsize=(7,9))
plt.axis([0,3,-0.1,100])
baritems= []
labelitems= []
for idx,item in enumerate(data_by_yct):
baritems.append(plt.bar(index, np.array([item.yct]), bw, color=item.color, edgecolor='None',
label=item.name, bottom=stack1[idx]))
labelitems.append(item.name)
for idx,item in enumerate(data_by_pei):
plt.bar(index + 1, np.array([item.pei]), bw, color=item.color, edgecolor='None',
bottom=stack2[idx])
handlermap = {item[0]:HandlerSquare() for item in baritems}
plt.legend([item[0] for item in baritems],labelitems,handler_map=handlermap,loc='right', ncol=1,fontsize=12, frameon=False)
#add text
for idx in range(0,30):
if data_by_yct[idx].yct >= 3.33:
plt.text(0.5, stack1[idx]+0.5*data_by_yct[idx].yct, '%.2f' % data_by_yct[idx].yct,ha='center',va='center')
for idx in range(0,30):
if data_by_pei[idx].pei >= 3.33:
plt.text(1.5, stack2[idx]+0.5*data_by_pei[idx].pei, '%.2f' % data_by_pei[idx].pei,ha='center',va='center')
#decorate
x_ticks = [0.5, 1.5]
x_label = [r"$D_{YCT}$", r"$D_{PEI}$"]
y_ticks = np.arange(0,101,10)
y_labels = np.array([str(item) for item in y_ticks])
for y_value in y_ticks[1:]:
plt.plot([0,0.25],[y_value,y_value],'k-',linewidth=0.5)
plt.plot([0.75,1.25],[y_value,y_value],'k-',linewidth=0.5)
plt.plot([1.75,2],[y_value,y_value],'k-',linewidth=0.5)
plt.plot([0,2],[0,0],'k-',linewidth=1.0)
plt.plot([2,2],[0,100],'k-',linewidth=0.5)
plt.ylabel('Percentage (%)',fontproperties=fp, fontsize=15)
plt.xticks(x_ticks, x_label, fontsize=12,fontproperties=fp)
plt.yticks(y_ticks, y_labels,fontproperties=fp)
gca = plt.gca()
gca.xaxis.set_ticks_position('bottom')
gca.yaxis.set_ticks_position('left')
gca.yaxis.set_ticks_position('left')
gca.spines['right'].set_color('none')
gca.spines['top'].set_color('none')
gca.spines['bottom'].set_color('none')
#plt.show()
plt.savefig('yct_and_pei_dpi_800.jpg',dpi=800)
if __name__ == '__main__':
draw() | mit | -4,575,353,626,627,105,300 | 36.774834 | 127 | 0.607049 | false |
xs2maverick/adhocracy3.mercator | src/adhocracy_frontend/adhocracy_frontend/tests/acceptance/shared.py | 1 | 5414 | """Shared acceptance test functions."""
from random import choice
from time import sleep
import requests
import json
from splinter.driver.webdriver import WebDriverElement
from adhocracy_core.testing import god_login
from adhocracy_core.testing import god_password
from adhocracy_core.testing import participant_password
from adhocracy_core.testing import participant_login
from selenium.common.exceptions import NoSuchElementException
root_uri = 'http://localhost:9080'
verbose = False
ALPHABET = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789'
WHITESPACE = ' '
def get_random_string(n=10, whitespace=False) -> str:
"""Return autogenerated string."""
alphabet = ALPHABET + WHITESPACE if whitespace else ALPHABET
return ''.join(choice(alphabet) for i in range(n))
def wait(condition, step=0.1, max_steps=10) -> bool:
"""Wait for a condition to become true."""
for i in range(max_steps - 1):
try:
result = condition()
if hasattr(result, 'visible'):
if result.visible:
return True
else:
sleep(step)
else:
if result:
return True
else:
sleep(step)
except ValueError:
pass
except NoSuchElementException:
pass
return condition()
def login(browser, name_or_email, password,
expect_success=True,
visit_root=True):
"""Login user with name and password."""
if is_logged_in(browser):
return
login_url = browser.app_url + 'login'
browser.visit(login_url)
fill_input(browser, '.login [name="nameOrEmail"]', name_or_email)
fill_input(browser, '.login [name="password"]', password)
click_button(browser, '.login [type="submit"]')
if expect_success and not browser.wait_for_condition(is_logged_in, 20):
raise Exception('login failed.')
if visit_root:
browser.visit(browser.root_url)
def login_god(browser, **kwargs):
"""Login god user."""
login(browser, god_login, god_password, **kwargs)
def login_participant(browser, **kwargs):
"""Login participant user."""
login(browser, participant_login, participant_password, **kwargs)
def logout(browser):
"""Logout user."""
if is_logged_in(browser):
click_button(browser, '.user-indicator-logout')
browser.wait_for_condition(is_logged_out, 30)
def is_logged_in(browser):
"""Check if user is logged in."""
return browser.is_element_present_by_css('.user-indicator-logout')
def is_logged_out(browser):
"""Check if user is logged out."""
return browser.is_element_not_present_by_css(
'.user-indicator-logout')
def fill_input(browser, css_selector, value):
"""Find `css_selector` and fill value."""
element = browser.find_by_css(css_selector).first
element.fill(value)
def click_button(browser, css_selector):
"""Find `css_selector` and click."""
element = browser.find_by_css(css_selector).first
element.click()
def title_is_in_listing(listing, title: str) -> bool:
"""Check that a listing element with text == `title` exists."""
for element in listing.find_by_css('.listing-element'):
wait(lambda: element.text, max_steps=5)
if element.text == title:
return True
def get_listing_create_form(listing) -> WebDriverElement:
"""Open and return the create form of a listing."""
return listing.find_by_css('.listing-create-form').first
def get_column_listing(browser, column_name: str) -> WebDriverElement:
"""Return the listing in the content column ."""
column = browser.find_by_css('.moving-column-' + column_name)
listing = column.first.find_by_css('.listing')
return listing
def get_list_element(listing, text, descendant=None, max_steps=20):
"""Return list element with text == `text`."""
for element in listing.find_by_css('.listing-element'):
wait(lambda: element.text, max_steps=max_steps)
if descendant is None:
element_text = element.text
else:
element_text = element.find_by_css(descendant).first.text
if element_text == text:
return element
def api_login(name_or_email: str, password: str) -> dict:
"""Login user and return user token and path."""
uri = root_uri + '/login_username'
headers = {
'Content-Type': 'application/json;charset=UTF-8',
'Accept': 'application/json, text/plain, */*',
'Accept-Encoding': 'gzip,deflate',
'Connection': 'keep-alive',
'Accept-Language': 'en-US,en;q=0.8',
'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64)',
'Content-Length': '36'
}
body = json.dumps({
'name': name_or_email,
'password': password
})
response = requests.post(uri, headers=headers, data=body)
if verbose:
print('\n')
print(uri)
print(headers)
print(body)
print(response)
print(response.text)
assert response.status_code == 200
data = response.json()
assert data['status'] == 'success'
return {'user_token': data['user_token'],
'user_path': data['user_path']}
def api_login_god() -> dict:
"""Login in as god and return user token and path."""
return api_login(god_login, god_password)
| agpl-3.0 | -2,467,685,987,288,279,600 | 29.937143 | 75 | 0.634281 | false |
matrix-org/synapse | tests/storage/test_state.py | 1 | 17131 | # Copyright 2018-2021 The Matrix.org Foundation C.I.C.
#
# 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 logging
from synapse.api.constants import EventTypes, Membership
from synapse.api.room_versions import RoomVersions
from synapse.storage.state import StateFilter
from synapse.types import RoomID, UserID
from tests.unittest import HomeserverTestCase
logger = logging.getLogger(__name__)
class StateStoreTestCase(HomeserverTestCase):
def prepare(self, reactor, clock, hs):
self.store = hs.get_datastore()
self.storage = hs.get_storage()
self.state_datastore = self.storage.state.stores.state
self.event_builder_factory = hs.get_event_builder_factory()
self.event_creation_handler = hs.get_event_creation_handler()
self.u_alice = UserID.from_string("@alice:test")
self.u_bob = UserID.from_string("@bob:test")
self.room = RoomID.from_string("!abc123:test")
self.get_success(
self.store.store_room(
self.room.to_string(),
room_creator_user_id="@creator:text",
is_public=True,
room_version=RoomVersions.V1,
)
)
def inject_state_event(self, room, sender, typ, state_key, content):
builder = self.event_builder_factory.for_room_version(
RoomVersions.V1,
{
"type": typ,
"sender": sender.to_string(),
"state_key": state_key,
"room_id": room.to_string(),
"content": content,
},
)
event, context = self.get_success(
self.event_creation_handler.create_new_client_event(builder)
)
self.get_success(self.storage.persistence.persist_event(event, context))
return event
def assertStateMapEqual(self, s1, s2):
for t in s1:
# just compare event IDs for simplicity
self.assertEqual(s1[t].event_id, s2[t].event_id)
self.assertEqual(len(s1), len(s2))
def test_get_state_groups_ids(self):
e1 = self.inject_state_event(self.room, self.u_alice, EventTypes.Create, "", {})
e2 = self.inject_state_event(
self.room, self.u_alice, EventTypes.Name, "", {"name": "test room"}
)
state_group_map = self.get_success(
self.storage.state.get_state_groups_ids(self.room, [e2.event_id])
)
self.assertEqual(len(state_group_map), 1)
state_map = list(state_group_map.values())[0]
self.assertDictEqual(
state_map,
{(EventTypes.Create, ""): e1.event_id, (EventTypes.Name, ""): e2.event_id},
)
def test_get_state_groups(self):
e1 = self.inject_state_event(self.room, self.u_alice, EventTypes.Create, "", {})
e2 = self.inject_state_event(
self.room, self.u_alice, EventTypes.Name, "", {"name": "test room"}
)
state_group_map = self.get_success(
self.storage.state.get_state_groups(self.room, [e2.event_id])
)
self.assertEqual(len(state_group_map), 1)
state_list = list(state_group_map.values())[0]
self.assertEqual({ev.event_id for ev in state_list}, {e1.event_id, e2.event_id})
def test_get_state_for_event(self):
# this defaults to a linear DAG as each new injection defaults to whatever
# forward extremities are currently in the DB for this room.
e1 = self.inject_state_event(self.room, self.u_alice, EventTypes.Create, "", {})
e2 = self.inject_state_event(
self.room, self.u_alice, EventTypes.Name, "", {"name": "test room"}
)
e3 = self.inject_state_event(
self.room,
self.u_alice,
EventTypes.Member,
self.u_alice.to_string(),
{"membership": Membership.JOIN},
)
e4 = self.inject_state_event(
self.room,
self.u_bob,
EventTypes.Member,
self.u_bob.to_string(),
{"membership": Membership.JOIN},
)
e5 = self.inject_state_event(
self.room,
self.u_bob,
EventTypes.Member,
self.u_bob.to_string(),
{"membership": Membership.LEAVE},
)
# check we get the full state as of the final event
state = self.get_success(self.storage.state.get_state_for_event(e5.event_id))
self.assertIsNotNone(e4)
self.assertStateMapEqual(
{
(e1.type, e1.state_key): e1,
(e2.type, e2.state_key): e2,
(e3.type, e3.state_key): e3,
# e4 is overwritten by e5
(e5.type, e5.state_key): e5,
},
state,
)
# check we can filter to the m.room.name event (with a '' state key)
state = self.get_success(
self.storage.state.get_state_for_event(
e5.event_id, StateFilter.from_types([(EventTypes.Name, "")])
)
)
self.assertStateMapEqual({(e2.type, e2.state_key): e2}, state)
# check we can filter to the m.room.name event (with a wildcard None state key)
state = self.get_success(
self.storage.state.get_state_for_event(
e5.event_id, StateFilter.from_types([(EventTypes.Name, None)])
)
)
self.assertStateMapEqual({(e2.type, e2.state_key): e2}, state)
# check we can grab the m.room.member events (with a wildcard None state key)
state = self.get_success(
self.storage.state.get_state_for_event(
e5.event_id, StateFilter.from_types([(EventTypes.Member, None)])
)
)
self.assertStateMapEqual(
{(e3.type, e3.state_key): e3, (e5.type, e5.state_key): e5}, state
)
# check we can grab a specific room member without filtering out the
# other event types
state = self.get_success(
self.storage.state.get_state_for_event(
e5.event_id,
state_filter=StateFilter(
types={EventTypes.Member: {self.u_alice.to_string()}},
include_others=True,
),
)
)
self.assertStateMapEqual(
{
(e1.type, e1.state_key): e1,
(e2.type, e2.state_key): e2,
(e3.type, e3.state_key): e3,
},
state,
)
# check that we can grab everything except members
state = self.get_success(
self.storage.state.get_state_for_event(
e5.event_id,
state_filter=StateFilter(
types={EventTypes.Member: set()}, include_others=True
),
)
)
self.assertStateMapEqual(
{(e1.type, e1.state_key): e1, (e2.type, e2.state_key): e2}, state
)
#######################################################
# _get_state_for_group_using_cache tests against a full cache
#######################################################
room_id = self.room.to_string()
group_ids = self.get_success(
self.storage.state.get_state_groups_ids(room_id, [e5.event_id])
)
group = list(group_ids.keys())[0]
# test _get_state_for_group_using_cache correctly filters out members
# with types=[]
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: set()}, include_others=True
),
)
self.assertEqual(is_all, True)
self.assertDictEqual(
{
(e1.type, e1.state_key): e1.event_id,
(e2.type, e2.state_key): e2.event_id,
},
state_dict,
)
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_members_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: set()}, include_others=True
),
)
self.assertEqual(is_all, True)
self.assertDictEqual({}, state_dict)
# test _get_state_for_group_using_cache correctly filters in members
# with wildcard types
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: None}, include_others=True
),
)
self.assertEqual(is_all, True)
self.assertDictEqual(
{
(e1.type, e1.state_key): e1.event_id,
(e2.type, e2.state_key): e2.event_id,
},
state_dict,
)
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_members_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: None}, include_others=True
),
)
self.assertEqual(is_all, True)
self.assertDictEqual(
{
(e3.type, e3.state_key): e3.event_id,
# e4 is overwritten by e5
(e5.type, e5.state_key): e5.event_id,
},
state_dict,
)
# test _get_state_for_group_using_cache correctly filters in members
# with specific types
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: {e5.state_key}}, include_others=True
),
)
self.assertEqual(is_all, True)
self.assertDictEqual(
{
(e1.type, e1.state_key): e1.event_id,
(e2.type, e2.state_key): e2.event_id,
},
state_dict,
)
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_members_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: {e5.state_key}}, include_others=True
),
)
self.assertEqual(is_all, True)
self.assertDictEqual({(e5.type, e5.state_key): e5.event_id}, state_dict)
# test _get_state_for_group_using_cache correctly filters in members
# with specific types
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_members_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: {e5.state_key}}, include_others=False
),
)
self.assertEqual(is_all, True)
self.assertDictEqual({(e5.type, e5.state_key): e5.event_id}, state_dict)
#######################################################
# deliberately remove e2 (room name) from the _state_group_cache
cache_entry = self.state_datastore._state_group_cache.get(group)
state_dict_ids = cache_entry.value
self.assertEqual(cache_entry.full, True)
self.assertEqual(cache_entry.known_absent, set())
self.assertDictEqual(
state_dict_ids,
{
(e1.type, e1.state_key): e1.event_id,
(e2.type, e2.state_key): e2.event_id,
},
)
state_dict_ids.pop((e2.type, e2.state_key))
self.state_datastore._state_group_cache.invalidate(group)
self.state_datastore._state_group_cache.update(
sequence=self.state_datastore._state_group_cache.sequence,
key=group,
value=state_dict_ids,
# list fetched keys so it knows it's partial
fetched_keys=((e1.type, e1.state_key),),
)
cache_entry = self.state_datastore._state_group_cache.get(group)
state_dict_ids = cache_entry.value
self.assertEqual(cache_entry.full, False)
self.assertEqual(cache_entry.known_absent, {(e1.type, e1.state_key)})
self.assertDictEqual(state_dict_ids, {(e1.type, e1.state_key): e1.event_id})
############################################
# test that things work with a partial cache
# test _get_state_for_group_using_cache correctly filters out members
# with types=[]
room_id = self.room.to_string()
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: set()}, include_others=True
),
)
self.assertEqual(is_all, False)
self.assertDictEqual({(e1.type, e1.state_key): e1.event_id}, state_dict)
room_id = self.room.to_string()
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_members_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: set()}, include_others=True
),
)
self.assertEqual(is_all, True)
self.assertDictEqual({}, state_dict)
# test _get_state_for_group_using_cache correctly filters in members
# wildcard types
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: None}, include_others=True
),
)
self.assertEqual(is_all, False)
self.assertDictEqual({(e1.type, e1.state_key): e1.event_id}, state_dict)
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_members_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: None}, include_others=True
),
)
self.assertEqual(is_all, True)
self.assertDictEqual(
{
(e3.type, e3.state_key): e3.event_id,
(e5.type, e5.state_key): e5.event_id,
},
state_dict,
)
# test _get_state_for_group_using_cache correctly filters in members
# with specific types
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: {e5.state_key}}, include_others=True
),
)
self.assertEqual(is_all, False)
self.assertDictEqual({(e1.type, e1.state_key): e1.event_id}, state_dict)
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_members_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: {e5.state_key}}, include_others=True
),
)
self.assertEqual(is_all, True)
self.assertDictEqual({(e5.type, e5.state_key): e5.event_id}, state_dict)
# test _get_state_for_group_using_cache correctly filters in members
# with specific types
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: {e5.state_key}}, include_others=False
),
)
self.assertEqual(is_all, False)
self.assertDictEqual({}, state_dict)
(state_dict, is_all,) = self.state_datastore._get_state_for_group_using_cache(
self.state_datastore._state_group_members_cache,
group,
state_filter=StateFilter(
types={EventTypes.Member: {e5.state_key}}, include_others=False
),
)
self.assertEqual(is_all, True)
self.assertDictEqual({(e5.type, e5.state_key): e5.event_id}, state_dict)
| apache-2.0 | -4,163,653,240,456,441,000 | 35.217759 | 88 | 0.556885 | false |
kenjyoung/MinAtar | examples/human_play.py | 1 | 3764 | ################################################################################################################
# Authors: #
# Kenny Young ([email protected]) #
# Tian Tian ([email protected]) #
# #
# python3 human_test.py -g <game> #
################################################################################################################
import argparse
import tkinter as Tk
from minatar import Environment, GUI
################################################################################################################
# Script that allows a human to play any of the MinAtar games. Use arrow keys to move and space to fire.
# Pressing q will exit the game, r will restart.
#
################################################################################################################
parser = argparse.ArgumentParser()
parser.add_argument("--game", "-g", type=str)
args = parser.parse_args()
# Setup game environment and GUI
env = Environment(args.game)
gui = GUI(env.game_name(), env.n_channels)
# Thread safe variables for use with GUI
action = Tk.IntVar()
action.set(0)
action_taken = Tk.BooleanVar()
action_taken.set(False)
action_released = Tk.BooleanVar()
action_released.set(False)
G = Tk.DoubleVar()
G.set(0.0)
is_terminate = Tk.BooleanVar()
is_terminate.set(False)
# Map input keys to agent actions
key_action_map = {' ':5, 'left':1, 'up':2, 'right':3, 'down':4}
# Key press handler for human player
def on_key_event(event):
if event.key == 'q': # quit the game
gui.quit()
elif (event.key == 'r'): # reset the game environment
env.reset()
elif(event.key in key_action_map):
key_action = key_action_map[event.key]
action.set(key_action)
# When new action is selected it has not yet been taken or released
action_released.set(False)
action_taken.set(False)
# Key release handlr for human player
def on_release_event(event):
if(event.key in key_action_map):
key_action = key_action_map[event.key]
a = action.get()
if(a==key_action):
# If released action has already been taken set action to no-op immediately
if(action_taken.get()):
action.set(0)
# Otherwise note that it has been released so that we can set back to no-op when it is taken
else:
action_released.set(True)
################################################################################################################
# play
#
# Allows user to the play the game and displays state and score via gui.
#
################################################################################################################
def play():
if is_terminate.get() == True:
gui.quit()
# Get players actions selection, if that action has been released, set action back to no-op for next frame
a = action.get()
action_taken.set(True)
if(action_released.get()):
action.set(0)
r, t = env.act(a)
is_terminate.set(t)
G.set(G.get()+r)
gui.display_state(env.state())
gui.set_message("Score: " + str(G.get()))
gui.update(50, play)
# Hook up the key handler and initiate game play
gui.overwrite_key_handle(on_key_event, on_release_event)
gui.update(0, play)
gui.run()
print("Final Score: "+str(G.get()))
| gpl-3.0 | -8,559,620,511,119,420,000 | 39.042553 | 112 | 0.459086 | false |
thortex/rpi3-webiopi | webiopi_0.7.1/python/webiopi/devices/memory/__init__.py | 1 | 12397 | # Copyright 2014 Andreas Riegg - t-h-i-n-x.net
#
# 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.
#
# Changelog
#
# 1.0 2014-06-26 Initial release.
# 1.1 2014-08-28 Added bit access.
# 1.2 2014-08-31 Added NON-REST multiple read/write byte methods
# to speed up direct Python access.
# 1.3 2014-11-13 Changed parameter order for writeMemoryBytes and
# optimized it.
# 1.4 2014-12-08 Simplified multiple read/write byte methods and
# made start/stop bounds checking more strict.
# Added REST mapping for multiple bytes reading.
# Made addressing scheme uniform for all slot types.
#
# Usage remarks
#
# - The smallest possible memory unit is 1 byte (8 bits)
# - Addressed slots can be
# - bits ( 1 bit)
# - bytes ( 8 bits)
# - words (16 bits)
# - longs (32 bits)
# - All memory address slots are mapped strictly sequential in ascending
# order like channel numbers starting at 0 with MSB first for non
# single-bit slots. This results in the following address slot mapping:
# |<- bit 0 bit 31 ->|
# 01010101010101010101010101010101
# |byte 0| byte 1| byte 2| byte 3|
# | -- word 0 -- | -- word 1 -- |
# | ---------- long 0 ---------- |
# - Where applicable, start and stop have the same meaning as range and
# list slices in Python. Start is included, stop is excluded.
#
from webiopi.decorators.rest import request, response
from webiopi.utils.types import toint, M_JSON
class Memory():
def __init__(self, byteCount):
self._byteCount = byteCount
#---------- Abstraction framework contracts ----------
def __family__(self):
return "Memory"
#---------- Memory abstraction REST implementation ----------
@request("GET", "memory/bit/*")
@response(contentType=M_JSON)
def memoryBitWildcard(self):
values = {}
for i in range(self.byteCount()):
valbyte = self.readMemoryByte(i)
for j in range(8):
position = 7 - j
values[i*8 + j] = "%d" % ((valbyte & (1 << position)) >> position)
return values
# {
# "0": "0",
# "1": "0",
# "2": "0",
# "3": "1"
# "4": "0"
# "5": "0"
# "6": "1"
# "7": "0"
# ...
# }
@request("GET", "memory/byte/*")
@response(contentType=M_JSON)
def memoryByteWildcard(self):
values = {}
byteValues = self.readMemoryBytes()
for i in range(len(byteValues)):
values[i] = "0x%02X" % byteValues[i]
return values
# {
# "0": "0x12",
# "1": "0x34",
# "2": "0xDE",
# "3": "0xFF"
# }
@request("GET", "memory/bytes/%(bounds)s")
@response(contentType=M_JSON)
def memoryBytes(self, bounds):
(start, stop) = bounds.split(",")
start = toint(start)
stop = toint(stop)
values = {}
byteValues = self.readMemoryBytes(start, stop)
for i in range(start, stop):
values[i] = "0x%02X" % byteValues[i - start]
return values
# {
# "1": "0x34",
# "2": "0xDE",
# }
@request("GET", "memory/word/*")
@response(contentType=M_JSON)
def memoryWordWildcard(self):
values = {}
for i in range(self.wordCount()):
values[i] = "0x%04X" % self.readMemoryWord(i)
return values
# {
# "0": "0x1234",
# "1": "0xDEFF"
# }
@request("GET", "memory/long/*")
@response(contentType=M_JSON)
def memoryLongWildcard(self):
values = {}
for i in range(self.longCount()):
values[i] = "0x%08X" % self.readMemoryLong(i)
return values
# {
# "0": "0x1234DEFF"
# }
@request("GET", "memory/bit/count")
@response("%d")
def bitCount(self):
return self._byteCount * 8
@request("GET", "memory/byte/count")
@response("%d")
def byteCount(self):
return self._byteCount
@request("GET", "memory/word/count")
@response("%d")
def wordCount(self):
return self._byteCount >> 1
@request("GET", "memory/long/count")
@response("%d")
def longCount(self):
return self._byteCount >> 2
@request("GET", "memory/bit/%(address)s")
@response("%d")
def readMemoryBit(self, address):
address = toint(address)
self.checkBitAddress(address)
return self.__readMemoryBit__(address)
@request("POST", "memory/bit/%(address)s/%(value)s")
@response("%d")
def writeMemoryBit(self, address, value):
address = toint(address)
self.checkBitAddress(address)
value = toint(value)
self.checkBitValue(value)
self.__writeMemoryBit__(address, value)
return self.readMemoryBit(address)
@request("GET", "memory/byte/%(address)s")
@response("0x%02X")
def readMemoryByte(self, address):
address = toint(address)
self.checkByteAddress(address)
return self.__readMemoryByte__(address)
@request("POST", "memory/byte/%(address)s/%(value)s")
@response("0x%02X")
def writeMemoryByte(self, address, value):
address = toint(address)
self.checkByteAddress(address)
value = toint(value)
self.checkByteValue(value)
self.__writeMemoryByte__(address, value)
return self.readMemoryByte(address)
@request("GET", "memory/word/%(address)s")
@response("0x%04X")
def readMemoryWord(self, address):
address = toint(address)
self.checkWordAddress(address)
return self.__readMemoryWord__(address)
@request("POST", "memory/word/%(address)s/%(value)s")
@response("0x%04X")
def writeMemoryWord(self, address, value):
address = toint(address)
self.checkWordAddress(address)
value = toint(value)
self.checkWordValue(value)
self.__writeMemoryWord__(address, value)
return self.readMemoryWord(address)
@request("GET", "memory/long/%(address)s")
@response("0x%08X")
def readMemoryLong(self, address):
address = toint(address)
self.checkLongAddress(address)
return self.__readMemoryLong__(address)
@request("POST", "memory/long/%(address)s/%(value)s")
@response("0x%08X")
def writeMemoryLong(self, address, value):
address = toint(address)
self.checkLongAddress(address)
value = toint(value)
self.checkLongValue(value)
self.__writeMemoryLong__(address, value)
return self.readMemoryLong(address)
#---------- Memory abstraction NON-REST implementation ----------
def readMemoryBytes(self, start=0, stop=None):
maxCount = self.byteCount()
if stop is None:
stop = maxCount
self.checkByteAddress(start)
self.checkStopByteAddress(stop)
byteValues = []
if start > stop:
raise ValueError("Stop address must be >= start address")
for i in range(start, stop):
byteValues.append(self.readMemoryByte(i))
return byteValues
def writeMemoryBytes(self, start=0, byteValues=[]):
self.checkByteAddress(start)
stop = start + len(byteValues)
self.checkStopByteAddress(stop)
i = 0
for byte in byteValues: # do nothing if list is empty
position = i + start
self.writeMemoryByte(position, byte)
i += 1
#---------- Memory abstraction contracts ----------
def __readMemoryByte__(self, address):
raise NotImplementedError
def __writeMemoryByte__(self, address, value):
raise NotImplementedError
#---------- Memory abstraction contracts with default implementations ---------
def __readMemoryBit__(self, address):
byteAddress, rawPosition = divmod(address, 8)
bitPosition = 7 - rawPosition
return (self.__readMemoryByte__(byteAddress) & (1 << bitPosition)) >> bitPosition
def __writeMemoryBit__(self, address, value):
byteAddress, rawPosition = divmod(address, 8)
bitPosition = 7 - rawPosition
changeMask = 1 << bitPosition
byteValue = self.__readMemoryByte__(byteAddress)
if value:
byteValue |= changeMask
else:
byteValue &= ~changeMask
self.__writeMemoryByte__(byteAddress, byteValue)
def __readMemoryWord__(self, address):
byte0 = self.__readMemoryByte__(address * 2)
byte1 = self.__readMemoryByte__((address * 2) + 1)
return (byte0 << 8) + byte1
def __writeMemoryWord__(self, address, value):
byte0 = (value >> 8) & 0xFF
byte1 = value & 0xFF
self.__writeMemoryByte__(address * 2, byte0)
self.__writeMemoryByte__((address * 2) + 1, byte1)
def __readMemoryLong__(self, address):
byte0 = self.__readMemoryByte__(address * 4)
byte1 = self.__readMemoryByte__((address * 4) + 1)
byte2 = self.__readMemoryByte__((address * 4) + 2)
byte3 = self.__readMemoryByte__((address * 4) + 3)
return (byte0 << 24) + (byte1 << 16) + (byte2 << 8) + byte3
def __writeMemoryLong__(self, address, value):
byte0 = (value >> 24) & 0xFF
byte1 = (value >> 16) & 0xFF
byte2 = (value >> 8) & 0xFF
byte3 = value & 0xFF
self.__writeMemoryByte__(address * 4, byte0)
self.__writeMemoryByte__((address * 4) + 1, byte1)
self.__writeMemoryByte__((address * 4) + 2, byte2)
self.__writeMemoryByte__((address * 4) + 3, byte3)
#---------- Value checks ----------
def checkBitAddress(self, address):
if not 0 <= address < self.byteCount() * 8:
raise ValueError("Bit address [%d] out of range [%d..%d]" % (address, 0, (self.byteCount() * 8) - 1))
def checkBitValue(self, value):
if not value in range(2):
raise ValueError("Bit value [%d] out of range [0..1]" % value)
def checkByteAddress(self, address):
if not 0 <= address < self.byteCount():
raise ValueError("Byte address [%d] out of range [%d..%d]" % (address, 0, self.byteCount() - 1))
def checkStopByteAddress(self, address):
if not 0 <= address <= self.byteCount():
raise ValueError("Stop byte address [%d] out of range [%d..%d]" % (address, 0, self.byteCount()))
def checkByteValue(self, value):
if not value in range(0x00,0xFF + 1):
raise ValueError("Byte value [0x%02X] out of range [0x%02X..0x%02X]" % (value, 0x00,0xFF))
def checkWordAddress(self, address):
if not 0 <= address < self.wordCount():
raise ValueError("Word address [%d] out of range [%d..%d]" % (address, 0, (self.wordCount() - 1)))
def checkWordValue(self, value):
if not value in range(0x00,0xFFFF + 1):
raise ValueError("Word value [0x%04X] out of range [0x%04X..0x%04X]" % (value, 0x00,0xFFFF))
def checkLongAddress(self, address):
if not 0 <= address < self.longCount():
raise ValueError("Long address [%d] out of range [%d..%d]" % (address, 0, (self.longCount() - 1)))
def checkLongValue(self, value):
if not value in range(0x00,0xFFFFFFFF + 1):
raise ValueError("Long value [0x%08X] out of range [0x%08X..0x%08X]" % (value, 0x00,0xFFFFFFFF))
#---------- Driver lookup ----------
DRIVERS = {}
DRIVERS["filememory"] = ["PICKLEFILE"]
DRIVERS["at24"] = ["EE24BASIC", "EE24X32", "EE24X64", "EE24X128", "EE24X256", "EE24X512", "EE24X1024_2"]
| apache-2.0 | -2,507,982,289,497,271,000 | 33.628492 | 113 | 0.571267 | false |
mattjj/pylds | pylds/distributions.py | 1 | 8777 | import autograd.numpy as np
from autograd import value_and_grad
from autograd.scipy.special import gammaln
from scipy.optimize import minimize
from pybasicbayes.distributions import Regression
from pybasicbayes.util.text import progprint_xrange
class PoissonRegression(Regression):
"""
Poisson regression with Gaussian distributed inputs and exp link:
y ~ Poisson(exp(Ax))
where x ~ N(mu, sigma)
Currently, we only support maximum likelihood estimation of the
parameters A given the distribution over inputs, x, and
the observed outputs, y.
We compute the expected log likelihood in closed form (since
we can do this with the exp link function), and we use Autograd
to compute its gradients.
"""
def __init__(self, D_out, D_in, A=None, verbose=False):
self._D_out, self._D_in = D_out, D_in
self.verbose = verbose
if A is not None:
assert A.shape == (D_out, D_in)
self.A = A.copy()
else:
self.A = 0.01 * np.random.randn(D_out, D_in)
self.sigma = None
@property
def D_in(self):
return self._D_in
@property
def D_out(self):
return self._D_out
def log_likelihood(self,xy):
assert isinstance(xy, tuple)
x, y = xy
loglmbda = x.dot(self.A.T)
lmbda = np.exp(loglmbda)
return -gammaln(y+1) - lmbda + y * loglmbda
def expected_log_likelihood(self, mus, sigmas, y):
"""
Compute the expected log likelihood for a mean and
covariance of x and an observed value of y.
"""
# Flatten the covariance
T = mus.shape[0]
D = self.D_in
sigs_vec = sigmas.reshape((T, D ** 2))
# Compute the log likelihood of each column
ll = np.zeros((T, self.D_out))
for n in range(self.D_out):
an = self.A[n]
E_loglmbda = np.dot(mus, an)
ll[:,n] += y[:,n] * E_loglmbda
# Vectorized log likelihood calculation
aa_vec = np.outer(an, an).reshape((D ** 2,))
ll[:,n] = -np.exp(E_loglmbda + 0.5 * np.dot(sigs_vec, aa_vec))
return ll
def predict(self, x):
return np.exp(x.dot(self.A.T))
def rvs(self,x=None,size=1,return_xy=True):
x = np.random.normal(size=(size, self.D_in)) if x is None else x
y = np.random.poisson(self.predict(x))
return np.hstack((x, y)) if return_xy else y
def max_likelihood(self, data, weights=None,stats=None):
"""
Maximize the likelihood for a given value of x
:param data:
:param weights:
:param stats:
:return:
"""
raise NotImplementedError
def max_expected_likelihood(self, stats, verbose=False):
# These aren't really "sufficient" statistics, since we
# need the mean and covariance for each time bin.
EyxuT = np.sum([s[0] for s in stats], axis=0)
mus = np.vstack([s[1] for s in stats])
sigmas = np.vstack([s[2] for s in stats])
inputs = np.vstack([s[3] for s in stats])
masks = np.vstack(s[4] for s in stats)
T = mus.shape[0]
D_latent = mus.shape[1]
sigmas_vec = sigmas.reshape((T, D_latent**2))
# Optimize each row of A independently
ns = progprint_xrange(self.D_out) if verbose else range(self.D_out)
for n in ns:
# Flatten the covariance to enable vectorized calculations
def ll_vec(an):
ll = 0
ll += np.dot(an, EyxuT[n])
# Vectorized log likelihood calculation
loglmbda = np.dot(mus, an)
aa_vec = np.outer(an[:D_latent], an[:D_latent]).reshape((D_latent ** 2,))
trms = np.exp(loglmbda + 0.5 * np.dot(sigmas_vec, aa_vec))
ll -= np.sum(trms[masks[:, n]])
if not np.isfinite(ll):
return -np.inf
return ll / T
obj = lambda x: -ll_vec(x)
itr = [0]
def cbk(x):
itr[0] += 1
print("M_step iteration ", itr[0])
res = minimize(value_and_grad(obj), self.A[n],
jac=True,
callback=cbk if verbose else None)
assert res.success
self.A[n] = res.x
class BernoulliRegression(Regression):
"""
Bernoulli regression with Gaussian distributed inputs and logistic link:
y ~ Bernoulli(logistic(Ax))
where x ~ N(mu, sigma)
Currently, we only support maximum likelihood estimation of the
parameter A given the distribution over inputs, x, and
the observed outputs, y.
We approximate the expected log likelihood with Monte Carlo.
"""
def __init__(self, D_out, D_in, A=None, verbose=False):
self._D_out, self._D_in = D_out, D_in
self.verbose = verbose
if A is not None:
assert A.shape == (D_out, D_in)
self.A = A.copy()
else:
self.A = 0.01 * np.random.randn(D_out, D_in)
self.sigma = None
@property
def D_in(self):
return self._D_in
@property
def D_out(self):
return self._D_out
def log_likelihood(self,xy):
assert isinstance(xy, tuple)
x, y = xy
psi = x.dot(self.A.T)
# First term is linear
ll = y * psi
# Compute second term with log-sum-exp trick (see above)
logm = np.maximum(0, psi)
ll -= np.sum(logm)
ll -= np.sum(np.log(np.exp(-logm) + np.exp(psi - logm)))
return ll
def predict(self, x):
return 1 / (1 + np.exp(-x.dot(self.A.T)))
def rvs(self, x=None, size=1, return_xy=True):
x = np.random.normal(size=(size, self.D_in)) if x is None else x
y = np.random.rand(x.shape[0], self.D_out) < self.predict(x)
return np.hstack((x, y)) if return_xy else y
def max_likelihood(self, data, weights=None, stats=None):
"""
Maximize the likelihood for given data
:param data:
:param weights:
:param stats:
:return:
"""
if isinstance(data, list):
x = np.vstack([d[0] for d in data])
y = np.vstack([d[1] for d in data])
elif isinstance(data, tuple):
assert len(data) == 2
elif isinstance(data, np.ndarray):
x, y = data[:,:self.D_in], data[:, self.D_in:]
else:
raise Exception("Invalid data type")
from sklearn.linear_model import LogisticRegression
for n in progprint_xrange(self.D_out):
lr = LogisticRegression(fit_intercept=False)
lr.fit(x, y[:,n])
self.A[n] = lr.coef_
def max_expected_likelihood(self, stats, verbose=False, n_smpls=1):
# These aren't really "sufficient" statistics, since we
# need the mean and covariance for each time bin.
EyxuT = np.sum([s[0] for s in stats], axis=0)
mus = np.vstack([s[1] for s in stats])
sigmas = np.vstack([s[2] for s in stats])
inputs = np.vstack([s[3] for s in stats])
T = mus.shape[0]
D_latent = mus.shape[1]
# Draw Monte Carlo samples of x
sigmas_chol = np.linalg.cholesky(sigmas)
x_smpls = mus[:, :, None] + np.matmul(sigmas_chol, np.random.randn(T, D_latent, n_smpls))
# Optimize each row of A independently
ns = progprint_xrange(self.D_out) if verbose else range(self.D_out)
for n in ns:
def ll_vec(an):
ll = 0
# todo include mask
# First term is linear in psi
ll += np.dot(an, EyxuT[n])
# Second term depends only on x and cannot be computed in closed form
# Instead, Monte Carlo sample x
psi_smpls = np.einsum('tdm, d -> tm', x_smpls, an[:D_latent])
psi_smpls = psi_smpls + np.dot(inputs, an[D_latent:])[:, None]
logm = np.maximum(0, psi_smpls)
trm2_smpls = logm + np.log(np.exp(-logm) + np.exp(psi_smpls - logm))
ll -= np.sum(trm2_smpls) / n_smpls
if not np.isfinite(ll):
return -np.inf
return ll / T
obj = lambda x: -ll_vec(x)
itr = [0]
def cbk(x):
itr[0] += 1
print("M_step iteration ", itr[0])
res = minimize(value_and_grad(obj), self.A[n],
jac=True,
# callback=cbk if verbose else None)
callback=None)
assert res.success
self.A[n] = res.x
| mit | 6,226,444,625,505,084,000 | 30.124113 | 97 | 0.53982 | false |
botswana-harvard/edc-rule-groups | edc_rule_groups/rule_group.py | 1 | 4885 | import inspect
import copy
from .exceptions import RuleGroupError
from .rule import Rule
class BaseMeta:
"""Base class for RuleGroup "Meta" class."""
app_label = None
source_model = None
source_fk = None
rules = None
def __init__(self, group_name, **meta_attrs):
for k, v in meta_attrs.items():
setattr(self, k, v)
self.group_name = group_name
def __repr__(self):
return '<Options for {}>'.format(self.group_name)
class RuleGroupMeta(type):
"""Rule group metaclass."""
def __new__(cls, name, bases, attrs):
"""Add the Meta attributes to each rule."""
try:
abstract = attrs.get('Meta', False).abstract
except AttributeError:
abstract = False
parents = [b for b in bases if isinstance(b, RuleGroupMeta)]
if not parents or abstract:
# If this isn't a subclass of BaseRuleGroup, don't do anything special.
return super(RuleGroupMeta, cls).__new__(cls, name, bases, attrs)
for parent in parents:
try:
if parent.Meta.abstract:
for rule in [member for member in inspect.getmembers(parent) if isinstance(member[1], Rule)]:
parent_rule = copy.deepcopy(rule)
attrs.update({parent_rule[0]: parent_rule[1]})
except AttributeError:
pass
# get the meta class delared on the RuleGroup
meta = attrs.pop('Meta', None)
try:
if meta.source_model == meta.source_model.split('.'):
source_model = meta.app_label, meta.source_model
else:
source_model = meta.source_model.split('.')
except AttributeError as e:
if '\'tuple\' object has no attribute \'split\'' not in str(e):
meta.source_model = None
source_model = None
else:
source_model = meta.source_model
try:
if not meta.source_fk:
meta.source_fk = None
except AttributeError:
meta.source_fk = None
# update attrs in each rule from values in Meta
rules = []
for rule_name, rule in attrs.items():
if not rule_name.startswith('_'):
if isinstance(rule, Rule):
rule.name = rule_name
rule.group = name
rule.app_label = meta.app_label
if meta:
rule.app_label = meta.app_label
target_models = []
try:
for target_model in rule.target_models:
if len(target_model.split('.')) != 2:
target_model = '{}.{}'.format(meta.app_label, target_model)
target_models.append(target_model)
rule.target_models = target_models
except AttributeError as e:
if 'target_models' not in str(e):
raise AttributeError(e)
if len(rule.target_model.split('.')) != 2:
rule.target_model = '{}.{}'.format(meta.app_label, rule.target_model)
rule.target_models = [rule.target_model]
rule.source_model = source_model
rules.append(rule)
# add a django like _meta to Rulegroup as an instance of BaseMeta
meta_attrs = {k: getattr(meta, k) for k in meta.__dict__ if not k.startswith('_')}
meta_attrs.update({'rules': tuple(rules)})
attrs.update({'_meta': BaseMeta(name, **meta_attrs)})
attrs.update({'name': '{}.{}'.format(meta.app_label, name.lower())})
return super(RuleGroupMeta, cls).__new__(cls, name, bases, attrs)
class RuleGroup(object, metaclass=RuleGroupMeta):
"""A class used to decalre and contain rules."""
@classmethod
def run_for_source_model(cls, obj, source_model):
for rule in cls._meta.rules:
if rule.source_model == source_model:
try:
rule.run(obj)
except AttributeError as e:
raise RuleGroupError(
'An exception was raised for rule {} with object \'{}\'. Got {}'.format(
rule, obj._meta.label_lower, str(e)))
@classmethod
def run_all(cls, obj):
for rule in cls._meta.rules:
try:
rule.run(obj)
except AttributeError as e:
raise RuleGroupError(
'An exception was raised for rule {} with object \'{}\'. Got {}'.format(
rule, obj._meta.label_lower, str(e)))
| gpl-2.0 | 1,186,585,431,572,537,900 | 38.715447 | 113 | 0.510952 | false |
oolorg/ool-l1patch-dev | patch_ofc.py | 1 | 8096 | import logging
import json
from webob import Response
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller import dpset
# from ryu.controller.handler import MAIN_DISPATCHER
from ryu.controller.handler import CONFIG_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_0
from ryu.ofproto import ofproto_v1_2
from ryu.ofproto import ofproto_v1_3
from ryu.lib import ofctl_v1_0
from ryu.lib import ofctl_v1_2
from ryu.lib import ofctl_v1_3
from ryu.app.wsgi import ControllerBase, WSGIApplication, route
import patch_ofc_flowbuilder
import patch_ofc_error
'''
"L1patch" OpenFlow controller based on "OFPatchPanel".
See also "OFPatchPanel" application.
nmasao/OFPatchPanel-SDNHackathon2014 - GitHub
https://github.com/nmasao/OFPatchPanel-SDNHackathon2014
'''
patch_instance_name = 'patch_app'
LOG = logging.getLogger('ryu.app.patch.patch_rest')
class PatchPanel(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION,
ofproto_v1_2.OFP_VERSION,
ofproto_v1_3.OFP_VERSION]
_CONTEXTS = {
'wsgi': WSGIApplication,
'dpset': dpset.DPSet}
def __init__(self, *args, **kwargs):
super(PatchPanel, self).__init__(*args, **kwargs)
self.dpset = kwargs['dpset']
wsgi = kwargs['wsgi']
wsgi.register(PatchController, {patch_instance_name: self})
self.patch_flows = [] # list of dict(flow)
@set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
datapath = ev.msg.datapath
message = 'connected datapath: dpid=%d' % datapath.id
LOG.info(message)
deny_any_flow = {
'match': {
# match any
},
'actions': [
# empty : action DROP
],
'priority': 0 # lowest priority
}
if not self._mod_patch_flow_entry(
datapath, deny_any_flow, datapath.ofproto.OFPFC_ADD):
msg = "DPID:%s, Cannot set default deny flow rule." % datapath.id
raise patch_ofc_error.PatchOfcError(msg)
def add_patch_flow(self, req_flow):
self._mod_patch_flow(req_flow, 'put')
def delete_patch_flow(self, req_flow):
self._mod_patch_flow(req_flow, 'delete')
def _mod_patch_flow(self, req_flow, command):
# check command
if command not in ['delete', 'put']:
LOG.error("Unknown command: %s" % command)
return Response(status=501)
# Check before send flow-mod
dpid = req_flow.get('dpid')
dp = self.dpset.get(dpid)
if dp is None:
LOG.error("Cannot find datapath-id:%s" % dpid)
return Response(status=400)
# TODO: resource overwrap-check for exclusive mode wire
# for flow in self.patch_flows:
# if dpid == flow['dpid'] and inport == flow['inport']:
# LOG.info('Requested inport is already used (dpid:%s, inport:%d)', dpid, inport)
# return Response(status=400)
try:
flow_rules = patch_ofc_flowbuilder.FlowRuleBuilder(dp, req_flow).build_flow()
for flow_rule in flow_rules:
print "--------------------------"
print "%s, dpid:%d (ofp_ver:%d)" % (
command.upper(), dpid, dp.ofproto.OFP_VERSION
)
print json.dumps(req_flow)
print json.dumps(flow_rule)
self._mod_patch_flow_entry(
dp, flow_rule, self._get_datapath_command(dp, command)
)
self._post_mod_patch_flow(req_flow, command)
print "--------------------------"
cors_headers = {'Access-Control-Allow-Origin': '*'}
# Notice: Any request will accepted (status=200)
# if the request can send flow-mod to OFS
# (When the request does not have invalid dpid, invalid ofp-version.)
# Does not matter whether the request is match/correct.
return Response(status=200, headers=cors_headers)
except (patch_ofc_error.PatchOfcRestError,
patch_ofc_error.PatchOfcError) as err:
LOG.error(err.message)
return Response(status=501)
@staticmethod
def _get_datapath_command(dp, command):
if command == 'delete':
return dp.ofproto.OFPFC_DELETE
elif command == 'put':
return dp.ofproto.OFPFC_ADD
else:
msg = "Unknown command: %s" % command
raise patch_ofc_error.PatchOfcError(msg)
def _post_mod_patch_flow(self, req_flow, command):
if command == 'delete':
self._delete_from_patch_flows(req_flow)
elif command == 'put':
self.patch_flows.append(req_flow)
else:
msg = "Unknown command: %s" % command
raise patch_ofc_error.PatchOfcError(msg)
def _delete_from_patch_flows(self, req_flow):
# check each flows
req_flow_str = json.dumps(req_flow)
found_flow = None
for flow in self.patch_flows:
# TODO: now, use simplified/strict compare...
# difficult to compare recursively complex dict/list data.
# To compare it more simply, stringify these data...
# (json.dumps default: dictionary sorted.
flow_str = json.dumps(flow)
if req_flow_str == flow_str:
found_flow = flow
break
if found_flow:
self.patch_flows.remove(found_flow)
def _mod_patch_flow_entry(self, dp, flow_rule, command):
if dp.ofproto.OFP_VERSION in self.OFP_VERSIONS:
if dp.ofproto.OFP_VERSION == ofproto_v1_0.OFP_VERSION:
ofctl_v1_0.mod_flow_entry(dp, flow_rule, command)
elif dp.ofproto.OFP_VERSION == ofproto_v1_2.OFP_VERSION:
ofctl_v1_2.mod_flow_entry(dp, flow_rule, command)
elif dp.ofproto.OFP_VERSION == ofproto_v1_3.OFP_VERSION:
ofctl_v1_3.mod_flow_entry(dp, flow_rule, command)
return True
else:
msg = "Unsupported OFP version: %s" % dp.ofproto.OFP_VERSION
raise patch_ofc_error.PatchOfcError(msg)
def get_patch_flows(self):
body = json.dumps(self.patch_flows)
return Response(content_type='application/json',
body=body, status=200)
class PatchController(ControllerBase):
def __init__(self, req, link, data, **config):
super(PatchController, self).__init__(req, link, data, **config)
self.patch_app = data[patch_instance_name]
@route('patch', '/patch/flow', methods=['PUT'])
def add_patch_flow(self, req, **kwargs):
LOG.debug("start add_patch_flow")
patch = self.patch_app
try:
flow = eval(req.body)
except SyntaxError:
LOG.debug('invalid syntax %s', req.body)
return Response(status=400)
result = patch.add_patch_flow(flow)
return result
@route('patch', '/patch/flow', methods=['DELETE'])
def delete_patch_flow(self, req, **kwargs):
patch = self.patch_app
try:
flow = eval(req.body)
except SyntaxError:
LOG.debug('invalid syntax %s', req.body)
return Response(status=400)
result = patch.delete_patch_flow(flow)
return result
@route('patch', '/patch/flow', methods=['GET'])
def get_patch_flows(self, req, **kwargs):
patch = self.patch_app
result = patch.get_patch_flows()
return result
@route('patch', '/patch/flow', methods=['OPTIONS'])
def opts_patch_flows(self, req, **kwargs):
cors_headers = {
'Access-Control-Allow-Origin': '*',
'Access-Control-Allow-Methods': 'PUT, GET, DELETE, OPTIONS',
'Access-Control-Allow-Headers': 'Content-Type, Origin'
}
return Response(status=200, headers=cors_headers)
| apache-2.0 | 517,307,418,234,747,600 | 36.655814 | 97 | 0.587204 | false |
RuiNascimento/krepo | script.module.lambdascrapers/lib/lambdascrapers/sources_placenta/en_placenta-1.7.8/cmovie.py | 1 | 3714 | # -*- coding: UTF-8 -*-
#######################################################################
# ----------------------------------------------------------------------------
# "THE BEER-WARE LICENSE" (Revision 42):
# @Daddy_Blamo wrote this file. As long as you retain this notice you
# can do whatever you want with this stuff. If we meet some day, and you think
# this stuff is worth it, you can buy me a beer in return. - Muad'Dib
# ----------------------------------------------------------------------------
#######################################################################
# Addon Name: Placenta
# Addon id: plugin.video.placenta
# Addon Provider: Mr.Blamo
import re,base64,json,urlparse,urllib
from resources.lib.modules import client
from resources.lib.modules import cleantitle
from resources.lib.modules import directstream
from resources.lib.modules import dom_parser2
from resources.lib.modules import cfscrape
class source:
def __init__(self):
self.priority = 1
self.language = ['en']
self.domains = ['cutemovie.net']
self.base_link = 'http://www1.cutemovie.net/'
self.movies_search_path = ('search-movies/%s.html')
self.scraper = cfscrape.create_scraper()
def movie(self, imdb, title, localtitle, aliases, year):
try:
clean_title = cleantitle.geturl(title).replace('-','+')
url = urlparse.urljoin(self.base_link, (self.movies_search_path % clean_title))
r = client.request(url)
r = dom_parser2.parse_dom(r, 'div', {'id': 'movie-featured'})
r = [dom_parser2.parse_dom(i, 'a', req=['href']) for i in r if i]
r = [(i[0].attrs['href'], re.search('Release:\s*(\d+)', i[0].content)) for i in r if i]
r = [(i[0], i[1].groups()[0]) for i in r if i[0] and i[1]]
r = [(i[0], i[1]) for i in r if i[1] == year]
if r[0]:
url = r[0][0]
return url
else: return
except Exception:
return
def tvshow(self, imdb, tvdb, tvshowtitle, localtvshowtitle, aliases, year):
return
def episode(self, url, imdb, tvdb, title, premiered, season, episode):
return
def sources(self, url, hostDict, hostprDict):
try:
sources = []
r = client.request(url)
r = dom_parser2.parse_dom(r, 'p', {'class': 'server_play'})
r = [dom_parser2.parse_dom(i, 'a', req=['href']) for i in r if i]
r = [(i[0].attrs['href'], re.search('/(\w+).html', i[0].attrs['href'])) for i in r if i]
r = [(i[0], i[1].groups()[0]) for i in r if i[0] and i[1]]
for i in r:
try:
host = i[1]
if str(host) in str(hostDict):
host = client.replaceHTMLCodes(host)
host = host.encode('utf-8')
sources.append({
'source': host,
'quality': 'SD',
'language': 'en',
'url': i[0].replace('\/','/'),
'direct': False,
'debridonly': False
})
except: pass
return sources
except Exception:
return
def resolve(self, url):
try:
r = client.request(url)
url = re.findall('document.write.+?"([^"]*)', r)[0]
url = base64.b64decode(url)
url = re.findall('src="([^"]*)', url)[0]
return url
except Exception:
return
| gpl-2.0 | 706,845,749,741,321,600 | 39.369565 | 100 | 0.462305 | false |
jemofthewest/mykoans | python3/koans/about_tuples.py | 1 | 2314 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from runner.koan import *
class AboutTuples(Koan):
def test_creating_a_tuple(self):
count_of_three = (1, 2, 5)
self.assertEqual(5, count_of_three[2])
def test_tuples_are_immutable_so_item_assignment_is_not_possible(self):
count_of_three = (1, 2, 5)
try:
count_of_three[2] = "three"
except TypeError as ex:
msg = ex.args[0]
# Note, assertRegexpMatches() uses regular expression pattern matching,
# so you don't have to copy the whole message.
self.assertRegexpMatches(msg, "'tuple' object")
def test_tuples_are_immutable_so_appending_is_not_possible(self):
count_of_three = (1, 2, 5)
with self.assertRaises(AttributeError): count_of_three.append("boom")
# Tuples are less flexible than lists, but faster.
def test_tuples_can_only_be_changed_through_replacement(self):
count_of_three = (1, 2, 5)
list_count = list(count_of_three)
list_count.append("boom")
count_of_three = tuple(list_count)
self.assertEqual((1, 2, 5, "boom"), count_of_three)
def test_tuples_of_one_look_peculiar(self):
self.assertEqual(int, (1).__class__)
self.assertEqual(tuple, (1,).__class__)
self.assertEqual(("Hello comma!",), ("Hello comma!", ))
def test_tuple_constructor_can_be_surprising(self):
self.assertEqual(('S','u','r','p','r','i','s','e','!'), tuple("Surprise!"))
def test_creating_empty_tuples(self):
self.assertEqual(tuple() , ())
self.assertEqual(() , tuple()) #Sometimes less confusing
def test_tuples_can_be_embedded(self):
lat = (37, 14, 6, 'N')
lon = (115, 48, 40, 'W')
place = ('Area 51', lat, lon)
self.assertEqual(('Area 51', (37, 14, 6, 'N'), (115, 48, 40, 'W')), place)
def test_tuples_are_good_for_representing_records(self):
locations = [
("Illuminati HQ", (38, 52, 15.56, 'N'), (77, 3, 21.46, 'W')),
("Stargate B", (41, 10, 43.92, 'N'), (1, 49, 34.29, 'W')),
]
locations.append( ("Cthulu", (26, 40, 1, 'N'), (70, 45, 7, 'W')) )
self.assertEqual('Cthulu', locations[2][0])
self.assertEqual(15.56, locations[0][1][2])
| mit | -1,628,391,265,102,596,600 | 33.029412 | 83 | 0.571305 | false |
joshwatson/binaryninja-api | python/settings.py | 1 | 18886 | # Copyright (c) 2015-2021 Vector 35 Inc
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to
# deal in the Software without restriction, including without limitation the
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
# sell copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
import ctypes
# Binary Ninja components
from binaryninja import _binaryninjacore as core
# 2-3 compatibility
from binaryninja import range
from binaryninja import pyNativeStr
from binaryninja.enums import SettingsScope
class Settings(object):
"""
:class:`Settings` provides a way to define and access settings in a hierarchical fashion. The value of a setting can \
be defined for each hierarchical level, where each level overrides the preceding level. The backing-store for setting \
values at each level is also configurable. This allows for ephemeral or platform-independent persistent settings storage \
for components within Binary Ninja or consumers of the Binary Ninja API.
Each :class:`Settings` instance has an ``instance_id`` which identifies a schema. The schema defines the settings contents \
and the way in which settings are retrieved and manipulated. A new :class:`Settings` instance defaults to using a value of *'default'* \
for the ``instance_id``. The *'default'* settings schema defines all of the settings available for the active Binary Ninja components \
which include at a minimum, the settings defined by the Binary Ninja core. The *'default'* schema may additionally define settings \
for the UI and/or installed plugins. Extending existing schemas, or defining new ones is accomplished by calling :func:`register_group` \
and :func:`register_setting` methods, or by deserializing an existing schema with :func:`deserialize_schema`.
.. note:: All settings in the *'default'* settings schema are rendered with UI elements in the Settings View of Binary Ninja UI.
Allowing setting overrides is an important feature and Binary Ninja accomplishes this by allowing one to override a setting at various \
levels. The levels and their associated storage are shown in the following table. Default setting values are optional, and if specified, \
saved in the schema itself.
================= ========================== ============== ==============================================
Setting Level Settings Scope Preference Storage
================= ========================== ============== ==============================================
Default SettingsDefaultScope Lowest Settings Schema
User SettingsUserScope - <User Directory>/settings.json
Project SettingsProjectScope - <Project Directory>/.binaryninja/settings.json
Resource SettingsResourceScope Highest Raw BinaryView (Storage in BNDB)
================= ========================== ============== ==============================================
Settings are identified by a key, which is a string in the form of **'<group>.<name>'** or **'<group>.<subGroup>.<name>'**. Groups provide \
a simple way to categorize settings. Sub-groups are optional and multiple sub-groups are allowed. When defining a settings group, the \
:func:`register_group` method allows for specifying a UI friendly title for use in the Binary Ninja UI. Defining a new setting requires a \
unique setting key and a JSON string of property, value pairs. The following table describes the available properties and values.
================== ====================================== ================= ======== =======================================================================
Property JSON Data Type Prerequisite Optional {Allowed Values} and Notes
================== ====================================== ================= ======== =======================================================================
"title" string None No Concise Setting Title
"type" string None No {"array", "boolean", "number", "string"}
"elementType" string "type" is "array" No {"string"}
"enum" array : {string} "type" is "array" Yes Enumeration definitions
"enumDescriptions" array : {string} "type" is "array" Yes Enumeration descriptions that match "enum" array
"minValue" number "type" is "number" Yes Specify 0 to infer unsigned (default is signed)
"maxValue" number "type" is "number" Yes Values less than or equal to INT_MAX infer a spinbox.
"precision" number "type" is "number" Yes Specify precision for a QDoubleSpinBox
"default" {array, boolean, number, string, null} None Yes Specify optimal default value
"aliases" array : {string} None Yes Array of deprecated setting key(s)
"description" string None No Detailed setting description
"ignore" array : {string} None Yes {"SettingsUserScope", "SettingsProjectScope", "SettingsResourceScope"}
"readOnly" boolean None Yes Only enforced by UI elements
"optional" boolean None Yes Indicates setting can be null
.. note:: In order to facilitate deterministic analysis results, settings from the *'default'* schema that impact analysis are serialized \
from Default, User, and Project scope into Resource scope during initial BinaryView analysis. This allows an analysis database to be opened \
at a later time with the same settings, regardless if Default, User, or Project settings have been modified.
.. note:: Settings that do not impact analysis (e.g. many UI settings) should use the *"ignore"* property to exclude \
*"SettingsProjectScope"* and *"SettingsResourceScope"* from the applicable scopes for the setting.
Example analysis plugin setting:
>>> my_settings = Settings()
>>> title = "My Pre-Analysis Plugin"
>>> description = "Enable extra analysis before core analysis."
>>> properties = f'{{"title" : "{title}", "description" : "{description}", "type" : "boolean", "default" : false}}'
>>> my_settings.register_group("myPlugin", "My Plugin")
True
>>> my_settings.register_setting("myPlugin.enablePreAnalysis", properties)
True
>>> my_bv = open_view("/bin/ls", options={'myPlugin.enablePreAnalysis' : True})
>>> Settings().get_bool("myPlugin.enablePreAnalysis")
False
>>> Settings().get_bool("myPlugin.enablePreAnalysis", my_bv)
True
Example UI plugin setting:
>>> my_settings = Settings()
>>> title = "My UI Plugin"
>>> description = "Enable My UI Plugin table display."
>>> properties = f'{{"title" : "{title}", "description" : "{description}", "type" : "boolean", "default" : true, "ignore" : ["SettingsProjectScope", "SettingsResourceScope"]}}'
>>> my_settings.register_group("myPlugin", "My Plugin")
True
>>> my_settings.register_setting("myPlugin.enableTableView", properties)
True
>>> my_bv = open_view("/bin/ls", options={'myPlugin.enablePreAnalysis' : True})
>>> Settings().get_bool("myPlugin.enableTableView")
True
"""
handle = core.BNCreateSettings("default")
def __init__(self, instance_id = "default", handle = None):
if handle is None:
if instance_id is None or instance_id == "":
instance_id = "default"
self._instance_id = instance_id
if instance_id == "default":
self.handle = Settings.handle
else:
self.handle = core.BNCreateSettings(instance_id)
else:
instance_id = core.BNGetUniqueIdentifierString()
self.handle = handle
def __del__(self):
if self.handle is not Settings.handle and self.handle is not None:
core.BNFreeSettings(self.handle)
def __eq__(self, other):
if not isinstance(other, self.__class__):
return NotImplemented
return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
def __ne__(self, other):
if not isinstance(other, self.__class__):
return NotImplemented
return not (self == other)
def __hash__(self):
return hash((self.instance_id, ctypes.addressof(self.handle.contents)))
@property
def instance_id(self):
"""Returns the ``instance_id`` for this :class:`Settings` repository (read-only)"""
return self._instance_id
def set_resource_id(self, resource_id = None):
"""
``set_resource_id`` Sets the resource identifier for this class:`Settings` instance. When accessing setting values at the \
``SettingsResourceScope`` level, the resource identifier is passed along through the backing store interface.
.. note:: Currently the only available backing store for ``SettingsResourceScope`` is a :class:`BinaryView` object. In the context \
of a :class:`BinaryView` the resource identifier is the :class:`BinaryViewType` name. All settings for this type of backing store \
are saved in the *'Raw'* :class:`BinaryViewType`. This enables the configuration of setting values such that they are available \
during :class:`BinaryView` creation and initialization.
:param str resource_id: a unique identifier
:rtype: None
"""
if resource_id is None:
resource_id = ""
core.BNSettingsSetResourceId(self.handle, resource_id)
def register_group(self, group, title):
"""
``register_group`` registers a group in the schema for this :class:`Settings` instance
:param str group: a unique identifier
:param str title: a user friendly name appropriate for UI presentation
:return: True on success, False on failure.
:rtype: bool
:Example:
>>> Settings().register_group("solver", "Solver")
True
>>>
"""
return core.BNSettingsRegisterGroup(self.handle, group, title)
def register_setting(self, key, properties):
"""
``register_setting`` registers a new setting with this :class:`Settings` instance
:param str key: a unique setting identifier in the form **'<group>.<name>'**
:param str properties: a JSON string describes the setting schema
:return: True on success, False on failure.
:rtype: bool
:Example:
>>> Settings().register_group("solver", "Solver")
True
>>> Settings().register_setting("solver.basicBlockSlicing", '{"description" : "Enable the basic block slicing in the solver.", "title" : "Basic Block Slicing", "default" : true, "type" : "boolean"}')
True
"""
return core.BNSettingsRegisterSetting(self.handle, key, properties)
def contains(self, key):
"""
``contains`` determine if a setting identifier exists in the active settings schema
:param str key: the setting identifier
:return: True if the identifier exists in this active settings schema, False otherwise
:rtype: bool
"""
return core.BNSettingsContains(self.handle, key)
def is_empty(self):
"""
``is_empty`` determine if the active settings schema is empty
:return: True if the active settings schema is empty, False otherwise
:rtype: bool
"""
return core.BNSettingsIsEmpty(self.handle)
def keys(self):
"""
``keys`` retrieve the list of setting identifiers in the active settings schema
:return: list of setting identifiers
:rtype: list(str)
"""
length = ctypes.c_ulonglong()
result = core.BNSettingsKeysList(self.handle, ctypes.byref(length))
out_list = []
for i in range(length.value):
out_list.append(pyNativeStr(result[i]))
core.BNFreeStringList(result, length)
return out_list
def query_property_string_list(self, key, property_name):
length = ctypes.c_ulonglong()
result = core.BNSettingsQueryPropertyStringList(self.handle, key, property_name, ctypes.byref(length))
out_list = []
for i in range(length.value):
out_list.append(pyNativeStr(result[i]))
core.BNFreeStringList(result, length)
return out_list
def update_property(self, key, setting_property):
return core.BNSettingsUpdateProperty(self.handle, key, setting_property)
def deserialize_schema(self, schema, scope = SettingsScope.SettingsAutoScope, merge = True):
return core.BNSettingsDeserializeSchema(self.handle, schema, scope, merge)
def serialize_schema(self):
return core.BNSettingsSerializeSchema(self.handle)
def deserialize_settings(self, contents, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
return core.BNDeserializeSettings(self.handle, contents, view, scope)
def serialize_settings(self, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
return core.BNSerializeSettings(self.handle, view, scope)
def reset(self, key, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
return core.BNSettingsReset(self.handle, key, view, scope)
def reset_all(self, view = None, scope = SettingsScope.SettingsAutoScope, schema_only = True):
if view is not None:
view = view.handle
return core.BNSettingsResetAll(self.handle, view, scope, schema_only)
def get_bool(self, key, view = None):
if view is not None:
view = view.handle
return core.BNSettingsGetBool(self.handle, key, view, None)
def get_double(self, key, view = None):
if view is not None:
view = view.handle
return core.BNSettingsGetDouble(self.handle, key, view, None)
def get_integer(self, key, view = None):
if view is not None:
view = view.handle
return core.BNSettingsGetUInt64(self.handle, key, view, None)
def get_string(self, key, view = None):
if view is not None:
view = view.handle
return core.BNSettingsGetString(self.handle, key, view, None)
def get_string_list(self, key, view = None):
if view is not None:
view = view.handle
length = ctypes.c_ulonglong()
result = core.BNSettingsGetStringList(self.handle, key, view, None, ctypes.byref(length))
out_list = []
for i in range(length.value):
out_list.append(pyNativeStr(result[i]))
core.BNFreeStringList(result, length)
return out_list
def get_json(self, key, view = None):
if view is not None:
view = view.handle
return core.BNSettingsGetJson(self.handle, key, view, None)
def get_bool_with_scope(self, key, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
c_scope = core.SettingsScopeEnum(scope)
result = core.BNSettingsGetBool(self.handle, key, view, ctypes.byref(c_scope))
return (result, SettingsScope(c_scope.value))
def get_double_with_scope(self, key, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
c_scope = core.SettingsScopeEnum(scope)
result = core.BNSettingsGetDouble(self.handle, key, view, ctypes.byref(c_scope))
return (result, SettingsScope(c_scope.value))
def get_integer_with_scope(self, key, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
c_scope = core.SettingsScopeEnum(scope)
result = core.BNSettingsGetUInt64(self.handle, key, view, ctypes.byref(c_scope))
return (result, SettingsScope(c_scope.value))
def get_string_with_scope(self, key, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
c_scope = core.SettingsScopeEnum(scope)
result = core.BNSettingsGetString(self.handle, key, view, ctypes.byref(c_scope))
return (result, SettingsScope(c_scope.value))
def get_string_list_with_scope(self, key, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
c_scope = core.SettingsScopeEnum(scope)
length = ctypes.c_ulonglong()
result = core.BNSettingsGetStringList(self.handle, key, view, ctypes.byref(c_scope), ctypes.byref(length))
out_list = []
for i in range(length.value):
out_list.append(pyNativeStr(result[i]))
core.BNFreeStringList(result, length)
return (out_list, SettingsScope(c_scope.value))
def get_json_with_scope(self, key, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
c_scope = core.SettingsScopeEnum(scope)
result = core.BNSettingsGetJson(self.handle, key, view, ctypes.byref(c_scope))
return (result, SettingsScope(c_scope.value))
def set_bool(self, key, value, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
return core.BNSettingsSetBool(self.handle, view, scope, key, value)
def set_double(self, key, value, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
return core.BNSettingsSetDouble(self.handle, view, scope, key, value)
def set_integer(self, key, value, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
return core.BNSettingsSetUInt64(self.handle, view, scope, key, value)
def set_string(self, key, value, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
return core.BNSettingsSetString(self.handle, view, scope, key, value)
def set_string_list(self, key, value, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
length = ctypes.c_ulonglong()
length.value = len(value)
string_list = (ctypes.c_char_p * len(value))()
for i in range(len(value)):
string_list[i] = value[i].encode('charmap')
return core.BNSettingsSetStringList(self.handle, view, scope, key, string_list, length)
def set_json(self, key, value, view = None, scope = SettingsScope.SettingsAutoScope):
if view is not None:
view = view.handle
return core.BNSettingsSetJson(self.handle, view, scope, key, value)
| mit | 2,208,039,915,937,876,000 | 46.571788 | 202 | 0.67378 | false |
pywren/pywren | fabfile.py | 1 | 11297 | #
# Copyright 2018 PyWren Team
#
# 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 fabric.api import local, env, run, put, cd, task, sudo, get, settings, warn_only, lcd
from fabric.contrib import project
import boto3
import cloudpickle
import json
import base64
from six.moves import cPickle as pickle
from pywren.wrenconfig import *
import pywren
import time
"""
conda notes
be sure to call conda clean --all before compressing
"""
env.roledefs['m'] = ['jonas@c65']
AWS_INSTANCE_NAME = "test_instance"
@task
def create_zip():
with lcd("pywren"):
local("zip ../deploy.zip *.py")
@task
def get_condaruntime():
pass
@task
def put_condaruntime():
local("scp -r c65:/data/jonas/chicken/condaruntime.tar.gz .")
#local("tar czvf condaruntime.tar.gz condaruntime")
local("aws s3 cp condaruntime.tar.gz s3://ericmjonas-public/condaruntime.tar.gz")
@task
def create_function():
lambclient = boto3.client('lambda', region_name=AWS_REGION)
lambclient.create_function(FunctionName = FUNCTION_NAME,
Handler = HANDLER_NAME,
Runtime = "python2.7",
MemorySize = MEMORY,
Timeout = TIMEOUT,
Role = ROLE,
Code = {'ZipFile' : open(PACKAGE_FILE, 'r').read()})
@task
def update_function():
lambclient = boto3.client('lambda', region_name=AWS_REGION)
response = lambclient.update_function_code(FunctionName=FUNCTION_NAME,
ZipFile=open(PACKAGE_FILE, 'r').read())
@task
def deploy():
local('git ls-tree --full-tree --name-only -r HEAD > .git-files-list')
project.rsync_project("/data/jonas/pywren/", local_dir="./",
exclude=['*.npy', "*.ipynb", 'data', "*.mp4",
"*.pdf", "*.png"],
extra_opts='--files-from=.git-files-list')
# copy the notebooks from remote to local
project.rsync_project("/data/jonas/pywren/", local_dir="./",
extra_opts="--include '*.ipynb' --include '*.pdf' --include '*.png' --include='*/' --exclude='*' ",
upload=False)
QUEUE_NAME = 'pywren-queue'
#MESSAGE_GROUP_ID = 'hello.world'
@task
def create_queue():
sqs = boto3.resource('sqs', region_name=AWS_REGION)
queue = sqs.create_queue(QueueName=QUEUE_NAME,
Attributes={'VisibilityTimeout' : "20"})
@task
def put_message(): # MessageBody="hello world"):
# Get the service resource
sqs = boto3.resource('sqs', region_name=AWS_REGION)
# Get the queue
queue = sqs.get_queue_by_name(QueueName=QUEUE_NAME)
MessageBody = "{}".format(time.time())
response = queue.send_message(MessageBody=MessageBody)
@task
def get_message(delete=False):
# Get the service resource
sqs = boto3.resource('sqs', region_name=AWS_REGION)
# Get the queue
queue = sqs.get_queue_by_name(QueueName=QUEUE_NAME)
response = queue.receive_messages()
if len(response) > 0 :
print(response[0].body)
if delete:
response[0].delete()
@task
def sqs_worker(number=1):
from multiprocessing.pool import ThreadPool, Pool
number = int(number)
sqs = boto3.resource('sqs', region_name=AWS_REGION)
# Get the queue
queue = sqs.get_queue_by_name(QueueName=QUEUE_NAME)
LOG_FILE = "sqs.log"
def process_message(m):
fid = open(LOG_FILE, 'a')
fid.write("sent {} received {}\n".format(m.body, time.time()))
m.delete()
fid.close()
pool = ThreadPool(10)
while(True):
print("reading queue" )
response = queue.receive_messages(WaitTimeSeconds=10)
if len(response) > 0:
print("Dispatching")
#pool.apply_async(
process_message(response[0])
else:
print("no message, sleeping")
time.sleep(1)
@task
def get_message(delete=False):
# Get the service resource
sqs = boto3.resource('sqs', region_name=AWS_REGION)
# Get the queue
queue = sqs.get_queue_by_name(QueueName=QUEUE_NAME)
response = queue.receive_messages()
if len(response) > 0 :
print(response[0].body)
if delete:
response[0].delete()
@task
def get_message(delete=False):
# Get the service resource
sqs = boto3.resource('sqs', region_name=AWS_REGION)
# Get the queue
queue = sqs.get_queue_by_name(QueueName=QUEUE_NAME)
@task
def sqs_purge_queue():
sqs = boto3.resource('sqs', region_name=AWS_REGION)
# Get the queue
queue = sqs.get_queue_by_name(QueueName=QUEUE_NAME)
queue.purge()
INSTANCE_PROFILE_NAME = "pywren_standalone"
@task
def create_instance_profile():
iam = boto3.resource('iam')
#iam.create_instance_profile(InstanceProfileName=INSTANCE_PROFILE_NAME)
instance_profile = iam.InstanceProfile(INSTANCE_PROFILE_NAME)
#instance_profile.add_role(RoleName='pywren_exec_role_refactor8')
print(instance_profile.name)
@task
def launch_instance():
tgt_ami = 'ami-b04e92d0'
AWS_REGION = 'us-west-2'
my_aws_key = 'ec2-us-west-2'
INSTANCE_TYPE = 'm3.xlarge'
instance_name = AWS_INSTANCE_NAME
ec2 = boto3.resource('ec2', region_name=AWS_REGION)
BlockDeviceMappings=[
{
'DeviceName': '/dev/xvda',
'Ebs': {
'VolumeSize': 100,
'DeleteOnTermination': True,
'VolumeType': 'standard',
'SnapshotId' : 'snap-c87f35ec'
},
},
]
user_data = """
#cloud-config
repo_update: true
repo_upgrade: all
packages:
- tmux
- emacs
- gcc
- g++
- git
- htop
runcmd:
- [ sh, -c, 'echo "hello world" > /tmp/hello.txt' ]
- pip install supervisor
- [ sudo, -Hu, ec2-user, sh, -c, "wget https://repo.continuum.io/miniconda/Miniconda2-latest-Linux-x86_64.sh -O /tmp/miniconda.sh"]
- [ sudo, -Hu, ec2-user, sh, -c, "chmod +x /tmp/miniconda.sh"]
- [ sudo, -Hu, ec2-user, sh, -c, "/tmp/miniconda.sh -b -p /home/ec2-user/anaconda"]
- [ sudo, -Hu, ec2-user, sh, -c, "/home/ec2-user/anaconda/bin/conda install -q -y numpy boto3"]
- [ sudo, -Hu, ec2-user, sh, -c, "git clone -b standalone-worker https://github.com/ericmjonas/pywren.git /home/ec2-user/pywren"]
- [ sudo, -Hu, ec2-user, sh, -c, "/home/ec2-user/anaconda/bin/pip install -e /home/ec2-user/pywren"]
"""
# - [
# - /home/ec2-user/anaconda/bin/conda install -q -y numpy boto3
# - git clone -b standalone-worker "https://github.com/ericmjonas/pywren.git" /home/ec2-user/pywren
# - /home/ec2-user/anaconda/bin/pip install -e
# - [ ./Miniconda2-latest-Linux-x86_64.sh -b -p /home/ec2-user/anaconda]
# - [ /home/ec2-user/anaconda/bin/conda install numpy boto3]
iam = boto3.resource('iam')
instance_profile = iam.InstanceProfile(INSTANCE_PROFILE_NAME)
instance_profile_dict = {
'Name' : instance_profile.name}
instances = ec2.create_instances(ImageId=tgt_ami, MinCount=1, MaxCount=1,
KeyName=my_aws_key,
InstanceType=INSTANCE_TYPE,
BlockDeviceMappings = BlockDeviceMappings,
InstanceInitiatedShutdownBehavior='terminate',
EbsOptimized=True,
IamInstanceProfile = instance_profile_dict,
UserData=user_data)
for inst in instances:
inst.wait_until_running()
inst.reload()
inst.create_tags(
Resources=[
inst.instance_id
],
Tags=[
{
'Key': 'Name',
'Value': instance_name
},
]
)
print(inst.public_dns_name)
def tags_to_dict(d):
return {a['Key'] : a['Value'] for a in d}
@task
def terminate_instance():
instance_name = "test_instance"
ec2 = boto3.resource('ec2', region_name=AWS_REGION)
insts = []
for i in ec2.instances.all():
if i.state['Name'] == 'running':
d = tags_to_dict(i.tags)
if d['Name'] == instance_name:
i.terminate()
insts.append(i)
@task
def delete_log_groups(prefix):
config = pywren.wrenconfig.default()
logclient = boto3.client('logs', region_name=config['account']['aws_region'])
lg = logclient.describe_log_groups(logGroupNamePrefix=prefix)
for l in lg['logGroups']:
logGroupName = l['logGroupName']
print('deleting', logGroupName)
logclient.delete_log_group(logGroupName = logGroupName)
@task
def cleanup_travis_leftovers():
"""
When travis builds fail they can leave behind IAM resources
"""
iam = boto3.resource('iam')
client = boto3.client('iam')
for p in iam.instance_profiles.all():
if 'pywren_travis_' in p.name:
print(p.name)
for r in p.roles:
p.remove_role(RoleName=r.name)
p.delete()
removed_role_count = 0
for r in iam.roles.all():
if 'pywren_travis_test_' in r.name:
for p in r.policies.all():
r.detach_policy(p)
p.delete()
r.delete()
removed_role_count += 1
print("removed {} roles".format(removed_role_count))
@task
def cleanup_leftover_buckets():
"""
Delete all buckets with pywren-travis in the name
"""
config = pywren.wrenconfig.default()
s3 = boto3.resource('s3')
client = boto3.client('s3')
for bucket in s3.buckets.all():
if 'pywren-travis-' in bucket.name:
while True:
response = client.list_objects_v2(Bucket=bucket.name,
MaxKeys=1000)
if response['KeyCount'] > 0:
keys = [c['Key'] for c in response['Contents']]
objects = [{'Key' : k} for k in keys]
print("deleting", len(keys), "keys")
client.delete_objects(Bucket=bucket.name,
Delete={'Objects' : objects})
else:
break
#for obj in bucket.objects.all():
print("deleting", bucket.name)
bucket.delete()
| apache-2.0 | -8,836,333,643,246,532,000 | 29.045213 | 136 | 0.565548 | false |
googleapis/googleapis-gen | google/cloud/dialogflow/cx/v3/dialogflow-cx-v3-py/google/cloud/dialogflowcx_v3/types/version.py | 1 | 8929 | # -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import proto # type: ignore
from google.cloud.dialogflowcx_v3.types import flow
from google.protobuf import field_mask_pb2 # type: ignore
from google.protobuf import timestamp_pb2 # type: ignore
__protobuf__ = proto.module(
package='google.cloud.dialogflow.cx.v3',
manifest={
'CreateVersionOperationMetadata',
'Version',
'ListVersionsRequest',
'ListVersionsResponse',
'GetVersionRequest',
'CreateVersionRequest',
'UpdateVersionRequest',
'DeleteVersionRequest',
'LoadVersionRequest',
},
)
class CreateVersionOperationMetadata(proto.Message):
r"""Metadata associated with the long running operation for
[Versions.CreateVersion][google.cloud.dialogflow.cx.v3.Versions.CreateVersion].
Attributes:
version (str):
Name of the created version. Format:
``projects/<Project ID>/locations/<Location ID>/agents/<Agent ID>/flows/<Flow ID>/versions/<Version ID>``.
"""
version = proto.Field(
proto.STRING,
number=1,
)
class Version(proto.Message):
r"""Represents a version of a flow.
Attributes:
name (str):
Format: projects/<Project
ID>/locations/<Location ID>/agents/<Agent
ID>/flows/<Flow ID>/versions/<Version ID>.
Version ID is a self-increasing number generated
by Dialogflow upon version creation.
display_name (str):
Required. The human-readable name of the
version. Limit of 64 characters.
description (str):
The description of the version. The maximum
length is 500 characters. If exceeded, the
request is rejected.
nlu_settings (google.cloud.dialogflowcx_v3.types.NluSettings):
Output only. The NLU settings of the flow at
version creation.
create_time (google.protobuf.timestamp_pb2.Timestamp):
Output only. Create time of the version.
state (google.cloud.dialogflowcx_v3.types.Version.State):
Output only. The state of this version. This
field is read-only and cannot be set by create
and update methods.
"""
class State(proto.Enum):
r"""The state of the version."""
STATE_UNSPECIFIED = 0
RUNNING = 1
SUCCEEDED = 2
FAILED = 3
name = proto.Field(
proto.STRING,
number=1,
)
display_name = proto.Field(
proto.STRING,
number=2,
)
description = proto.Field(
proto.STRING,
number=3,
)
nlu_settings = proto.Field(
proto.MESSAGE,
number=4,
message=flow.NluSettings,
)
create_time = proto.Field(
proto.MESSAGE,
number=5,
message=timestamp_pb2.Timestamp,
)
state = proto.Field(
proto.ENUM,
number=6,
enum=State,
)
class ListVersionsRequest(proto.Message):
r"""The request message for
[Versions.ListVersions][google.cloud.dialogflow.cx.v3.Versions.ListVersions].
Attributes:
parent (str):
Required. The [Flow][google.cloud.dialogflow.cx.v3.Flow] to
list all versions for. Format:
``projects/<Project ID>/locations/<Location ID>/agents/<Agent ID>/flows/<Flow ID>``.
page_size (int):
The maximum number of items to return in a
single page. By default 20 and at most 100.
page_token (str):
The next_page_token value returned from a previous list
request.
"""
parent = proto.Field(
proto.STRING,
number=1,
)
page_size = proto.Field(
proto.INT32,
number=2,
)
page_token = proto.Field(
proto.STRING,
number=3,
)
class ListVersionsResponse(proto.Message):
r"""The response message for
[Versions.ListVersions][google.cloud.dialogflow.cx.v3.Versions.ListVersions].
Attributes:
versions (Sequence[google.cloud.dialogflowcx_v3.types.Version]):
A list of versions. There will be a maximum number of items
returned based on the page_size field in the request. The
list may in some cases be empty or contain fewer entries
than page_size even if this isn't the last page.
next_page_token (str):
Token to retrieve the next page of results,
or empty if there are no more results in the
list.
"""
@property
def raw_page(self):
return self
versions = proto.RepeatedField(
proto.MESSAGE,
number=1,
message='Version',
)
next_page_token = proto.Field(
proto.STRING,
number=2,
)
class GetVersionRequest(proto.Message):
r"""The request message for
[Versions.GetVersion][google.cloud.dialogflow.cx.v3.Versions.GetVersion].
Attributes:
name (str):
Required. The name of the
[Version][google.cloud.dialogflow.cx.v3.Version]. Format:
``projects/<Project ID>/locations/<Location ID>/agents/<Agent ID>/flows/<Flow ID>/versions/<Version ID>``.
"""
name = proto.Field(
proto.STRING,
number=1,
)
class CreateVersionRequest(proto.Message):
r"""The request message for
[Versions.CreateVersion][google.cloud.dialogflow.cx.v3.Versions.CreateVersion].
Attributes:
parent (str):
Required. The [Flow][google.cloud.dialogflow.cx.v3.Flow] to
create an [Version][google.cloud.dialogflow.cx.v3.Version]
for. Format:
``projects/<Project ID>/locations/<Location ID>/agents/<Agent ID>/flows/<Flow ID>``.
version (google.cloud.dialogflowcx_v3.types.Version):
Required. The version to create.
"""
parent = proto.Field(
proto.STRING,
number=1,
)
version = proto.Field(
proto.MESSAGE,
number=2,
message='Version',
)
class UpdateVersionRequest(proto.Message):
r"""The request message for
[Versions.UpdateVersion][google.cloud.dialogflow.cx.v3.Versions.UpdateVersion].
Attributes:
version (google.cloud.dialogflowcx_v3.types.Version):
Required. The version to update.
update_mask (google.protobuf.field_mask_pb2.FieldMask):
Required. The mask to control which fields get updated.
Currently only ``description`` and ``display_name`` can be
updated.
"""
version = proto.Field(
proto.MESSAGE,
number=1,
message='Version',
)
update_mask = proto.Field(
proto.MESSAGE,
number=2,
message=field_mask_pb2.FieldMask,
)
class DeleteVersionRequest(proto.Message):
r"""The request message for
[Versions.DeleteVersion][google.cloud.dialogflow.cx.v3.Versions.DeleteVersion].
Attributes:
name (str):
Required. The name of the
[Version][google.cloud.dialogflow.cx.v3.Version] to delete.
Format:
``projects/<Project ID>/locations/<Location ID>/agents/<Agent ID>/flows/<Flow ID>/versions/<Version ID>``.
"""
name = proto.Field(
proto.STRING,
number=1,
)
class LoadVersionRequest(proto.Message):
r"""The request message for
[Versions.LoadVersion][google.cloud.dialogflow.cx.v3.Versions.LoadVersion].
Attributes:
name (str):
Required. The
[Version][google.cloud.dialogflow.cx.v3.Version] to be
loaded to draft flow. Format:
``projects/<Project ID>/locations/<Location ID>/agents/<Agent ID>/flows/<Flow ID>/versions/<Version ID>``.
allow_override_agent_resources (bool):
This field is used to prevent accidental overwrite of other
agent resources, which can potentially impact other flow's
behavior. If ``allow_override_agent_resources`` is false,
conflicted agent-level resources will not be overridden
(i.e. intents, entities, webhooks).
"""
name = proto.Field(
proto.STRING,
number=1,
)
allow_override_agent_resources = proto.Field(
proto.BOOL,
number=2,
)
__all__ = tuple(sorted(__protobuf__.manifest))
| apache-2.0 | 1,017,226,616,603,671,700 | 29.578767 | 118 | 0.62045 | false |
cans/tappy-pkg | tap/tracker.py | 1 | 2144 | # Copyright (c) 2015, Matt Layman
from __future__ import print_function
from collections import namedtuple
import os
TAPLine = namedtuple('TAPLine', ['status', 'description', 'directive'])
class Tracker(object):
def __init__(self, outdir=None):
self._test_cases = {}
self.outdir = outdir
if outdir and not os.path.exists(outdir):
os.makedirs(outdir)
def _track(self, class_name):
"""Keep track of which test cases have executed."""
if self._test_cases.get(class_name) is None:
self._test_cases[class_name] = []
def add_ok(self, class_name, description, directive=''):
self._track(class_name)
self._test_cases[class_name].append(
TAPLine('ok', description, directive))
def add_not_ok(self, class_name, description, directive=''):
self._track(class_name)
self._test_cases[class_name].append(
TAPLine('not ok', description, directive))
def add_skip(self, class_name, description, reason):
directive = '# SKIP {0}'.format(reason)
self.add_ok(class_name, description, directive)
def generate_tap_reports(self):
for test_case, tap_lines in self._test_cases.items():
self.generate_tap_report(test_case, tap_lines)
def generate_tap_report(self, test_case, tap_lines):
with open(self._get_tap_file_path(test_case), 'w') as f:
print('# TAP results for {0}'.format(test_case), file=f)
for line_count, tap_line in enumerate(tap_lines, start=1):
result = ' '.join([
tap_line.status,
str(line_count),
'-',
tap_line.description,
tap_line.directive,
])
print(result, file=f)
print('1..{0}'.format(len(tap_lines)), file=f)
def _get_tap_file_path(self, test_case):
"""Get the TAP output file path for the test case."""
tap_file = test_case + '.tap'
if self.outdir:
return os.path.join(self.outdir, tap_file)
return tap_file
| bsd-2-clause | 9,054,455,438,370,134,000 | 33.580645 | 71 | 0.573694 | false |
quantopian/qdb | qdb/comm.py | 1 | 34207 | #
# Copyright 2015 Quantopian, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function
from abc import ABCMeta, abstractmethod
import atexit
from bdb import Breakpoint
import errno
from functools import partial
import json
import os
from pprint import pprint
import signal
import socket
from struct import pack, unpack
from textwrap import dedent
from logbook import Logger
from qdb.compat import (
Connection,
PY3,
gevent,
input,
items,
print_,
range,
with_metaclass,
)
from qdb.errors import (
QdbAuthenticationError,
QdbBreakpointReadError,
QdbCommunicationError,
QdbFailedToConnect,
QdbReceivedInvalidData,
QdbUnreachableBreakpoint,
)
from qdb.utils import Timeout, tco
log = Logger('Qdb')
def fmt_msg(event, payload=None, serial=None):
"""
Packs a message to be sent to the server.
Serial is a function to call on the frame to serialize it, e.g:
json.dumps.
"""
frame = {
'e': event,
'p': payload,
}
return serial(frame) if serial else frame
def fmt_err_msg(error_type, data, serial=None):
"""
Constructs an error message.
"""
return fmt_msg(
'error', {
'type': error_type,
'data': data,
},
serial=serial,
)
def fmt_breakpoint(breakpoint):
"""
formats breakpoint payload.
"""
return {
'file': breakpoint.file,
'line': breakpoint.line,
'temp': breakpoint.temporary,
'cond': breakpoint.cond,
'func': breakpoint.funcname,
}
class CommandManager(with_metaclass(ABCMeta, object)):
"""
An abstract base class for the command managers that control the tracer.
"""
def _fmt_stackframe(self, tracer, stackframe, line):
"""
Formats stackframe payload data.
"""
filename = stackframe.f_code.co_filename
func = stackframe.f_code.co_name
code = tracer.get_line(filename, line)
return {
'file': tracer.canonic(filename),
'line': line,
'func': func,
'code': code,
}
def send_disabled(self):
"""
Sends a message to the server to say that the tracer is done.
"""
try:
self.send_event('disabled')
except socket.error:
# We may safely ignore errors that occur here because we are
# already disabled.
pass
def send_breakpoints(self):
"""
Sends the breakpoint list event.
"""
self.send_event(
'breakpoints',
[fmt_breakpoint(breakpoint) for breakpoint in Breakpoint.bpbynumber
if breakpoint]
)
def send_watchlist(self, tracer):
"""
Sends the watchlist event.
"""
self.send_event(
'watchlist',
[{'expr': k, 'exc': exc, 'value': val}
for k, (exc, val) in items(tracer.watchlist)],
)
def send_print(self, input_, exc, output):
"""
Sends the print event with the given input and output.
"""
self.send(fmt_msg(
'print', {
'input': input_,
'exc': exc,
'output': output
},
serial=json.dumps)
)
def send_stack(self, tracer):
"""
Sends the stack event.
This filters out frames based on the rules defined in the tracer's
skip_fn. The index reported will account for any skipped frames, such
that querying the stack at the index provided will return the current
frame.
"""
stack = []
index = tracer.curindex
skip_fn = tracer.skip_fn
for n, (frame, line) in enumerate(tracer.stack):
if skip_fn(frame.f_code.co_filename):
if n < tracer.curindex:
index -= 1 # Drop the index to account for a skip
continue # Don't add frames we need to skip.
stack.append(self._fmt_stackframe(tracer, frame, line))
self.send_event(
'stack', {
'index': index,
'stack': stack,
}
)
def send_error(self, error_type, error_data):
"""
Sends a formatted error message.
"""
self.send(fmt_err_msg(error_type, error_data, serial=json.dumps))
def send_event(self, event, payload=None):
"""
Sends a formatted event.
"""
self.send(fmt_msg(event, payload, serial=json.dumps))
@tco
def next_command(self, tracer, msg=None):
"""
Processes the next command from the user.
If msg is given, it is sent with self.send(msg) before processing the
next command.
"""
if msg:
self.send(msg)
return self.user_next_command(tracer)
@abstractmethod
def send(self, msg):
"""
Sends a raw (already jsond) message.
"""
raise NotImplementedError
@abstractmethod
def user_next_command(self, tracer):
"""
Processes the next command.
This method must be overridden to dictate how the commands are
processed.
"""
raise NotImplementedError
@abstractmethod
def start(self, tracer, auth_msg=''):
"""
Start acquiring new commands.
"""
raise NotImplementedError
def stop(self):
"""
Stop acquiring new commands.
"""
self.send_disabled()
self.user_stop()
@abstractmethod
def user_stop(self):
"""
Use this to release and resources needed to generate the commands.
"""
raise NotImplementedError
class NopCommandManager(CommandManager):
"""
Nop command manager that never alters the state of the debugger.
This is useful if you want to manage the debugger in an alternate way.
"""
def user_next_command(self, tracer):
pass
def send(self, msg):
pass
def start(self, tracer, msg):
pass
def user_stop(self):
pass
class RemoteCommandManager(CommandManager):
"""
Manager that processes commands from the server.
This is the default Qdb command manager.
"""
def __init__(self):
super(RemoteCommandManager, self).__init__()
if gevent is not None:
import gipc # Only use gipc if we are running in gevent.
self._pipe = gipc.pipe
self._start_process = gipc.start_process
else:
import multiprocessing
def _pipe(*args, **kwargs):
a, b = multiprocessing.Pipe(*args, **kwargs)
return Connection(a), Connection(b)
self._pipe = _pipe
def _start_process(*args, **kwargs):
proc = multiprocessing.Process(*args, **kwargs)
proc.start()
return proc
self._start_process = _start_process
self.pipe = None
self.socket = None
self.reader = None
def _socket_connect(self, tracer):
"""
Connects to the socket or raise a QdbFailedToConnect error.
"""
log.info('Connecting to (%s, %d)' % tracer.address)
for n in range(tracer.retry_attempts):
# Try to connect to the server.
try:
self.socket = socket.create_connection(tracer.address)
# If we made it here, we connected and no longer need to retry.
break
except socket.error:
log.warn(
'Client %s failed to connect to (%s, %d) on attempt %d...'
% (tracer.uuid, tracer.address[0],
tracer.address[1], n + 1)
)
if self.socket is None:
log.warn(
'Failed to connect to (%s, %d), no longer retying.'
% tracer.address
)
raise QdbFailedToConnect(
tracer.address,
tracer.retry_attempts
)
log.info('Client %s connected to (%s, %d)'
% (tracer.uuid, tracer.address[0],
tracer.address[1]))
def start(self, tracer, auth_msg=''):
"""
Begins processing commands from the server.
"""
self.pipe, child_end = self._pipe()
self._socket_connect(tracer)
self.reader = self._start_process(
target=ServerReader,
args=(child_end, os.getpid(),
self.socket.fileno(),
tracer.pause_signal),
)
with Timeout(5, QdbFailedToConnect(tracer.address,
tracer.retry_attempts)):
# Receive a message to know that the reader is ready to begin.
while True:
try:
self.pipe.get()
break
except IOError as e:
# EAGAIN says to try the syscall again.
if e.errno != errno.EAGAIN:
raise
self.send(
fmt_msg(
'start', {
'uuid': tracer.uuid,
'auth': auth_msg,
'local': (0, 0),
},
serial=json.dumps,
)
)
signal.signal(
tracer.pause_signal, partial(self._pause_handler, tracer)
)
atexit.register(self.stop)
def user_stop(self):
"""
Stops the command manager, freeing its resources.
"""
if self.reader and self.reader.is_alive():
self.reader.terminate()
self.socket.close()
def fmt_breakpoint_dict(self, tracer, breakpoint):
"""
Makes our protocol for breakpoints match the Bdb protocol.
"""
if 'file' not in breakpoint and tracer.default_file:
breakpoint['file'] = tracer.default_file
if 'file' in breakpoint and 'line' in breakpoint:
# Do some formatting here to make the params cleaner.
breakpoint['filename'] = breakpoint.pop('file')
breakpoint['lineno'] = breakpoint.pop('line')
breakpoint['temporary'] = breakpoint.pop('temp', None)
breakpoint['funcname'] = breakpoint.pop('func', None)
breakpoint.setdefault('cond', None)
return breakpoint
raise QdbBreakpointReadError(breakpoint)
def send(self, msg):
"""
Sends a message to the server.
"""
self.socket.sendall(pack('>i', len(msg)))
self.socket.sendall(msg.encode('utf-8'))
def payload_check(self, payload, command):
"""
Asserts that payload is not None, sending an error message if it is.
returns False if payload is None, otherwise returns True.
"""
if payload is None:
self.send_error('payload', '%s: expected payload' % command)
return False
return True
def _pause_handler(self, tracer, signum, stackframe):
"""
Manager for the pause command.
"""
if signum == tracer.pause_signal:
tracer.set_step()
def get_events(self):
"""
Infinitely yield events from the Reader.
"""
while self.reader.is_alive():
try:
event = self.pipe.get()
except IOError as i:
if i.errno == errno.EAGAIN:
continue
raise
yield event
def get_commands(self, tracer):
"""
Yields the commands out of the events.
"""
for event in self.get_events():
if event['e'] == 'error':
self.handle_error(event.get('p'))
else:
command = getattr(self, 'command_' + event['e'], None)
if not command:
self.send_error('event', 'Command %s does not exist'
% event['e'])
else:
yield lambda: command(tracer, event.get('p'))
def handle_error(self, payload):
if payload['type'] == 'auth':
raise QdbAuthenticationError(payload['data'])
else:
raise QdbCommunicationError(payload)
def user_next_command(self, tracer, msg=None):
"""
Processes the next message from the reader.
"""
try:
return next(self.get_commands(tracer))()
except StopIteration:
raise QdbCommunicationError('No more commands from server')
def command_step(self, tracer, payload):
tracer.set_step()
def command_return(self, tracer, payload):
tracer.set_return(tracer.curframe)
def command_next(self, tracer, payload):
tracer.set_next(tracer.curframe)
def command_until(self, tracer, payload):
tracer.set_until(tracer.curframe)
def command_continue(self, tracer, payload):
tracer.set_continue()
def command_pprint(self, tracer, payload):
"""
Evaluates the expression with the pretty printer.
"""
return self.command_eval(tracer, payload, pprint=True)
def command_eval(self, tracer, payload, pprint=False):
"""
Evaluates and expression in tracer.curframe, reevaluates the
watchlist, and defers to user control.
"""
if not self.payload_check(payload, 'eval'):
return self.next_command.tailcall(tracer)
tracer.eval_(payload, pprint)
self.send_watchlist(tracer)
return self.next_command.tailcall(tracer)
def command_set_watch(self, tracer, payload):
"""
Extends the watchlist and defers to user control.
"""
if not self.payload_check(payload, 'set_watch'):
return self.next_command.tailcall(tracer)
tracer.extend_watchlist(*payload)
self.send_watchlist(tracer)
return self.next_command.tailcall(tracer)
def command_clear_watch(self, tracer, payload):
"""
Clears expressions from the watchlist and defers to user control.
"""
if not self.payload_check(payload, 'clear_watch'):
return self.next_command.tailcall(tracer)
for w in payload:
# Default to None so that clearing values that have not been set
# acts as a nop instead of an error.
tracer.watchlist.pop(w, None)
self.send_watchlist(tracer)
return self.next_command.tailcall(tracer)
def command_set_break(self, tracer, payload):
"""
Sets a breakpoint and defers to user control.
"""
if not self.payload_check(payload, 'set_break'):
return self.next_command.tailcall(tracer)
try:
breakpoint = self.fmt_breakpoint_dict(tracer, payload)
except QdbBreakpointReadError as b:
err_msg = fmt_err_msg('set_break', str(b), serial=json.dumps)
return self.next_command.tailcall(tracer, err_msg)
err_msg = None
try:
tracer.set_break(**breakpoint)
except QdbUnreachableBreakpoint as u:
err_msg = fmt_err_msg(
'set_breakpoint',
str(u),
serial=json.dumps
)
return self.next_command.tailcall(tracer, err_msg)
def command_clear_break(self, tracer, payload):
"""
Clears a breakpoint and defers to user control.
"""
if not self.payload_check(payload, 'clear_break'):
return self.next_command.tailcall(tracer)
try:
breakpoint = self.fmt_breakpoint_dict(tracer, payload)
except QdbBreakpointReadError as b:
err_msg = fmt_err_msg('clear_break', str(b), serial=json.dumps)
return self.next_command.tailcall(tracer, err_msg)
tracer.clear_break(**breakpoint)
return self.next_command.tailcall(tracer)
def command_list(self, tracer, payload):
"""
List the contents of a file and defer to user control.
"""
if not self.payload_check(payload, 'list'):
return self.next_command.tailcall(tracer)
filename = payload.get('file') or tracer.default_file
try:
if tracer.skip_fn(filename):
raise KeyError # Handled the same, avoids duplication.
if not (payload.get('start') or payload.get('end')):
msg = fmt_msg(
'list',
tracer.get_file(payload['file']),
serial=json.dumps
)
else:
# Send back the slice of the file that they requested.
msg = fmt_msg(
'list',
'\n'.join(
tracer.get_file_lines(tracer.canonic(filename))[
int(payload.get('start')):int(payload.get('end'))
]
),
serial=json.dumps
)
except KeyError: # The file failed to be cached.
msg = fmt_err_msg(
'list',
'File %s does not exist' % payload['file'],
serial=json.dumps
)
except TypeError:
# This occurs when we fail to convert the 'start' or 'stop' fields
# to integers.
msg = fmt_err_msg(
'list',
'List slice arguments must be convertable to type int',
serial=json.dumps
)
return self.next_command.tailcall(msg)
def command_up(self, tracer, payload):
"""
Step up the stack and defer to user control.
This will 'ignore' frames that we should skip, potentially going up
more than one stackframe.
"""
try:
tracer.stack_shift_direction(+1)
except IndexError:
self.send_error('up', 'Oldest frame')
self.send_watchlist(tracer)
self.send_stack(tracer)
return self.next_command.tailcall(tracer)
def command_down(self, tracer, payload):
"""
Step down the stack and defer to user control
This will 'ignore' frames that we should skip, potentially going down
more than one stackframe.
"""
try:
tracer.stack_shift_direction(-1)
except IndexError:
self.send_error('down', 'Newest frame')
self.send_watchlist(tracer)
self.send_stack(tracer)
return self.next_command.tailcall(tracer)
def command_locals(self, tracer, payload):
"""
Sends back the current frame locals and defer to user control.
"""
self.send_event('locals', tracer.curframe_locals)
return self.next_command.tailcall(tracer)
def command_start(self, tracer, payload):
"""
Sends back initial information and defers to user control.
"""
self.send_breakpoints()
self.send_watchlist(tracer)
self.send_stack(tracer)
return self.next_command.tailcall(tracer)
def command_disable(self, tracer, payload):
"""
Disables the tracer.
"""
if not self.payload_check(payload, 'disable'):
return self.next_command.tailcall(tracer)
if payload not in ['soft', 'hard']:
err_msg = fmt_err_msg(
'disable',
"payload must be either 'soft' or 'hard'",
serial=json.dumps
)
return self.next_command.tailcall(err_msg)
tracer.disable(payload)
def get_events_from_socket(sck):
"""
Yields valid events from the server socket.
"""
while True:
try:
sck.setblocking(True)
resp = bytearray(4)
if sck.recv_into(resp, 4) != 4:
raise QdbReceivedInvalidData(resp)
rlen = unpack('>i', resp)[0]
resp = bytearray(rlen)
sck.settimeout(1)
if sck.recv_into(resp, rlen) != rlen:
raise QdbReceivedInvalidData(resp)
if PY3:
resp = resp.decode('utf-8')
else:
resp = bytes(resp)
cmd = json.loads(resp)
if cmd['e'] == 'disabled':
# We are done tracing.
return
except KeyError:
log.warn('Client sent invalid cmd.')
yield fmt_err_msg('event', "No 'e' field sent")
return
except Exception as e:
# We can no longer talk to the server.
log.warn('Exception raised reading from socket')
yield fmt_err_msg('socket', str(e))
return
else:
# Yields only valid commands.
yield cmd
class ServerReader(object):
"""
Object that reads from the server asynchronously from the process
being debugged.
"""
def __init__(self, debugger_pipe, session_pid, server_comm_fd,
pause_signal):
self.pause_signal = pause_signal or signal.SIGUSR2
self.debugger_pipe = debugger_pipe
self.server_comm = socket.fromfd(server_comm_fd, 0, 0)
self.session_pid = session_pid
self.socket_error = None
self.process_messages()
def command_pause(self):
"""
Manages the pause command by raising a user defined signal in the
session process which will be caught by the command manager.
"""
os.kill(self.session_pid, self.pause_signal)
def process_messages(self):
"""
Infinitely reads events off the server. If it is a pause, then it
pauses the process; otherwise, it passes the message along.
"""
# Send a message to alert the tracer that we are ready to begin reading
# messages.
self.debugger_pipe.put(fmt_msg('reader_started'))
try:
for event in get_events_from_socket(self.server_comm):
if event['e'] == 'pause':
self.command_pause()
else:
self.debugger_pipe.put(event)
# If we get here, we had a socket error that dropped us
# out of get_events(), signal this to the process.
self.debugger_pipe.put(fmt_msg('disable', 'soft'))
finally:
log.info('ServerReader terminating')
class ServerLocalCommandManager(RemoteCommandManager):
"""
Use this command manager if you know for certain that the tracer will be
running on the same machine as the server. This circumvents the need for
spinning up the Reader process and lets the server take over some of that
responsibility. While using a normal RemoteCommandManager will work, this
incurs less overhead.
"""
def start(self, tracer, auth_msg=''):
"""
Begins processing commands from the server.
"""
self._socket_connect(tracer)
self.send(
fmt_msg(
'start', {
'uuid': tracer.uuid,
'auth': auth_msg,
'local': (os.getpid(), tracer.pause_signal),
},
serial=json.dumps,
)
)
def user_stop(self):
self.socket.close()
def get_events(self):
return get_events_from_socket(self.socket)
class TerminalCommandManager(CommandManager):
def __init__(self):
super(TerminalCommandManager, self).__init__()
self._sticky = True
self._redraw = True
# Side effectful imports ;_;
import rlcompleter # NOQA
import readline
self.readline = readline
readline.parse_and_bind("tab: complete")
def pprint(self, msg):
pprint(msg)
def send(self, event):
event = json.loads(event)
evfn = getattr(self, 'event_' + event['e'], None)
if not evfn:
self.unknown_event(event['e'])
else:
evfn(event.get('p'))
def writeln(self, msg=''):
print_(msg)
def writeerr(self, msg=''):
self.writeln('*** error: ' + msg)
def missing_argument(self, cmd):
self.writeerr('{cmd}: missing argument(s)'.format(cmd=cmd))
def unknown_event(self, e):
self.writeerr('{0}: unknown event type'.format(e))
def event_print(self, payload):
out = payload['output']
if out:
self.writeln(
'%s%s' % ('*** error: ' if payload['exc'] else '', out),
)
def event_stack(self, payload):
frame = payload['stack'][payload['index']] # Current frame
self.writeln('> {file}:{line}'.format(**frame))
if not self._sticky:
self.writeln('--> ' + frame['code'])
def event_watchlist(self, payload):
self.writeln('watchlist: [')
for watched in payload:
self.writeln(
' > %s%s: %s'
% ('*** error: ' if watched['exc'] else '',
watched['expr'], watched['value'])
)
self.writeln(']')
def event_exception(self, payload):
self.writeln('--* %s:%s' % (payload['type'], payload['value']))
def event_breakpoints(self, payload):
self.writeln('breakpoints: [')
for breakpoint in payload:
self.writeln(
' > {file} {line} {temp} {cond} {func}'.format(**breakpoint),
)
self.writeln(']')
def event_error(self, payload):
self.writeerr('{0}: {1}'.format(payload['type'], payload['data']))
def event_return(self, payload):
self.writeln('---> returning with %s' % payload)
def event_disabled(self, payload):
self.writeln()
def start(self, tracer, auth_msg=''):
pass
def user_stop(self):
pass
def prompt_user(self):
inp = input('(qdb) ').split(None, 1)
if not inp:
rl = self.readline
inp = rl.get_history_item(rl.get_current_history_length())
return inp
def user_next_command(self, tracer):
if self._sticky and self._redraw:
self.do_list(None, tracer, recurse=False)
self._redraw = False
try:
while True:
try:
inp = self.prompt_user()
while not inp:
inp = self.prompt_user()
break
except KeyboardInterrupt:
self.writeln()
except EOFError:
inp = ('quit',)
cmd = inp[0]
if cmd.endswith('?') and hasattr(self, 'do_' + cmd[:-1]):
self.writeln(dedent(getattr(self, 'do_' + cmd[:-1]).__doc__))
return self.user_next_command(tracer)
command = getattr(self, 'do_' + cmd, None)
if command is None:
return self.do_print(' '.join(inp), tracer)
else:
try:
arg = inp[1]
except IndexError:
arg = None
return command(arg, tracer)
def do_print(self, arg, tracer):
"""
p(rint)
Print the following expression
"""
tracer.eval_(arg)
return self.next_command.tailcall(tracer)
do_p = do_print
def do_step(self, arg, tracer):
"""
s(tep)
Execute the next line, function call, or return.
"""
self._redraw = True
tracer.set_step()
do_s = do_step
def do_return(self, arg, tracer):
"""
r(eturn)
Execute until the return event for the current stackframe.
"""
self._redraw = True
tracer.set_return(tracer.curframe)
do_r = do_return
def do_next(self, arg, tracer):
"""
n(ext)
Execute up to the next line in the current frame.
"""
self._redraw = True
tracer.set_next(tracer.curframe)
do_n = do_next
def do_until(self, arg, tracer):
"""
unt(il)
Execute until the line greater than the current is hit or until
you return from the current frame.
"""
self._redraw = True
tracer.set_until(tracer.curframe)
do_unt = do_until
def do_continue(self, arg, tracer):
"""
c(ontinue)
Continue execution until the next breakpoint is hit. If there are
no more breakpoints, stop tracing.
"""
self._redraw = True
tracer.set_continue()
do_c = do_continue
def do_watch(self, arg, tracer):
"""
w(atch) EXPR
Adds an expression to the watchlist.
"""
if not arg:
return self.missing_argument('w(atch)')
tracer.extend_watchlist((arg,))
return self.next_command.tailcall(tracer)
do_w = do_watch
def do_unwatch(self, arg, tracer):
"""
unw(atch) EXPR
Removes an expression from the watchlist if it is already being
watched, otherwise does nothing.
"""
if not arg:
return self.missing_argument('unw(atch)')
tracer.watchlist.pop(arg, None)
return self.next_command.tailcall(tracer)
do_unw = do_unwatch
def do_break(self, arg, tracer, temp=False):
"""
b(reak) BREAK-DICT
Adds a breakpoint with the form:
{'file': str, 'line': int, 'temp': bool, 'cond': str, 'func': str}
"""
if not arg:
self.missing_argument('b(reak)')
return
break_arg = self.parse_break_arg(arg, temp)
if break_arg:
tracer.set_break(**break_arg)
return self.next_command.tailcall(tracer)
do_b = do_break
def do_clear(self, arg, tracer):
"""
cl(ear) BREAK-DICT
Clears a breakpoint with the form:
{'file': str, 'line': int, 'temp': bool, 'cond': str, 'func': str}
Only 'file' and 'line' are needed.
"""
if not arg:
self.missing_argument('cl(ear)')
return
break_arg = self.parse_break_arg(arg)
if break_arg:
tracer.clear_break(**break_arg)
return self.next_command.tailcall(tracer)
do_cl = do_clear
def do_tbreak(self, arg, tracer):
"""
tbreak BREAK-DICT
Same as break, but with 'temp' defaulted to True.
"""
return self.do_break(arg, tracer, temp=True)
def do_list(self, arg, tracer, recurse=True):
"""
l(ist) FILE [START, [END]]
Shows the content of a file where START is the first line to show
and END is the last. This acts like a Python slice.
"""
start = end = None
try:
start, end = map(int, arg.split() if arg else ())
except (TypeError, ValueError):
pass
curline = tracer.curframe.f_lineno
if start is None and end is None and arg != ':':
start = curline - 5
if start < 0:
start = 0
end = curline + 5
def prepend(ix_l):
return (
'%s ' % ('-->' if ix_l[0] == curline else ' ')
) + ix_l[1]
self.writeln(
'\n'.join(
map(
prepend,
enumerate(
tracer.get_file_lines(
tracer.curframe.f_code.co_filename,
)[start:end],
1 if start is None else start + 1,
)
)
),
)
if recurse:
return self.next_command.tailcall(tracer)
do_l = do_list
def do_up(self, arg, tracer):
"""
u(p)
Steps up a stackframe if possible.
"""
try:
tracer.stack_shift_direction(+1)
except IndexError:
self.writeerr('up: top of stack')
else:
self.do_list(None, tracer, recurse=False)
return self.next_command.tailcall(tracer)
do_u = do_up
def do_down(self, arg, tracer):
"""
d(own)
Steps down a stackframe if possible.
"""
try:
tracer.stack_shift_direction(-1)
except IndexError:
self.writeerr('down: bottom of stack')
else:
self.do_list(None, tracer, recurse=False)
return self.next_command.tailcall(tracer)
do_d = do_down
def do_locals(self, arg, tracer):
"""
locals
Report back the current stackframe's locals.
"""
self.writeln('locals: [')
for p in items(tracer.curframe_locals):
self.writeln(' %s=%s' % p)
self.writeln(']')
return self.next_command.tailcall(tracer)
def do_quit(self, arg, tracer):
"""
q(uit) [MODE]
Stops the debugging session with the given mode, defaulting to
'soft'.
"""
if not arg or arg in ('soft', 'hard'):
tracer.disable(arg or 'hard')
else:
self.writeerr("disable: argument must be 'soft' or 'hard'")
def do_sticky(self, arg, tracer):
"""
sticky
Toggle sticky mode; printing the current context after every step.
"""
self._sticky = not self._sticky
if self._sticky:
return self.do_list(None, tracer)
return self.next_command.tailcall(tracer)
| apache-2.0 | -142,132,856,372,043,680 | 29.541964 | 79 | 0.540679 | false |
FrodeSolheim/fs-uae-launcher | fsgamesys/input/dinputkeycodes.py | 1 | 6071 | """
from dinput.h
"""
dinput_key_codes = {
"BACKSPACE": 0x0E,
"TAB": 0x0F,
"CLEAR": 0, # FIXME
"RETURN": 0x1C,
"PAUSE": 0, # FIXME
"ESCAPE": 0x01,
"SPACE": 0x39,
"EXCLAIM": 0, # FIXME
"QUOTEDBL": 0, # FIXME
"HASH": 0, # FIXME
"DOLLAR": 0, # FIXME
"AMPERSAND": 0, # FIXME
"QUOTE": 0x28,
"LEFTPAREN": 0, # FIXME
"RIGHTPAREN": 0, # FIXME
"ASTERISK": 0, # FIXME
"PLUS": 0, # FIXME
"COMMA": 0x33,
"MINUS": 0x0C,
"PERIOD": 0x34,
"SLASH": 0x35,
"0": 0x0B,
"1": 0x02,
"2": 0x03,
"3": 0x04,
"4": 0x05,
"5": 0x06,
"6": 0x07,
"7": 0x08,
"8": 0x09,
"9": 0x0A,
"COLON": 0x92,
"SEMICOLON": 0x27,
"LESS": 0, # FIXME
"EQUALS": 0x0D,
"GREATER": 0, # FIXME
"QUESTION": 0, # FIXME
"AT": 0x91,
"LEFTBRACKET": 0x1A,
"BACKSLASH": 0x2B,
"RIGHTBRACKET": 0x1B,
"CARET": 0, # FIXME
"UNDERSCORE": 0x93,
"BACKQUOTE": 0, # FIXME
"A": 0x1E,
"B": 0x30,
"C": 0x2E,
"D": 0x20,
"E": 0x12,
"F": 0x21,
"G": 0x22,
"H": 0x23,
"I": 0x17,
"J": 0x24,
"K": 0x25,
"L": 0x26,
"M": 0x32,
"N": 0x31,
"O": 0x18,
"P": 0x19,
"Q": 0x10,
"R": 0x13,
"S": 0x1F,
"T": 0x14,
"U": 0x16,
"V": 0x2F,
"W": 0x11,
"X": 0x2D,
"Y": 0x15,
"Z": 0x2C,
"DELETE": 0xD3,
"KP0": 0x52,
"KP1": 0x4F,
"KP2": 0x50,
"KP3": 0x51,
"KP4": 0x4B,
"KP5": 0x4C,
"KP6": 0x4D,
"KP7": 0x47,
"KP8": 0x48,
"KP9": 0x49,
"KP_PERIOD": 0x53,
"KP_DIVIDE": 0xB5,
"KP_MULTIPLY": 0x37,
"KP_MINUS": 0x4A,
"KP_PLUS": 0x4E,
"KP_ENTER": 0x9C,
"KP_EQUALS": 0x8D,
"UP": 0xC8,
"DOWN": 0xD0,
"RIGHT": 0xCD,
"LEFT": 0xCB,
"INSERT": 0xD2,
"HOME": 0xC7,
"END": 0xCF,
"PAGEUP": 0xC9,
"PAGEDOWN": 0xD1,
"F1": 0x3B,
"F2": 0x3C,
"F3": 0x3D,
"F4": 0x3E,
"F5": 0x3F,
"F6": 0x40,
"F7": 0x41,
"F8": 0x42,
"F9": 0x43,
"F10": 0x44,
"F11": 0x57,
"F12": 0x58,
"F13": 0x64,
"F14": 0x65,
"F15": 0x66,
"NUMLOCK": 0x45,
"CAPSLOCK": 0x3A,
"SCROLLOCK": 0x46,
"RSHIFT": 0x36,
"LSHIFT": 0x2A,
"RCTRL": 0x9D,
"LCTRL": 0x1D,
"RALT": 0xB8,
"LALT": 0x38,
"RMETA": 0, # FIXME
"LMETA": 0, # FIXME
"LSUPER": 0xDB,
"RSUPER": 0xDC,
"MODE": 0, # FIXME
"COMPOSE": 0, # FIXME
"HELP": 0, # FIXME
"PRINT": 0, # FIXME
"SYSREQ": 0xB7,
"BREAK": 0, # FIXME
"MENU": 0, # FIXME
"POWER": 0, # FIXME
"EURO": 0, # FIXME
"UNDO": 0, # FIXME
}
sdlk_to_dik = {
"ESCAPE": "ESCAPE",
"1": "1",
"2": "2",
"3": "3",
"4": "4",
"5": "5",
"6": "6",
"7": "7",
"8": "8",
"9": "9",
"0": "0",
"MINUS": "MINUS",
"EQUALS": "EQUALS",
"BACKSPACE": "BACK",
"TAB": "TAB",
"Q": "Q",
"W": "W",
"E": "E",
"R": "R",
"T": "T",
"Y": "Y",
"U": "U",
"I": "I",
"O": "O",
"P": "P",
"LEFTBRACKET": "LBRACKET",
"RIGHTBRACKET": "RBRACKET",
"RETURN": "RETURN",
"LCTRL": "LCONTROL",
"A": "A",
"S": "S",
"D": "D",
"F": "F",
"G": "G",
"H": "H",
"J": "J",
"K": "K",
"L": "L",
"SEMICOLON": "SEMICOLON",
"QUOTE": "APOSTROPHE",
"BACKQUOTE": "GRAVE",
"LSHIFT": "LSHIFT",
"BACKSLASH": "BACKSLASH",
"Z": "Z",
"X": "X",
"C": "C",
"V": "V",
"B": "B",
"N": "N",
"M": "M",
"COMMA": "COMMA",
"PERIOD": "PERIOD",
"SLASH": "SLASH",
"RSHIFT": "RSHIFT",
"KP_MULTIPLY": "MULTIPLY",
"LALT": "LMENU",
"SPACE": "SPACE",
"CAPSLOCK": "CAPITAL",
"F1": "F1",
"F2": "F2",
"F3": "F3",
"F4": "F4",
"F5": "F5",
"F6": "F6",
"F7": "F7",
"F8": "F8",
"F9": "F9",
"F10": "F10",
"NUMLOCK": "NUMLOCK",
"SCROLLOCK": "SCROLL",
"KP7": "NUMPAD7",
"KP8": "NUMPAD8",
"KP9": "NUMPAD9",
"KP_MINUS": "SUBTRACT",
"KP4": "NUMPAD4",
"KP5": "NUMPAD5",
"KP6": "NUMPAD6",
"KP_PLUS": "ADD",
"KP1": "NUMPAD1",
"KP2": "NUMPAD2",
"KP3": "NUMPAD3",
"KP0": "NUMPAD0",
"KP_PERIOD": "DECIMAL",
"F11": "F11",
"F12": "F12",
"F13": "F13",
"F14": "F14",
"F15": "F15",
# "": "KANA",
# "": "CONVERT",
# "": "NOCONVERT",
# "": "YEN",
# "": "NUMPADEQUALS",
# "": "CIRCUMFLEX",
"AT": "AT",
"COLON": "COLON",
# "": "UNDERLINE",
# "": "KANJI",
# "": "STOP",
# "": "AX",
# "": "UNLABELED",
"KP_ENTER": "NUMPADENTER",
"RCTRL": "RCONTROL",
# "": "NUMPADCOMMA",
"KP_DIVIDE": "DIVIDE",
"SYSREQ": "SYSRQ",
"RALT": "RMENU",
"HOME": "HOME",
"UP": "UP",
"PAGEUP": "PRIOR",
"LEFT": "LEFT",
"RIGHT": "RIGHT",
"END": "END",
"DOWN": "DOWN",
"PAGEDOWN": "NEXT",
"INSERT": "INSERT",
"DELETE": "DELETE",
"LSUPER": "LWIN",
"RSUPER": "RWIN",
# "": "APPS",
}
# "BACKSPACE": "BACKSPACE DIK_BACK /* backspace */
# "KP_MULTIPLY": "NUMPADSTAR DIK_MULTIPLY /* * on numeric keypad */
# "": "LALT DIK_LMENU /* left Alt */
# "": "CAPSLOCK DIK_CAPITAL /* CapsLock */
# "": "NUMPADMINUS DIK_SUBTRACT /* - on numeric keypad */
# "": "NUMPADPLUS DIK_ADD /* + on numeric keypad */
# "": "NUMPADPERIOD DIK_DECIMAL /* . on numeric keypad */
# "": "NUMPADSLASH DIK_DIVIDE /* / on numeric keypad */
# "": "RALT DIK_RMENU /* right Alt */
# "": "UPARROW DIK_UP /* UpArrow on arrow keypad */
# "": "PGUP DIK_PRIOR /* PgUp on arrow keypad */
# "": "LEFTARROW DIK_LEFT /* LeftArrow on arrow keypad */
# "": "RIGHTARROW DIK_RIGHT /* RightArrow on arrow keypad */
# "": "DOWNARROW DIK_DOWN /* DownArrow on arrow keypad */
# "": "PGDN DIK_NEXT /* PgDn on arrow keypad */
| gpl-2.0 | -8,757,528,464,550,546,000 | 20.682143 | 79 | 0.420853 | false |
open-synergy/opnsynid-hr | hr_expense_header_account/tests/test_onchange.py | 1 | 2544 | # -*- coding: utf-8 -*-
# Copyright 2016 OpenSynergy Indonesia
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from .base import BaseCase
class HrExpensePayableAccount(BaseCase):
# Check value account_id
# Condition :
# journal_id == True
# default_credit_account == True
# home_address == True
# property_account_payable == True
def test_onchange_journal_id_1(self):
with self.env.do_in_onchange():
new = self.obj_hr_expense.new()
new.journal_id = self.journal_1.id
new.employee_id = self.employee_1.id
new.onchange_account_id()
self.assertEqual(
self.journal_1.default_credit_account_id.id,
new.account_id.id)
# Check value account_id
# Condition :
# journal_id == True
# default_credit_account == False
# home_address == True
# property_account_payable == True
def test_onchange_journal_id_2(self):
with self.env.do_in_onchange():
new = self.obj_hr_expense.new()
new.journal_id = self.journal_2.id
new.employee_id = self.employee_1.id
property_account_payable =\
new._get_partner_account()
new.onchange_account_id()
self.assertEqual(
property_account_payable,
new.account_id.id)
# Check value account_id
# Condition :
# journal_id == True
# default_credit_account == False
# home_address == False
# property_account_payable == False
def test_onchange_journal_id_3(self):
with self.env.do_in_onchange():
new = self.obj_hr_expense.new()
new.journal_id = self.journal_2.id
new.employee_id = self.employee_2.id
new.onchange_account_id()
self.assertEqual(
False,
new.account_id.id)
# Check value account_id
# Condition :
# journal_id == False
# default_credit_account == False
# home_address == True
# property_account_payable == True
def test_onchange_journal_id_4(self):
with self.env.do_in_onchange():
new = self.obj_hr_expense.new()
new.journal_id = False
new.employee_id = self.employee_1.id
property_account_payable =\
new._get_partner_account()
new.onchange_account_id()
self.assertEqual(
property_account_payable,
new.account_id.id)
| agpl-3.0 | -4,510,974,846,039,466,000 | 27.266667 | 63 | 0.56761 | false |
ForAP/Advanc3d-Pr0graming | A5-Tree/A5-Updated/toolbox.py | 1 | 2769 | # File name: toolbox.py
import kivy
kivy.require('1.7.0')
import math
from kivy.uix.togglebutton import ToggleButton
from kivy.graphics import Line
from turingwidgets import StateRep, DraggableWidget, Transition1, Transition2
from kivy.utils import get_color_from_hex
from kivy.graphics import Color, Ellipse, Line, Bezier
class ToolState(ToggleButton):
def on_touch_down(self, touch):
ds = self.parent.drawing_space
if self.state == 'down' and ds.collide_point(touch.x, touch.y):
(x,y) = ds.to_widget(touch.x, touch.y)
print (x,y)
self.draw(ds, x, y)
return True
return super(ToolState, self).on_touch_down(touch)
def draw(self, ds, x, y):
sm = StateRep(width=48, height=48)
sm.center = (x,y)
sm.opacity = 1
print type(ds.children)
print "ds children is " + str(ds.children)
print "ds children's length is " + str(len(ds.children))
go = self.parent.general_options
go.add_state()
ds.add_widget(sm)
ds.children[0].set_state(go.nameCounter - 1)
#if len(ds.children) > 2:
# tool = ToolTransition()
# tool.draw(ds,ds.children[-1],ds.children[-2])
class ToolTransition(ToggleButton):
#still to test and fix...
def draw_transition(self, current_state, transInfo, transitionCounter):
ds = self.parent.drawing_space
go = self.parent.general_options
print ds.children
stateOneID = int(current_state) + transitionCounter + 1
print stateOneID
stateOne = ds.children[-(stateOneID)]
# search for whether transition has already been created
if (current_state, transInfo[2]) in go.transitions:
key = go.transitions[(current_state, transInfo[2])]
# searches through the drawingspace for the transition and updates the label
for child in ds.children:
if isinstance(child, Transition1) or isinstance(child, Transition2):
if child.key == key:
child.update_label(transInfo)
# find what kind of transition is to be drawn
if current_state == transInfo[2]:
t = Transition1(stateOne,transInfo,go.keyNum)
ds.add_widget(t)
go.transitions.update({(current_state, transInfo[2]):go.keyNum})
go.keyNum += 1
go.transitionCounter += 1
else:
stateTwo = ds.children[-(int(transInfo[2])+transitionCounter+1)]
t = Transition2(stateOne,stateTwo,transInfo,go.keyNum)
ds.add_widget(t)
go.transitions.update({(current_state, transInfo[2]):go.keyNum})
go.keyNum += 1
go.transitionCounter += 1
| gpl-2.0 | 2,529,451,731,753,912,300 | 39.130435 | 84 | 0.615746 | false |
leebecker/jembatan | jembatan/analyzers/spacy.py | 1 | 10874 | import re
import itertools
import functools
from enum import auto, Flag
from jembatan.core.spandex import (Span, Spandex)
from jembatan.core.af import process_default_view, AnalysisFunction
from jembatan.typesys.chunking import NounChunk, Entity
from jembatan.typesys.segmentation import (Document, Sentence, Token)
from jembatan.typesys.syntax import (DependencyEdge, DependencyNode, DependencyParse)
class AnnotationLayers(Flag):
"""Enumerated type useful for turning on/off behavior in Spacy Analyzers
"""
DOCUMENT = auto()
SENTENCE = auto()
TOKEN = auto()
DEPPARSE = auto()
ENTITY = auto()
NOUN_CHUNK = auto()
@classmethod
def NONE(cls):
return functools.reduce(lambda x, y: x | y, [f for f in cls])
@classmethod
def ALL(cls):
return functools.reduce(lambda x, y: x | y, [f for f in cls])
@classmethod
def contains(flagset, flag):
return bool(flagset & flag)
class SpacyToJson(object):
def __init__(self):
pass
def serialize_token(self, t): #, token_lookup, sent_idx):
res = {}
text = {
"content": t.text,
"beginOffset": t.idx
}
partOfSpeech = {
"tag": t.pos_, # This switch is to make naming consistent with Google Natural Language API
"pos": t.tag_ # This is not a field in Google's API, but the original Treebank
}
depEdge = {
"headTokenIndex": t.head.i,
"label": t.dep_
}
return {
"text": text,
"partOfSpeech": partOfSpeech,
"lemma": t.lemma_,
"dependencyEdge": depEdge
}
def serialize_sentence(self, s):
return {
"text": {
"content": s.text,
"beginOffset": s.start_char
},
"sentiment": {}
}
def serialize_entity(self, e):
return {
"name": e.text,
"type": e.label_,
"metadata": { },
"salience": -1,
"mentions": [ {"content": e.text, "beginOffset": e.start_char, "type": "PROPER"}]
}
def to_json(self, spacydoc):
sentences = [self.serialize_sentence(s) for s in spacydoc.sents]
tokens = [self.serialize_token(t) for t in spacydoc]
entities = [self.serialize_entity(e) for e in spacydoc.ents]
return {
"sentences": sentences,
"tokens": tokens,
"entities": entities,
"documentSentiment": {},
"language": "unk"
}
class SpacyToSpandexUtils:
@staticmethod
def convert_sentence(spacysent, window_span=None):
begin = spacysent.start_char
end = begin + len(spacysent.text)
if window_span:
sent_span = Span(begin=window_span.begin + begin, end=window_span.begin + end)
else:
sent_span = Span(begin=begin, end=end)
sent = Sentence()
sent.span = sent_span
sent.source = spacysent
return sent
@staticmethod
def convert_token(spacytok, window_span=None):
span = Span(spacytok.idx, spacytok.idx + len(spacytok))
if window_span:
span = Span(window_span.begin + span.begin, window_span.begin + span.end)
tok = Token(lemma=spacytok.lemma_, pos=spacytok.tag_, tag=spacytok.pos_)
tok.span = span
tok.source = spacytok
return tok
@staticmethod
def convert_entity(entity, window_span=None):
if window_span:
entity_span = Span(window_span.begin + entity.start_char,
window_span.begin + entity.end_char)
else:
entity_span = Span(entity.start_char,
entity.end_char)
entity = Entity(name=None, salience=None, label=entity.label_)
entity.span = entity_span
entity.source = entity
return entity
@staticmethod
def convert_noun_chunk(noun_chunk, window_span=None):
if window_span:
noun_chunk_span = Span(window_span.begin + noun_chunk.start_char,
window_span.begin + noun_chunk.end_char)
else:
noun_chunk_span = Span(noun_chunk.start_char, noun_chunk.end_char)
noun_chunk = NounChunk(label=noun_chunk.label_)
noun_chunk.span = noun_chunk_span
return noun_chunk
@staticmethod
def spacy_to_spandex(spacy_doc, spndx=None, annotation_layers=AnnotationLayers.ALL(), window_span=None):
if not spndx:
spndx = Spandex(spacy_doc.text_with_ws)
if annotation_layers & AnnotationLayers.DOCUMENT:
if window_span:
doc = Document(begin=window_span.begin, end=window_span.end)
else:
doc_span = Span(0, len(spndx.content_string))
doc = Document(begin=doc_span.begin, end=doc_span.end)
spndx.add_annotations(doc)
if annotation_layers & AnnotationLayers.SENTENCE:
spndx.add_annotations(
*[SpacyToSpandexUtils.convert_sentence(s, window_span) for s in spacy_doc.sents])
# Extract tokens and dependency parse
spacy_toks = [t for t in spacy_doc]
if annotation_layers & AnnotationLayers.TOKEN:
all_toks = [SpacyToSpandexUtils.convert_token(t, window_span) for t in spacy_toks]
word_toks = [(tok, spacy_tok) for (tok, spacy_tok) in zip(all_toks, spacy_toks) if not spacy_tok.is_space]
toks = [tok for (tok, spacy_tok) in word_toks]
spndx.add_annotations(*toks)
if annotation_layers & AnnotationLayers.DEPPARSE:
# Pull out dependency graphs
span_to_nodes = {tok.span: DependencyNode(begin=tok.begin, end=tok.end) for tok in toks}
depedges = []
depnodes = []
depnode_spans = set()
for (tok, spacy_tok) in word_toks:
headtok = all_toks[spacy_tok.head.i]
head_node = span_to_nodes[headtok.span]
child_span = tok.span
child_node = span_to_nodes[child_span]
# get span for full dependency
depspan = Span(begin=min(tok.begin, headtok.begin),
end=max(tok.end, headtok.end))
# Build edges
depedge = DependencyEdge(label=spacy_tok.dep_, head=head_node, child=child_node)
depedge.span = depspan
child_node.head_edge = depedge
head_node.child_edges.append(depedge)
if headtok.span not in depnode_spans:
depnodes.append(head_node)
depnode_spans.add(head_node.span)
if child_span not in depnode_spans:
depnodes.append(child_node)
depnode_spans.add(child_span)
depedges.append(depedge)
# push dependency graph onto spandex
spndx.add_annotations(*depedges)
spndx.add_annotations(*depnodes)
dep_parses = []
for sent in spndx.select(Sentence):
dep_parse = DependencyParse(begin=sent.begin, end=sent.end)
dep_nodes = [n for n in spndx.select_covered(DependencyNode, dep_parse)]
for dep_node in dep_nodes:
if not dep_parse.root and dep_node.is_root:
# found the root
dep_parse.root = dep_node
dep_parses.append(dep_parse)
spndx.add_annotations(*dep_parses)
if annotation_layers & AnnotationLayers.ENTITY:
spndx.add_annotations(*[SpacyToSpandexUtils.convert_entity(e, window_span) for e in spacy_doc.ents])
if annotation_layers & AnnotationLayers.NOUN_CHUNK:
spndx.add_annotations(
*[SpacyToSpandexUtils.convert_noun_chunk(n, window_span) for n in spacy_doc.noun_chunks])
class SpacyAnalyzer(AnalysisFunction):
"""
Instances of this class accept a spandex operator at run Spacy on the spandex text
Spacy analyses are then converted into a common typesystem
"""
def __init__(self, spacy_pipeline=None, window_type=None):
"""
@param spacy_pipeline: a spacy model pipeline function which accepts text
and returns a spacy document. Default value of None will trigger
creation and initialization of the Spacy English model.
Example:
# initialize pipeline
spacy_analyzer = SpacyAnalyzer(en_nlp)
# only populate Document, Sentence and Token layers in Spandex
layers = AnnotationLayers.DOCUMENT | AnnotationLayers.SENTENCE \
| AnnotationLayers.TOKEN
spacy_analyzer(spndx, annotation_layers=layers)
"""
if spacy_pipeline:
self.spacy_pipeline = spacy_pipeline
else:
# no pipeline is specified so go ahead and initialize one
import spacy
self.spacy_pipeline = spacy.load("en_core_web_sm")
self.window_type = window_type
@process_default_view
def process(self, spndx: Spandex, **kwargs):
"""
Args:
**kwargs: Keyword Arguments
Keyword Args:
annotation_layers (:obj:`AnnotationLayer`): Bitwise mask of AnnotationLayers
indicating which layers to populate in Spandex. Default value is
AnnotationLayers.ALL()
window_type (str or type): Class Type of object to run processing
over. A common use case would be to run on boundaries already
defined prior to processing. For example processing a document
by subsection boundaries Default of None means to process the
full contents of the Spandex.
"""
# FIXME, better in init or as kwargs?
# window_type = kwargs.get('window_type', None)
annotation_layers = kwargs.get('annotation_layers', AnnotationLayers.ALL())
if not self.window_type:
# process full document
spacy_doc = self.spacy_pipeline(spndx.content_string)
SpacyToSpandexUtils.spacy_to_spandex(spacy_doc, spndx, annotation_layers)
else:
# process over windows
for window in spndx.select(self.window_type):
window_text = spndx.spanned_text(window)
spacy_doc = self.spacy_pipeline(window_text)
SpacyToSpandexUtils.spacy_to_spandex(spacy_doc, spndx, annotation_layers, window)
| apache-2.0 | 1,064,162,214,636,632,700 | 35.489933 | 118 | 0.573754 | false |
choderalab/MSMs | jchodera/src-10471/pyemma/cluster.py | 1 | 2588 | #!/usr/bin/env python
import pyemma
import numpy as np
import mdtraj
import os
# Source directory
source_directory = '/cbio/jclab/projects/fah/fah-data/munged/no-solvent/10471'
source_directory = '/cbio/jclab/projects/fah/fah-data/munged/no-solvent/10490'
################################################################################
# Load reference topology
################################################################################
print ('loading reference topology...')
reference_pdb_filename = 'reference.pdb'
reference_trajectory = os.path.join(source_directory, 'run0-clone0.h5')
traj = mdtraj.load(reference_trajectory)
traj[0].save_pdb(reference_pdb_filename)
################################################################################
# Initialize featurizer
################################################################################
print('Initializing featurizer...')
import pyemma.coordinates
featurizer = pyemma.coordinates.featurizer(reference_pdb_filename)
featurizer.add_all()
################################################################################
# Define coordinates source
################################################################################
import pyemma.coordinates
from glob import glob
trajectory_filenames = glob(os.path.join(source_directory, 'run0-clone94.h5'))
coordinates_source = pyemma.coordinates.source(trajectory_filenames, features=featurizer)
print("There are %d frames total in %d trajectories." % (coordinates_source.n_frames_total(), coordinates_source.number_of_trajectories()))
################################################################################
# Cluster
################################################################################
print('Clustering...')
generator_ratio = 100
nframes = coordinates_source.n_frames_total()
nstates = int(nframes / generator_ratio)
stride = 4
metric = 'minRMSD'
clustering = pyemma.coordinates.cluster_uniform_time(data=coordinates_source, k=nstates, stride=stride, metric=metric)
dtrajs = clustering.dtrajs
# Save discrete trajectories.
dtrajs_dir = 'dtrajs'
clustering.save_dtrajs(output_dir=dtrajs_dir, output_format='npy', extension='.npy')
################################################################################
# Make timescale plots
################################################################################
from pyemma import msm
from pyemma import plots
lags = [1,2,5,10]
its = msm.its(dtrajs, lags=lags, errors='bayes')
plots.plot_implied_timescales(its)
import matplotlib.pyplot as plt
plt.savefig('plot.pdf')
| gpl-2.0 | -3,964,985,091,263,813,600 | 34.452055 | 139 | 0.532844 | false |
nonsk131/USRP2016 | generate_tests0000-0999.py | 1 | 3341 | from isochrones.dartmouth import Dartmouth_Isochrone
from isochrones.utils import addmags
import numpy as np
import pandas as pd
file = open('/tigress/np5/true_params.txt','a')
def get_index(n):
if n < 10:
return '000' + str(n)
elif n < 100:
return '00' + str(n)
elif n < 1000:
return '0' + str(n)
else:
return str(n)
for n in range(0,1000,1):
index = get_index(n)
file.write('test: ' + index + '\n')
dar = Dartmouth_Isochrone()
array = np.random.rand(2) + 0.5
if array[0] > array[1]:
M1 = array[0]
M2 = array[1]
else:
M1 = array[1]
M2 = array[0]
age1 = np.log10(1e8)
age2 = np.log10(5e8)
feh1 = 0.0
array = 1400*np.random.rand(2) + 100
if array[0] > array[1]:
distance1 = array[0]
distance2 = array[1]
else:
distance1 = array[1]
distance2 = array[0]
AV1 = 0.0
feh2 = 0.2
AV2 = 0.1
params = (M1,M2,age1,age2,feh1,feh2,distance1,distance2,AV1,AV2)
params = str(params)
file.write('(M1,M2,age1,age2,feh1,feh2,distance1,distance2,AV1,AV2) = ' + params + '\n')
file.write('\n')
#Simulate true magnitudes
unresolved_bands = ['J','H','K']
resolved_bands = ['i','K']
args1 = (age1, feh1, distance1, AV1)
args2 = (age2, feh2, distance2, AV2)
unresolved = {b:addmags(dar.mag[b](M1, *args1), dar.mag[b](M2, *args2)) for b in unresolved_bands}
resolved_1 = {b:dar.mag[b](M1, *args1) for b in resolved_bands}
resolved_2 = {b:dar.mag[b](M2, *args2) for b in resolved_bands}
#print dar.mag['K'](M2, *args2)
#print unresolved, resolved_1, resolved_2
instruments = ['twomass','RAO']
bands = {'twomass':['J','H','K'],
'RAO':['i','K']}
mag_unc = {'twomass': 0.02, 'RAO':0.1}
resolution = {'twomass':4.0, 'RAO':0.1}
relative = {'twomass':False, 'RAO':True}
separation = 0.5
PA = 100.
columns = ['name', 'band', 'resolution', 'relative', 'separation', 'pa', 'mag', 'e_mag']
df = pd.DataFrame(columns=columns)
i=0
for inst in ['twomass']: #Unresolved observations
for b in bands[inst]:
row = {}
row['name'] = inst
row['band'] = b
row['resolution'] = resolution[inst]
row['relative'] = relative[inst]
row['separation'] = 0.
row['pa'] = 0.
row['mag'] = unresolved[b]
row['e_mag'] = mag_unc[inst]
df = df.append(pd.DataFrame(row, index=[i]))
i += 1
for inst in ['RAO']: #Resolved observations
for b in bands[inst]:
mags = [resolved_1[b], resolved_2[b]]
pas = [0, PA]
seps = [0., separation]
for mag,sep,pa in zip(mags,seps,pas):
row = {}
row['name'] = inst
row['band'] = b
row['resolution'] = resolution[inst]
row['relative'] = relative[inst]
row['separation'] = sep
row['pa'] = pa
row['mag'] = mag
row['e_mag'] = mag_unc[inst]
df = df.append(pd.DataFrame(row, index=[i]))
i += 1
#print df
df.to_csv(path_or_buf='/tigress/np5/df_binary_test{}.csv'.format(index))
file.close()
| mit | -4,797,106,223,220,081,000 | 28.566372 | 102 | 0.516911 | false |
potato16/pythonl | dirtylook/widgetsII.py | 1 | 2420 | import sys
from PyQt5.QtWidgets import (QWidget, QHBoxLayout,
QLabel, QApplication, QLineEdit,
QFrame, QSplitter, QStyleFactory,
QComboBox)
from PyQt5.QtGui import QPixmap
from PyQt5.QtCore import Qt
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
topleft = QFrame(self)
topleft.setFrameShape(QFrame.StyledPanel)
topright = QFrame(self)
topright.setFrameShape(QFrame.StyledPanel)
bottom = QFrame(self)
bottom.setFrameShape(QFrame.StyledPanel)
splitter1 = QSplitter(Qt.Horizontal)
splitter1.addWidget(topleft)
splitter1.addWidget(topright)
splitter2 = QSplitter(Qt.Vertical)
splitter2.addWidget(splitter1)
splitter2.addWidget(bottom)
self.lbl1 = QLabel(self)
qle = QLineEdit(self)
qle.move(60, 100)
self.lbl1.move(60,40)
qle.textChanged[str].connect(self.onChanged)
hbox = QHBoxLayout(self)
hbox.addWidget(splitter2)
#combobox
self.lblc = QLabel('Ubuntu', self)
combo = QComboBox(self)
combo.addItem("Ubuntu")
combo.addItem("Mandriva")
combo.addItem("Fedora")
combo.addItem("Arch")
combo.addItem("Gentoo")
combo.move (50, 50)
self.lblc.move(50,150)
combo.activated[str].connect(self.onActivated)
tmphbox = QHBoxLayout()
tmphbox.addWidget(combo)
tmphbox.addWidget(self.lblc)
topleft.setLayout(tmphbox)
#hbox.addWidget(self.lbl1)
#hbox.addWidget(qle)
pixmap = QPixmap('img1.jpg')
lbl = QLabel(self)
lbl.setPixmap(pixmap)
#hbox.addWidget(lbl)
self.setLayout(hbox)
# self.move(300, 200)
tmphbox = QHBoxLayout()
tmphbox.addWidget(self.lbl1)
tmphbox.addWidget(qle)
topright.setLayout(tmphbox)
tmphbox = QHBoxLayout()
tmphbox.addWidget(lbl)
bottom.setLayout(tmphbox)
self.setWindowTitle('Red Rock')
self.show()
def onActivated(self, text):
self.lblc.setText(text)
self.lblc.adjustSize()
def onChanged(self, text):
self.lbl1.setText(text)
self.lbl1.adjustSize()
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
| apache-2.0 | 1,898,606,519,239,225,300 | 30.842105 | 54 | 0.606198 | false |
piface/pifacecad | setup.py | 2 | 1293 | import sys
from distutils.core import setup
#PY3 = sys.version_info.major >= 3
PY3 = sys.version_info[0] >= 3
VERSION_FILE = "pifacecad/version.py"
def get_version():
if PY3:
version_vars = {}
with open(VERSION_FILE) as f:
code = compile(f.read(), VERSION_FILE, 'exec')
exec(code, None, version_vars)
return version_vars['__version__']
else:
execfile(VERSION_FILE)
return __version__
setup(
name='pifacecad',
version=get_version(),
description='The PiFace Control And Display module.',
author='Thomas Preston',
author_email='[email protected]',
license='GPLv3+',
url='http://piface.github.io/pifacecad/',
packages=['pifacecad', 'pifacecad.tools'],
long_description=open('README.md').read() + open('CHANGELOG').read(),
classifiers=[
"License :: OSI Approved :: GNU Affero General Public License v3 or "
"later (AGPLv3+)",
"Programming Language :: Python :: 3",
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"Topic :: Software Development :: Libraries :: Python Modules",
],
keywords='piface cad control display raspberrypi openlx',
requires=['pifacecommon', 'lirc'],
)
| gpl-3.0 | 8,687,815,180,526,768,000 | 29.785714 | 77 | 0.621036 | false |
TheTazza/StRADRL | settings/options3.py | 1 | 4094 | # -*- coding: utf-8 -*-
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
def get_options(option_type):
"""
option_type: string
'training' or 'diplay' or 'visualize'
"""
# name
tf.app.flags.DEFINE_string("training_name","tc_v1","name of next training in log")
# Common
tf.app.flags.DEFINE_string("env_type", "gym", "environment type (lab or gym or maze)")
tf.app.flags.DEFINE_string("env_name", "CartPole-v1", "environment name (for lab)")
tf.app.flags.DEFINE_integer("env_max_steps", 400000, "max number of steps in environment")
tf.app.flags.DEFINE_boolean("use_base", False, "whether to use base A3C for aux network")
tf.app.flags.DEFINE_boolean("use_pixel_change", False, "whether to use pixel change")
tf.app.flags.DEFINE_boolean("use_value_replay", False, "whether to use value function replay")
tf.app.flags.DEFINE_boolean("use_reward_prediction", False, "whether to use reward prediction")
tf.app.flags.DEFINE_boolean("use_temporal_coherence", True, "whether to use temporal coherence")
tf.app.flags.DEFINE_boolean("use_proportionality", False, "whether to use proportionality")
tf.app.flags.DEFINE_boolean("use_causality", False, "whether to use causality")
tf.app.flags.DEFINE_boolean("use_repeatability", False, "whether to use repeatability")
tf.app.flags.DEFINE_string("checkpoint_dir", "/tmp/StRADRL/checkpoints", "checkpoint directory")
# For training
if option_type == 'training':
tf.app.flags.DEFINE_string("temp_dir", "/tmp/StRADRL/tensorboard/", "base directory for tensorboard")
tf.app.flags.DEFINE_string("log_dir", "/tmp/StRADRL/log/", "base directory for logs")
tf.app.flags.DEFINE_integer("max_time_step", 10**6, "max time steps")
tf.app.flags.DEFINE_integer("save_interval_step", 10**4, "saving interval steps")
tf.app.flags.DEFINE_boolean("grad_norm_clip", 40.0, "gradient norm clipping")
#base
tf.app.flags.DEFINE_float("initial_learning_rate", 1e-3, "learning rate")
tf.app.flags.DEFINE_float("gamma", 0.99, "discount factor for rewards")
tf.app.flags.DEFINE_float("entropy_beta", 0.01, "entropy regurarlization constant")
tf.app.flags.DEFINE_float("value_lambda", 0.5, "value ratio for base loss")
tf.app.flags.DEFINE_float("base_lambda", 0.97, "generalized adv. est. lamba for short-long sight")
# auxiliary
tf.app.flags.DEFINE_integer("parallel_size", 1, "parallel thread size")
tf.app.flags.DEFINE_float("aux_initial_learning_rate", 1e-3, "learning rate")
tf.app.flags.DEFINE_float("aux_lambda", 0.0, "generalized adv. est. lamba for short-long sight (aux)")
tf.app.flags.DEFINE_float("gamma_pc", 0.9, "discount factor for pixel control")
tf.app.flags.DEFINE_float("pixel_change_lambda", 0.0001, "pixel change lambda") # 0.05, 0.01 ~ 0.1 for lab, 0.0001 ~ 0.01 for gym
tf.app.flags.DEFINE_float("temporal_coherence_lambda", 1., "temporal coherence lambda")
tf.app.flags.DEFINE_float("proportionality_lambda", 100., "proportionality lambda")
tf.app.flags.DEFINE_float("causality_lambda", 1., "causality lambda")
tf.app.flags.DEFINE_float("repeatability_lambda", 100., "repeatability lambda")
tf.app.flags.DEFINE_integer("experience_history_size", 100000, "experience replay buffer size")
# queuer
tf.app.flags.DEFINE_integer("local_t_max", 20, "repeat step size")
tf.app.flags.DEFINE_integer("queue_length", 5, "max number of batches (of length local_t_max) in queue")
tf.app.flags.DEFINE_integer("env_runner_sync", 1, "number of env episodes before sync to global")
tf.app.flags.DEFINE_float("action_freq", 0, "number of actions per second in env")
# For display
if option_type == 'display':
tf.app.flags.DEFINE_string("frame_save_dir", "/tmp/StRADRL_frames", "frame save directory")
tf.app.flags.DEFINE_boolean("recording", False, "whether to record movie")
tf.app.flags.DEFINE_boolean("frame_saving", False, "whether to save frames")
return tf.app.flags.FLAGS
| mit | -3,369,474,994,041,291,300 | 53.586667 | 133 | 0.703713 | false |
kedz/sumpy | duc_testbed.py | 1 | 2216 | import argparse
import pandas as pd
import os
import sumpy
import sumpy.eval
def load_docsets(duc_dir):
docset_paths = [os.path.join(duc_dir, fname)
for fname in os.listdir(duc_dir)]
docset_paths = [path for path in docset_paths if os.path.isdir(path)]
docsets = {}
for docset_path in docset_paths:
docset_id, docs, models = load_docset(docset_path)
docsets[docset_id] = {u"docs": docs, u"models": models}
return docsets
def load_docset(docset_path):
docset_id = os.path.split(docset_path)[1]
docs_path = os.path.join(docset_path, u"docs")
docs = sumpy.io.load_duc_docset(docs_path)
models = []
for fname in os.listdir(docset_path):
if docset_id in fname:
model_paths = [os.path.join(docset_path, fname, length)
for length in [u"200", u"400"]]
model_sums = sumpy.io.load_duc_abstractive_summaries(model_paths)
models.extend(model_sums)
return docset_id, docs, models
def generate_summaries(systems, docsets):
rouge = sumpy.eval.ROUGE(max_ngrams=2, limit=100, limit_type=u"word")
results = []
for docset_id in docsets.keys():
#print docset_id
docs = docsets[docset_id][u"docs"]
models = docsets[docset_id][u"models"]
sys_sums = [(system_name, unicode(sum_func(docs)))
for system_name, sum_func in systems]
df = rouge.evaluate(sys_sums, models)
results.append(df)
return pd.concat(results).groupby(level=0).mean()
def main(duc_dir):
print u"Loading DUC document sets from:", duc_dir
docsets = load_docsets(duc_dir)
lede = lambda x: sumpy.lede(x)
centroid = lambda x: sumpy.centroid(x)
lexrank = lambda x: sumpy.lexrank(x)
systems = [(u"lede", lede), (u"centroid", centroid),
(u"lexrank", lexrank)]
print generate_summaries(systems, docsets)
if __name__ == u"__main__":
parser = argparse.ArgumentParser()
parser.add_argument(u"-d", u"--duc-dir", required=True, type=unicode,
help=u"path to DUC document set directory")
args = parser.parse_args()
duc_dir = args.duc_dir
main(duc_dir)
| apache-2.0 | 1,770,225,091,152,493,600 | 34.174603 | 77 | 0.618682 | false |
repotvsupertuga/tvsupertuga.repository | script.module.streamtvsupertuga/lib/resources/lib/sources/it/freedownload.py | 1 | 3281 | import requests
import re
import xbmc,xbmcaddon,time
from ..scraper import Scraper
from ..common import clean_title,clean_search,random_agent,send_log,error_log
dev_log = xbmcaddon.Addon('script.module.universalscrapers').getSetting("dev_log")
class freedownload(Scraper):
domains = ['http://freemoviedownloads6.com']
name = "FreeDownload"
sources = []
def __init__(self):
self.base_link = 'http://freemoviedownloads6.com'
self.goog = 'https://www.google.co.uk'
self.sources = []
if dev_log=='true':
self.start_time = time.time()
def scrape_movie(self, title, year, imdb, debrid=False):
try:
scrape = clean_search(title.lower()).replace(' ','+')
start_url = '%s/search?q=freemoviedownloads6.com+%s+%s' %(self.goog,scrape,year)
#print 'START> '+start_url
headers = {'User-Agent':random_agent()}
html = requests.get(start_url,headers=headers,timeout=3).content
results = re.compile('href="(.+?)"',re.DOTALL).findall(html)
for url in results:
if self.base_link in url:
if scrape.replace('+','-') in url:
if 'webcache' in url:
continue
self.get_source(url,title,year)
return self.sources
except Exception, argument:
if dev_log == 'true':
error_log(self.name,'Check Search')
return self.sources
def get_source(self,url,title,year):
try:
#print 'cfwds %s %s %s' %(url,title,year)
confirm_name = clean_title(title.lower()) + year
headers={'User-Agent':random_agent()}
OPEN = requests.get(url,headers=headers,timeout=5).content
getTit = re.compile('<title>(.+?)</title>',re.DOTALL).findall(OPEN)[0]
getTit = getTit.split('Free')[0]
if clean_title(getTit.lower()) == confirm_name:
#print 'This Movie + '+getTit
OPEN = OPEN.split("type='video/mp4'")[1]
Regex = re.compile('href="(.+?)"',re.DOTALL).findall(OPEN)
count = 0
for link in Regex:
if '1080' in link:
res = '1080p'
elif '720' in link:
res = '720p'
elif '480' in link:
res = '480p'
else:
res = 'SD'
if '.mkv' in link:
count +=1
self.sources.append({'source': 'DirectLink', 'quality': res, 'scraper': self.name, 'url': link,'direct': True})
if '.mp4' in link:
count +=1
self.sources.append({'source': 'DirectLink', 'quality': res, 'scraper': self.name, 'url': link,'direct': True})
if dev_log=='true':
end_time = time.time() - self.start_time
send_log(self.name,end_time,count)
except:
pass
| gpl-2.0 | 967,297,113,718,419,100 | 37.6 | 135 | 0.477294 | false |
DarjaGFX/GroupWeb | web/settings.py | 1 | 3218 | """
Django settings for web project.
Generated by 'django-admin startproject' using Django 1.10.5.
For more information on this file, see
https://docs.djangoproject.com/en/1.10/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.10/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '6tua3m@^yp6@ld%q*exja6p$3mlr@th-r)4y8s8#cf$xk7ivqs'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'blog',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
# 'web.middleware.alaki'
]
ROOT_URLCONF = 'web.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'web.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.10/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Password validation
# https://docs.djangoproject.com/en/1.10/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/1.10/topics/i18n/
LANGUAGE_CODE = 'en-us'
# LANGUAGE_CODE = 'fa-ir'
# import locale
# locale.setlocale(locale.LC_ALL, "fa_IR")
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.10/howto/static-files/
STATIC_URL = '/blog/static/'
| gpl-3.0 | -8,696,760,926,007,692,000 | 24.744 | 91 | 0.684587 | false |
aksareen/balrog | auslib/test/admin/views/test_releases.py | 1 | 71942 | import mock
import simplejson as json
from sqlalchemy import select
from auslib.blobs.base import createBlob
from auslib.global_state import dbo
from auslib.test.admin.views.base import ViewTest
class TestReleasesAPI_JSON(ViewTest):
def testGetRelease(self):
ret = self._get("/releases/b")
self.assertStatusCode(ret, 200)
self.assertEqual(json.loads(ret.data), json.loads("""
{
"name": "b",
"hashFunction": "sha512",
"schema_version": 1
}
"""))
def testGetRelease404(self):
ret = self._get("/releases/g")
self.assertStatusCode(ret, 404)
def testReleasePostUpdateExisting(self):
data = json.dumps(dict(detailsUrl='blah', fakePartials=True, schema_version=1))
ret = self._post('/releases/d', data=dict(data=data, product='d', data_version=1))
self.assertStatusCode(ret, 200)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'd').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "d",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"d": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}
"""))
def testReleasePostUpdateExistingWithoutPermission(self):
data = json.dumps(dict(detailsUrl='blah', fakePartials=True, schema_version=1))
ret = self._post('/releases/d', data=dict(data=data, product='d', data_version=1), username="hannah")
self.assertStatusCode(ret, 403)
def testReleasePutUpdateMergeableOutdatedData(self):
ancestor_blob = """
{
"name": "dd",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"dd": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}"""
blob1 = """
{
"name": "dd",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"dd": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
},
"dd2": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}"""
blob2 = """
{
"name": "dd",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"dd": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
},
"dd1": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}"""
result_blob = createBlob("""
{
"name": "dd",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"dd2": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
},
"dd": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
},
"dd1": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}""")
# Testing Put request to add new release
ret = self._put('/releases/dd', data=dict(blob=ancestor_blob, name='dd',
product='dd', data_version=1))
self.assertStatusCode(ret, 201)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'dd').execute().fetchone()[0]
self.assertEqual(ret, createBlob(ancestor_blob))
# Updating same release
ret = self._put('/releases/dd', data=dict(blob=blob1, name='dd',
product='dd', data_version=1))
self.assertStatusCode(ret, 200)
self.assertEqual(json.loads(ret.data), dict(new_data_version=2))
# Updating release with outdated data, testing if merged correctly
ret = self._put('/releases/dd', data=dict(blob=blob2, name='dd',
product='dd', data_version=1))
self.assertStatusCode(ret, 200)
self.assertEqual(json.loads(ret.data), dict(new_data_version=3))
ret = select([dbo.releases.data]).where(dbo.releases.name == 'dd').execute().fetchone()[0]
self.assertEqual(ret, result_blob)
def testReleasePutUpdateConflictingOutdatedData(self):
ancestor_blob = """
{
"name": "dd",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"dd": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}"""
blob1 = """
{
"name": "dd",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"dd1": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}"""
blob2 = """
{
"name": "dd",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"dd": {
"complete": {
"filesize": 12345,
"from": "*",
"hashValue": "abc"
}
},
"dd1": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc1"
}
}
}
}
}
}"""
# Testing Put request to add new release
ret = self._put('/releases/dd', data=dict(blob=ancestor_blob, name='dd', product='dd', data_version=1))
self.assertStatusCode(ret, 201)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'dd').execute().fetchone()[0]
self.assertEqual(ret, createBlob(ancestor_blob))
# Updating same release
ret = self._put('/releases/dd', data=dict(blob=blob1, name='dd',
product='dd', data_version=1))
self.assertStatusCode(ret, 200)
self.assertEqual(json.loads(ret.data), dict(new_data_version=2))
# Updating same release with conflicting data
ret = self._put('/releases/dd', data=dict(blob=blob2, name='dd',
product='dd', data_version=1))
self.assertStatusCode(ret, 400)
def testReleasePostUpdateOutdatedDataNotBlob(self):
blob = """
{
"name": "ee",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"ee": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}"""
ret = self._post('/releases/ee', data=dict(data=blob, hashFunction="sha512", name='ee', product='ee', data_version=1))
self.assertStatusCode(ret, 201)
# Updating same release
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = self._post('/releases/ee', data=dict(data=blob,
hashFunction="sha512",
name='ee', product='ee', data_version=2))
self.assertStatusCode(ret, 200)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=3)), "Data: %s" % ret.data)
# Outdated Data Error on same release
ret = self._post('/releases/ee', data=dict(hashFunction="sha512",
read_only=True,
name='ee', product='ee', data_version=1))
self.assertStatusCode(ret, 400)
def testReleasePostMismatchedName(self):
data = json.dumps(dict(name="eee", schema_version=1))
ret = self._post('/releases/d', data=dict(data=data, product='d', data_version=1))
self.assertStatusCode(ret, 400)
def testReleasePostUpdateChangeHashFunction(self):
data = json.dumps(dict(detailsUrl='blah', hashFunction="sha1024", schema_version=1))
ret = self._post('/releases/d', data=dict(data=data, product='d', data_version=1))
self.assertStatusCode(ret, 400)
def testReleasePostUpdateChangeProduct(self):
data = json.dumps(dict(detailsUrl="abc", schema_version=1))
ret = self._post("/releases/c", data=dict(data=data, product="h", data_version=1))
self.assertStatusCode(ret, 400)
def testReleasePostInvalidBlob(self):
data = json.dumps(dict(uehont="uhetn", schema_version=1))
ret = self._post("/releases/c", data=dict(data=data, product="c", data_version=1))
self.assertStatusCode(ret, 400)
self.assertIn("Additional properties are not allowed", ret.data)
def testReleasePostWithSignoffRequired(self):
data = json.dumps(dict(bouncerProducts=dict(partial='foo'), name='a', hashFunction="sha512"))
ret = self._post("/releases/a", data=dict(data=data, product="a", data_version=1, schema_version=1))
self.assertStatusCode(ret, 400)
self.assertIn("This change requires signoff", ret.data)
def testReleasePostCreatesNewReleasev1(self):
data = json.dumps(dict(bouncerProducts=dict(partial='foo'), name='e', hashFunction="sha512"))
ret = self._post('/releases/e', data=dict(data=data, product='e', schema_version=1))
self.assertStatusCode(ret, 201)
ret = dbo.releases.t.select().where(dbo.releases.name == 'e').execute().fetchone()
self.assertEqual(ret['product'], 'e')
self.assertEqual(ret['name'], 'e')
self.assertEqual(ret['data'], createBlob("""
{
"name": "e",
"hashFunction": "sha512",
"schema_version": 1,
"bouncerProducts": {
"partial": "foo"
}
}
"""))
def testReleasePostCreatesNewReleaseNopermission(self):
data = json.dumps(dict(bouncerProducts=dict(partial='foo'), name='e', hashFunction="sha512"))
ret = self._post('/releases/e', data=dict(data=data, product='e', schema_version=1), username="kate")
self.assertStatusCode(ret, 403)
def testReleasePostCreatesNewReleasev2(self):
data = json.dumps(dict(bouncerProducts=dict(complete='foo'), name='e', hashFunction="sha512"))
ret = self._post('/releases/e', data=dict(data=data, product='e', schema_version=2))
self.assertStatusCode(ret, 201)
ret = dbo.releases.t.select().where(dbo.releases.name == 'e').execute().fetchone()
self.assertEqual(ret['product'], 'e')
self.assertEqual(ret['name'], 'e')
self.assertEqual(ret['data'], createBlob("""
{
"name": "e",
"hashFunction": "sha512",
"schema_version": 2,
"bouncerProducts": {
"complete": "foo"
}
}
"""))
def testReleasePostInvalidKey(self):
data = json.dumps(dict(foo=1))
ret = self._post('/releases/ab', data=dict(data=data))
self.assertStatusCode(ret, 400)
def testReleasePostRejectedURL(self):
data = json.dumps(dict(platforms=dict(p=dict(locales=dict(f=dict(complete=dict(fileUrl='http://evil.com')))))))
ret = self._post('/releases/d', data=dict(data=data, product='d', data_version=1))
self.assertStatusCode(ret, 400)
def testDeleteRelease(self):
ret = self._delete("/releases/d", qs=dict(data_version=1))
self.assertStatusCode(ret, 200)
ret = dbo.releases.t.count().where(dbo.releases.name == 'd').execute().first()[0]
self.assertEqual(ret, 0)
def testDeleteReleaseOutdatedData(self):
# Release's data version is outdated
ret = self._get("/releases/d")
self.assertStatusCode(ret, 200)
ret = self._delete("/releases/d", qs=dict(data_version=7))
self.assertStatusCode(ret, 400)
def testDeleteNonExistentRelease(self):
ret = self._delete("/releases/ueo", qs=dict(data_version=1))
self.assertStatusCode(ret, 404)
def testDeleteWithoutPermission(self):
ret = self._delete("/releases/d", username="bob", qs=dict(data_version=1))
self.assertStatusCode(ret, 403)
def testDeleteWithoutPermissionForAction(self):
ret = self._delete("/releases/d", username="bob", qs=dict(data_version=1))
self.assertStatusCode(ret, 403)
def testDeleteWithProductAdminPermission(self):
ret = self._delete("/releases/d", username="bill", qs=dict(data_version=1))
self.assertStatusCode(ret, 200)
def testDeleteWithoutProductAdminPermission(self):
ret = self._delete("/releases/d", username="billy", qs=dict(data_version=1))
self.assertStatusCode(ret, 403)
def testDeleteReadOnlyRelease(self):
dbo.releases.t.update(values=dict(read_only=True, data_version=2)).where(dbo.releases.name == "d").execute()
ret = self._delete("/releases/d", username="bill", qs=dict(data_version=2))
self.assertStatusCode(ret, 403)
def testDeleteWithRules(self):
ret = self._delete("/releases/a", qs=dict(data_version=1))
self.assertStatusCode(ret, 400)
def testLocalePut(self):
data = json.dumps({
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc",
}
})
ret = self._put('/releases/ab/builds/p/l', data=dict(data=data, product='a', data_version=1, schema_version=1))
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'ab').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "ab",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"l": {
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}
"""))
def testLocalePutSpecificPermission(self):
data = json.dumps({
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc",
}
})
ret = self._put('/releases/ab/builds/p/l', username="ashanti", data=dict(data=data, product='a', data_version=1, schema_version=1))
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'ab').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "ab",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"l": {
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}
"""))
def testLocalePutWithBadHashFunction(self):
data = json.dumps(dict(complete=dict(filesize='435')))
ret = self._put('/releases/ab/builds/p/l', data=dict(data=data, product='a', data_version=1, schema_version=1))
self.assertStatusCode(ret, 400)
def testLocalePutWithoutPermission(self):
data = '{"complete": {"filesize": 435, "from": "*", "hashValue": "abc"}}'
ret = self._put('/releases/ab/builds/p/l', username='liu', data=dict(data=data, product='a', data_version=1, schema_version=1))
self.assertStatusCode(ret, 403)
def testLocalePutWithoutPermissionForProduct(self):
data = '{"complete": {"filesize": 435, "from": "*", "hashValue": "abc"}}'
ret = self._put('/releases/ab/builds/p/l', username='bob', data=dict(data=data, product='a', data_version=1, schema_version=1))
self.assertStatusCode(ret, 403)
def testLocalePutForNewRelease(self):
data = json.dumps({
"complete": {
"filesize": 678,
"from": "*",
"hashValue": "abc",
}
})
# setting schema_version in the incoming blob is a hack for testing
# SingleLocaleView._put() doesn't give us access to the form
ret = self._put('/releases/e/builds/p/a', data=dict(data=data, product='e', hashFunction="sha512", schema_version=1))
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'e').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "e",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"a": {
"complete": {
"filesize": 678,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}
"""))
def testLocalePutAppend(self):
data = json.dumps({
"partial": {
"filesize": 234,
"from": "c",
"hashValue": "abc",
"fileUrl": "http://good.com/blah",
}
})
ret = self._put('/releases/d/builds/p/g', data=dict(data=data, product='d', data_version=1, schema_version=1))
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'd').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "d",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"d": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
},
"g": {
"partial": {
"filesize": 234,
"from": "c",
"hashValue": "abc",
"fileUrl": "http://good.com/blah"
}
}
}
}
}
}
"""))
def testLocalePutForNewReleaseWithAlias(self):
data = json.dumps({
"complete": {
"filesize": 678,
"from": "*",
"hashValue": "abc",
}
})
# setting schema_version in the incoming blob is a hack for testing
# SingleLocaleView._put() doesn't give us access to the form
ret = self._put('/releases/e/builds/p/a', data=dict(data=data, product='e', alias='["p2"]', schema_version=1, hashFunction="sha512"))
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'e').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "e",
"hashFunction": "sha512",
"schema_version": 1,
"platforms": {
"p": {
"locales": {
"a": {
"complete": {
"filesize": 678,
"from": "*",
"hashValue": "abc"
}
}
}
},
"p2": {
"alias": "p"
}
}
}
"""))
def testLocalePutAppendWithAlias(self):
data = json.dumps({
"partial": {
"filesize": 123,
"from": "c",
"hashValue": "abc",
"fileUrl": "http://good.com/blah",
}
})
ret = self._put('/releases/d/builds/q/g', data=dict(data=data, product='d', data_version=1, alias='["q2"]', schema_version=1))
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'd').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "d",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"d": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
},
"q": {
"locales": {
"g": {
"partial": {
"filesize": 123,
"from": "c",
"hashValue": "abc",
"fileUrl": "http://good.com/blah"
}
}
}
},
"q2": {
"alias": "q"
}
}
}
"""))
def testLocalePutWithCopy(self):
data = json.dumps({
"partial": {
"filesize": 123,
"from": "b",
"hashValue": "abc",
}
})
data = dict(data=data, product='a', copyTo=json.dumps(['b']), data_version=1, schema_version=1)
ret = self._put('/releases/ab/builds/p/l', data=data)
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'ab').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "ab",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"l": {
"partial": {
"filesize": 123,
"from": "b",
"hashValue": "abc"
}
}
}
}
}
}
"""))
ret = select([dbo.releases.data]).where(dbo.releases.name == 'b').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "b",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"l": {
"partial": {
"filesize": 123,
"from": "b",
"hashValue": "abc"
}
}
}
}
}
}
"""))
def testLocalePutBadJSON(self):
ret = self._put('/releases/ab/builds/p/l', data=dict(data='a', product='a'))
self.assertStatusCode(ret, 400)
def testLocaleRejectedURL(self):
data = json.dumps(dict(complete=dict(fileUrl='http://evil.com')))
ret = self._put('/releases/ab/builds/p/l', data=dict(data=data, product='a', data_version=1))
self.assertStatusCode(ret, 400)
def testLocaleGet(self):
ret = self._get('/releases/d/builds/p/d')
self.assertStatusCode(ret, 200)
got = json.loads(ret.data)
expected = {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc",
}
}
self.assertEquals(got, expected)
self.assertEqual(ret.headers['X-Data-Version'], '1')
def testLocalePutNotAllowed(self):
data = json.dumps({
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc",
}
})
inp_data = dict(csrf_token="lorem", data=data, product='d', data_version=1, schema_version=1)
ret = self.client.put('/releases/d/builds/p/d', data=json.dumps(inp_data), content_type="application/json")
self.assertStatusCode(ret, 401)
def testLocalePutReadOnlyRelease(self):
dbo.releases.t.update(values=dict(read_only=True, data_version=2)).where(dbo.releases.name == "ab").execute()
data = json.dumps({
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc",
}
})
ret = self._put('/releases/ab/builds/p/l', data=dict(data=data, product='a', data_version=1, schema_version=1))
self.assertStatusCode(ret, 403)
def testLocalePutWithProductAdmin(self):
data = json.dumps({
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc",
}
})
ret = self._put('/releases/ab/builds/p/l', username='billy',
data=dict(data=data, product='a', data_version=1, schema_version=1))
self.assertStatusCode(ret, 201)
def testLocalePutWithoutProductAdmin(self):
data = json.dumps({
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc",
}
})
ret = self._put('/releases/d/builds/p/d', username='billy',
data=dict(data=data, product='d', data_version=1, schema_version=1))
self.assertStatusCode(ret, 403)
def testLocalePutCantChangeProduct(self):
data = json.dumps(dict(complete=dict(filesize=435)))
ret = self._put('/releases/ab/builds/p/l', data=dict(data=data, product='b', schema_version=1))
self.assertStatusCode(ret, 400)
def testLocaleGet404(self):
ret = self._get("/releases/c/builds/h/u")
self.assertStatusCode(ret, 404)
# FIXME: We shouldn't rely on 500 to validate behaviour. This test should fake a 400 instead.
# Currently, causing a 400 in this will NOT make version revert to the original value. Need to
# fix the bug at the same time as changing the test.
# def testLocaleRevertsPartialUpdate(self):
# data = json.dumps(dict(complete=dict(filesize=1)))
# with mock.patch('auslib.global_state.dbo.releases.addLocaleToRelease') as r:
# r.side_effect = Exception("Fail")
# ret = self._put('/releases/a/builds/p/l', data=dict(data=data, product='a', version='c', data_version=1, schema_version=1))
# self.assertStatusCode(ret, 500)
# ret = dbo.releases.t.select().where(dbo.releases.name == 'a').execute().fetchone()
# self.assertEqual(ret['product'], 'a')
# self.assertEqual(ret['version'], 'a')
# self.assertEqual(json.loads(ret['data']), dict(name='a', hashFunction="sha512", schema_version=1))
def testNewReleasePut(self):
ret = self._put('/releases/new_release', data=dict(name='new_release', product='Firefox',
blob="""
{
"name": "new_release",
"hashFunction": "sha512",
"schema_version": 1,
"platforms": {
"p": {
"locales": {
"l": {
}
}
}
}
}
"""))
self.assertEquals(ret.status_code, 201, "Status Code: %d, Data: %s" % (ret.status_code, ret.data))
r = dbo.releases.t.select().where(dbo.releases.name == 'new_release').execute().fetchall()
self.assertEquals(len(r), 1)
self.assertEquals(r[0]['name'], 'new_release')
self.assertEquals(r[0]['product'], 'Firefox')
self.assertEquals(r[0]['data'], createBlob("""
{
"name": "new_release",
"hashFunction": "sha512",
"schema_version": 1,
"platforms": {
"p": {
"locales": {
"l": {
}
}
}
}
}
"""))
def testNewReleasePutBadInput(self):
ret = self._put("/releases/ueohueo", data=dict(name="ueohueo", product="aa", blob="""
{
"name": "ueohueo",
"schema_version": 3,
"hashFunction": "sha512",
"borken": "yes"
}
"""))
self.assertStatusCode(ret, 400)
def testNewReleasePutMismatchedName(self):
ret = self._put("/releases/aaaa", data=dict(name="ueohueo", product="aa", blob="""
{
"name": "bbbb",
"schema_version": 3
}
"""))
self.assertStatusCode(ret, 400)
def testPutExistingRelease(self):
ret = self._put("/releases/d", data=dict(name="d", product="Firefox", data_version=1, blob="""
{
"name": "d",
"schema_version": 3,
"hashFunction": "sha512",
"actions": "doit"
}
"""))
self.assertEquals(ret.status_code, 200, "Status Code: %d, Data: %s" % (ret.status_code, ret.data))
r = dbo.releases.t.select().where(dbo.releases.name == 'd').execute().fetchall()
self.assertEquals(len(r), 1)
self.assertEquals(r[0]['name'], 'd')
self.assertEquals(r[0]['product'], 'Firefox')
self.assertEquals(r[0]['data'], createBlob("""
{
"name": "d",
"schema_version": 3,
"hashFunction": "sha512",
"actions": "doit"
}
"""))
def testGMPReleasePut(self):
ret = self._put('/releases/gmprel', data=dict(name='gmprel', product='a',
blob="""
{
"name": "gmprel",
"schema_version": 1000,
"hashFunction": "sha512",
"vendors": {
"foo": {
"version": "1",
"platforms": {
"a": {
"filesize": 2,
"hashValue": "acbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbda\
cbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbd",
"fileUrl": "http://good.com/4"
},
"a2": {
"alias": "a"
}
}
}
}
}
"""))
self.assertEquals(ret.status_code, 201, "Status Code: %d, Data: %s" % (ret.status_code, ret.data))
r = dbo.releases.t.select().where(dbo.releases.name == 'gmprel').execute().fetchall()
self.assertEquals(len(r), 1)
self.assertEquals(r[0]['name'], 'gmprel')
self.assertEquals(r[0]['product'], 'a')
self.assertEquals(r[0]['data'], createBlob("""
{
"name": "gmprel",
"schema_version": 1000,
"hashFunction": "sha512",
"vendors": {
"foo": {
"version": "1",
"platforms": {
"a": {
"filesize": 2,
"hashValue": "acbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbda\
cbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbdacbd",
"fileUrl": "http://good.com/4"
},
"a2": {
"alias": "a"
}
}
}
}
}
"""))
def testGetReleases(self):
ret = self._get("/releases")
self.assertStatusCode(ret, 200)
data = json.loads(ret.data)
self.assertEquals(len(data["releases"]), 5)
def testGetReleasesNamesOnly(self):
ret = self._get("/releases", qs=dict(names_only=1))
self.assertStatusCode(ret, 200)
self.assertEquals(json.loads(ret.data), json.loads("""
{
"names": [
"a", "ab", "b", "c", "d"
]
}
"""))
def testGetReleasesNamePrefix(self):
ret = self._get("/releases", qs=dict(name_prefix='a'))
self.assertStatusCode(ret, 200)
ret_data = json.loads(ret.data)
with self.assertRaises(KeyError):
ret_data['data']
self.assertEquals(ret_data, json.loads("""
{
"releases": [
{"data_version": 1, "name": "a", "product": "a", "read_only": false, "rule_ids": [3, 4, 6, 7]},
{"data_version": 1, "name": "ab", "product": "a", "read_only": false, "rule_ids": []}
]
}
"""))
def testGetReleasesNamePrefixNamesOnly(self):
ret = self._get("/releases", qs=dict(name_prefix='a',
names_only='1'))
self.assertStatusCode(ret, 200)
self.assertEquals(json.loads(ret.data), json.loads("""
{
"names": ["a", "ab"]
}
"""))
def testReleasesPost(self):
data = json.dumps(dict(bouncerProducts=dict(partial='foo'), name='e', schema_version=1, hashFunction="sha512"))
ret = self._post('/releases', data=dict(blob=data, name="e", product='e'))
self.assertStatusCode(ret, 201)
ret = dbo.releases.t.select().where(dbo.releases.name == 'e').execute().fetchone()
self.assertEqual(ret['product'], 'e')
self.assertEqual(ret['name'], 'e')
self.assertEqual(ret['data'], createBlob("""
{
"name": "e",
"hashFunction": "sha512",
"schema_version": 1,
"bouncerProducts": {
"partial": "foo"
}
}
"""))
class TestReleasesScheduledChanges(ViewTest):
maxDiff = 10000
def setUp(self):
super(TestReleasesScheduledChanges, self).setUp()
dbo.releases.scheduled_changes.t.insert().execute(
sc_id=1, scheduled_by="bill", change_type="insert", data_version=1, base_name="m", base_product="m",
base_data=createBlob(dict(name="m", hashFunction="sha512", schema_version=1))
)
dbo.releases.scheduled_changes.history.t.insert().execute(change_id=1, changed_by="bill", timestamp=50, sc_id=1)
dbo.releases.scheduled_changes.history.t.insert().execute(
change_id=2, changed_by="bill", timestamp=51, sc_id=1, scheduled_by="bill", change_type="insert", data_version=1, base_name="m",
base_product="m", base_data=createBlob(dict(name="m", hashFunction="sha512", schema_version=1))
)
dbo.releases.scheduled_changes.conditions.t.insert().execute(sc_id=1, when=4000000000, data_version=1)
dbo.releases.scheduled_changes.conditions.history.t.insert().execute(change_id=1, changed_by="bill", timestamp=50, sc_id=1)
dbo.releases.scheduled_changes.conditions.history.t.insert().execute(
change_id=2, changed_by="bill", timestamp=51, sc_id=1, when=4000000000, data_version=1
)
dbo.releases.scheduled_changes.t.insert().execute(
sc_id=2, scheduled_by="bill", change_type="update", data_version=1, base_name="a", base_product="a",
base_data=createBlob(dict(name="a", hashFunction="sha512", schema_version=1, extv="2.0")), base_data_version=1
)
dbo.releases.scheduled_changes.history.t.insert().execute(change_id=3, changed_by="bill", timestamp=70, sc_id=2)
dbo.releases.scheduled_changes.history.t.insert().execute(
change_id=4, changed_by="bill", timestamp=71, sc_id=2, scheduled_by="bill", change_type="update", data_version=1, base_name="a",
base_product="a", base_data=createBlob(dict(name="a", hashFunction="sha512", schema_version=1, extv="2.0")), base_data_version=1
)
dbo.releases.scheduled_changes.signoffs.t.insert().execute(sc_id=2, username="bill", role="releng")
dbo.releases.scheduled_changes.signoffs.history.t.insert().execute(change_id=1, changed_by="bill", timestamp=100, sc_id=2, username="bill")
dbo.releases.scheduled_changes.signoffs.history.t.insert().execute(change_id=2, changed_by="bill", timestamp=101, sc_id=2,
username="bill", role="releng")
dbo.releases.scheduled_changes.conditions.t.insert().execute(sc_id=2, when=6000000000, data_version=1)
dbo.releases.scheduled_changes.conditions.history.t.insert().execute(change_id=3, changed_by="bill", timestamp=70, sc_id=2)
dbo.releases.scheduled_changes.conditions.history.t.insert().execute(
change_id=4, changed_by="bill", timestamp=71, sc_id=2, when=6000000000, data_version=1
)
dbo.releases.scheduled_changes.t.insert().execute(
sc_id=3, complete=True, scheduled_by="bill", change_type="update", data_version=2, base_name="b", base_product="b",
base_data=createBlob(dict(name="b", hashFunction="sha512", schema_version=1)), base_data_version=1
)
dbo.releases.scheduled_changes.history.t.insert().execute(change_id=5, changed_by="bill", timestamp=6, sc_id=3)
dbo.releases.scheduled_changes.history.t.insert().execute(
change_id=6, changed_by="bill", timestamp=7, sc_id=3, complete=False, scheduled_by="bill", change_type="update", data_version=1, base_name="b",
base_product="b", base_data=createBlob(dict(name="b", hashFunction="sha512", schema_version=1)), base_data_version=1
)
dbo.releases.scheduled_changes.history.t.insert().execute(
change_id=7, changed_by="bill", timestamp=25, sc_id=3, complete=True, change_type="update", scheduled_by="bill", data_version=2, base_name="b",
base_product="b", base_data=createBlob(dict(name="b", hashFunction="sha512", schema_version=1)), base_data_version=1
)
dbo.releases.scheduled_changes.conditions.t.insert().execute(sc_id=3, when=10000000, data_version=2)
dbo.releases.scheduled_changes.conditions.history.t.insert().execute(change_id=5, changed_by="bill", timestamp=6, sc_id=3)
dbo.releases.scheduled_changes.conditions.history.t.insert().execute(
change_id=6, changed_by="bill", timestamp=7, sc_id=3, when=10000000, data_version=1
)
dbo.releases.scheduled_changes.conditions.history.t.insert().execute(
change_id=7, changed_by="bill", timestamp=25, sc_id=3, when=10000000, data_version=2
)
dbo.releases.scheduled_changes.t.insert().execute(
sc_id=4, complete=False, scheduled_by="bill", change_type="delete", data_version=1, base_name="ab", base_data_version=1,
)
dbo.releases.scheduled_changes.history.t.insert().execute(change_id=8, changed_by="bill", timestamp=25, sc_id=4)
dbo.releases.scheduled_changes.history.t.insert().execute(
change_id=9, changed_by="bill", timestamp=26, sc_id=4, complete=False, scheduled_by="bill", change_type="delete", data_version=1,
base_name="ab", base_data_version=1
)
dbo.releases.scheduled_changes.conditions.t.insert().execute(sc_id=4, when=230000000, data_version=1)
dbo.releases.scheduled_changes.conditions.history.t.insert().execute(change_id=8, changed_by="bill", timestamp=25, sc_id=4)
dbo.releases.scheduled_changes.conditions.history.t.insert().execute(
change_id=9, changed_by="bill", timestamp=26, sc_id=4, when=230000000, data_version=1
)
dbo.releases.scheduled_changes.signoffs.t.insert().execute(sc_id=4, username="bill", role="releng")
dbo.releases.scheduled_changes.signoffs.t.insert().execute(sc_id=4, username="ben", role="releng")
def testGetScheduledChanges(self):
ret = self._get("/scheduled_changes/releases")
expected = {
"count": 3,
"scheduled_changes": [
{
"sc_id": 1, "when": 4000000000, "scheduled_by": "bill", "change_type": "insert", "complete": False, "sc_data_version": 1,
"name": "m", "product": "m", "data": {"name": "m", "hashFunction": "sha512", "schema_version": 1}, "read_only": False,
"data_version": None, "signoffs": {}, "required_signoffs": {},
},
{
"sc_id": 2, "when": 6000000000, "scheduled_by": "bill", "change_type": "update", "complete": False, "sc_data_version": 1,
"name": "a", "product": "a", "data": {"name": "a", "hashFunction": "sha512", "schema_version": 1, "extv": "2.0"},
"read_only": False, "data_version": 1, "signoffs": {"bill": "releng"}, "required_signoffs": {"releng": 1},
},
{
"sc_id": 4, "when": 230000000, "scheduled_by": "bill", "change_type": "delete", "complete": False, "sc_data_version": 1,
"name": "ab", "product": None, "data": None, "read_only": False, "data_version": 1, "signoffs": {"ben": "releng", "bill": "releng"},
"required_signoffs": {},
},
]
}
self.assertEquals(json.loads(ret.data), expected)
def testGetScheduledChangesWithCompleted(self):
ret = self._get("/scheduled_changes/releases", qs={"all": 1})
expected = {
"count": 4,
"scheduled_changes": [
{
"sc_id": 1, "when": 4000000000, "scheduled_by": "bill", "change_type": "insert", "complete": False, "sc_data_version": 1,
"name": "m", "product": "m", "data": {"name": "m", "hashFunction": "sha512", "schema_version": 1}, "read_only": False,
"data_version": None, "signoffs": {}, "required_signoffs": {},
},
{
"sc_id": 2, "when": 6000000000, "scheduled_by": "bill", "change_type": "update", "complete": False, "sc_data_version": 1,
"name": "a", "product": "a", "data": {"name": "a", "hashFunction": "sha512", "schema_version": 1, "extv": "2.0"},
"read_only": False, "data_version": 1, "signoffs": {"bill": "releng"}, "required_signoffs": {"releng": 1},
},
{
"sc_id": 3, "when": 10000000, "scheduled_by": "bill", "change_type": "update", "complete": True, "sc_data_version": 2,
"name": "b", "product": "b", "data": {"name": "b", "hashFunction": "sha512", "schema_version": 1}, "read_only": False,
"data_version": 1, "signoffs": {}, "required_signoffs": {},
},
{
"sc_id": 4, "when": 230000000, "scheduled_by": "bill", "change_type": "delete", "complete": False, "sc_data_version": 1,
"name": "ab", "product": None, "data": None, "read_only": False, "data_version": 1, "signoffs": {"ben": "releng", "bill": "releng"},
"required_signoffs": {},
},
]
}
self.assertEquals(json.loads(ret.data), expected)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testAddScheduledChangeExistingRelease(self):
data = {
"when": 2300000000, "name": "d", "data": '{"name": "d", "hashFunction": "sha256", "schema_version": 1}',
"product": "d", "data_version": 1, "change_type": "update"
}
ret = self._post("/scheduled_changes/releases", data=data)
self.assertEquals(ret.status_code, 200, ret.data)
self.assertEquals(json.loads(ret.data), {"sc_id": 5})
r = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 5).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 5, "scheduled_by": "bill", "change_type": "update", "complete": False, "data_version": 1, "base_product": "d", "base_read_only": False,
"base_name": "d", "base_data": {"name": "d", "hashFunction": "sha256", "schema_version": 1}, "base_data_version": 1
}
self.assertEquals(db_data, expected)
cond = dbo.releases.scheduled_changes.conditions.t.select().where(dbo.releases.scheduled_changes.conditions.sc_id == 5).execute().fetchall()
self.assertEquals(len(cond), 1)
cond_expected = {"sc_id": 5, "data_version": 1, "when": 2300000000}
self.assertEquals(dict(cond[0]), cond_expected)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testAddScheduledChangeDeleteRelease(self):
data = {
"when": 4200000000, "name": "d", "data_version": 1, "change_type": "delete",
}
ret = self._post("/scheduled_changes/releases", data=data)
self.assertEquals(ret.status_code, 200, ret.data)
self.assertEquals(json.loads(ret.data), {"sc_id": 5})
r = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 5).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 5, "scheduled_by": "bill", "change_type": "delete", "complete": False, "data_version": 1, "base_product": None, "base_read_only": False,
"base_name": "d", "base_data": None, "base_data_version": 1,
}
self.assertEquals(db_data, expected)
cond = dbo.releases.scheduled_changes.conditions.t.select().where(dbo.releases.scheduled_changes.conditions.sc_id == 5).execute().fetchall()
self.assertEquals(len(cond), 1)
cond_expected = {"sc_id": 5, "data_version": 1, "when": 4200000000}
self.assertEquals(dict(cond[0]), cond_expected)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testAddScheduledChangeNewRelease(self):
data = {
"when": 5200000000, "name": "q", "data": '{"name": "q", "hashFunction": "sha512", "schema_version": 1}',
"product": "q", "change_type": "insert",
}
ret = self._post("/scheduled_changes/releases", data=data)
self.assertEquals(ret.status_code, 200, ret.data)
self.assertEquals(json.loads(ret.data), {"sc_id": 5})
r = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 5).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 5, "scheduled_by": "bill", "change_type": "insert", "complete": False, "data_version": 1, "base_product": "q", "base_read_only": False,
"base_name": "q", "base_data": {"name": "q", "hashFunction": "sha512", "schema_version": 1}, "base_data_version": None,
}
self.assertEquals(db_data, expected)
cond = dbo.releases.scheduled_changes.conditions.t.select().where(dbo.releases.scheduled_changes.conditions.sc_id == 5).execute().fetchall()
self.assertEquals(len(cond), 1)
cond_expected = {"sc_id": 5, "data_version": 1, "when": 5200000000}
self.assertEquals(dict(cond[0]), cond_expected)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testUpdateScheduledChangeExistingRelease(self):
data = {
"data": '{"name": "a", "hashFunction": "sha512", "extv": "3.0", "schema_version": 1}', "name": "a",
"data_version": 1, "sc_data_version": 1, "when": 78900000000, "change_type": "update",
}
ret = self._post("/scheduled_changes/releases/2", data=data)
self.assertEquals(ret.status_code, 200, ret.data)
self.assertEquals(json.loads(ret.data), {"new_data_version": 2})
r = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 2).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 2, "complete": False, "change_type": "update", "data_version": 2, "scheduled_by": "bill", "base_name": "a", "base_product": "a",
"base_read_only": False, "base_data": {"name": "a", "hashFunction": "sha512", "extv": "3.0", "schema_version": 1},
"base_data_version": 1,
}
self.assertEquals(db_data, expected)
cond = dbo.releases.scheduled_changes.conditions.t.select().where(dbo.releases.scheduled_changes.conditions.sc_id == 2).execute().fetchall()
self.assertEquals(len(cond), 1)
cond_expected = {"sc_id": 2, "data_version": 2, "when": 78900000000}
self.assertEquals(dict(cond[0]), cond_expected)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testUpdateScheduledChangeExistingReleaseResetSignOffs(self):
data = {
"name": "ab", "data_version": 1, "sc_data_version": 1, "when": 88900000000, "change_type": "delete"
}
rows = dbo.releases.scheduled_changes.signoffs.t.select().\
where(dbo.releases.scheduled_changes.signoffs.sc_id == 4).execute().fetchall()
self.assertEquals(len(rows), 2)
ret = self._post("/scheduled_changes/releases/4", data=data)
self.assertEquals(ret.status_code, 200, ret.data)
self.assertEquals(json.loads(ret.data), {"new_data_version": 2})
r = dbo.releases.scheduled_changes.t.select().where(
dbo.releases.scheduled_changes.sc_id == 4).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 4, "complete": False, "change_type": "delete", "data_version": 2, "scheduled_by": "bill",
"base_name": "ab", "base_product": None,
"base_read_only": False,
"base_data": None,
"base_data_version": 1,
}
self.assertEquals(db_data, expected)
rows = dbo.releases.scheduled_changes.signoffs.t.select(). \
where(dbo.releases.scheduled_changes.signoffs.sc_id == 4).execute().fetchall()
self.assertEquals(len(rows), 0)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testUpdateScheduledChangeExistingDeleteRelease(self):
data = {
"name": "c",
"data_version": 1, "sc_data_version": 1, "when": 78900000000, "change_type": "delete"
}
ret = self._post("/scheduled_changes/releases/4", data=data)
self.assertEquals(ret.status_code, 200, ret.data)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testUpdateCompletedScheduledChangeDeleteRelease(self):
data = {
"name": "c",
"data_version": 1, "sc_data_version": 1, "when": 78900000000, "change_type": "delete"
}
ret = self._post("/scheduled_changes/releases/3", data=data)
self.assertEquals(ret.status_code, 400, ret.data)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testUpdateCompletedScheduledChangeUpdatingTheRelease(self):
data = {
"data": '{"name": "c", "hashFunction": "sha512", "extv": "3.0", "schema_version": 1}', "name": "c",
"data_version": 1, "sc_data_version": 1, "when": 78900000000, "change_type": "update",
}
ret = self._post("/scheduled_changes/releases/3", data=data)
self.assertEquals(ret.status_code, 400, ret.data)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testUpdateScheduledChangeNewRelease(self):
data = {
"data": '{"name": "m", "hashFunction": "sha512", "appv": "4.0", "schema_version": 1}', "name": "m", "product": "m",
"sc_data_version": 1, "change_type": "insert",
}
ret = self._post("/scheduled_changes/releases/1", data=data)
self.assertEquals(ret.status_code, 200, ret.data)
self.assertEquals(json.loads(ret.data), {"new_data_version": 2})
r = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 1).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 1, "complete": False, "change_type": "insert", "data_version": 2, "scheduled_by": "bill", "base_name": "m", "base_product": "m",
"base_read_only": False, "base_data": {"name": "m", "hashFunction": "sha512", "appv": "4.0", "schema_version": 1},
"base_data_version": None,
}
self.assertEquals(db_data, expected)
cond = dbo.releases.scheduled_changes.conditions.t.select().where(dbo.releases.scheduled_changes.conditions.sc_id == 1).execute().fetchall()
self.assertEquals(len(cond), 1)
cond_expected = {"sc_id": 1, "data_version": 2, "when": 4000000000}
self.assertEquals(dict(cond[0]), cond_expected)
@mock.patch("time.time", mock.MagicMock(return_value=300))
def testUpdateScheduledChangeNewReleaseChangeName(self):
data = {
"data": '{"name": "mm", "hashFunction": "sha512", "appv": "4.0", "schema_version": 1}', "name": "mm", "product": "mm",
"sc_data_version": 1, "change_type": "insert",
}
ret = self._post("/scheduled_changes/releases/1", data=data)
self.assertEquals(ret.status_code, 200, ret.data)
self.assertEquals(json.loads(ret.data), {"new_data_version": 2})
r = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 1).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 1, "complete": False, "change_type": "insert", "data_version": 2, "scheduled_by": "bill", "base_name": "mm", "base_product": "mm",
"base_read_only": False, "base_data": {"name": "mm", "hashFunction": "sha512", "appv": "4.0", "schema_version": 1},
"base_data_version": None,
}
self.assertEquals(db_data, expected)
cond = dbo.releases.scheduled_changes.conditions.t.select().where(dbo.releases.scheduled_changes.conditions.sc_id == 1).execute().fetchall()
self.assertEquals(len(cond), 1)
cond_expected = {"sc_id": 1, "data_version": 2, "when": 4000000000}
self.assertEquals(dict(cond[0]), cond_expected)
def testDeleteScheduledChange(self):
ret = self._delete("/scheduled_changes/releases/2", qs={"data_version": 1})
self.assertEquals(ret.status_code, 200, ret.data)
got = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 2).execute().fetchall()
self.assertEquals(got, [])
cond_got = dbo.releases.scheduled_changes.conditions.t.select().where(dbo.releases.scheduled_changes.conditions.sc_id == 2).execute().fetchall()
self.assertEquals(cond_got, [])
def testEnactScheduledChangeExistingRelease(self):
ret = self._post("/scheduled_changes/releases/2/enact")
self.assertEquals(ret.status_code, 200, ret.data)
r = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 2).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 2, "complete": True, "data_version": 2, "scheduled_by": "bill", "change_type": "update", "base_name": "a", "base_product": "a",
"base_read_only": False, "base_data": {"name": "a", "hashFunction": "sha512", "schema_version": 1, "extv": "2.0"},
"base_data_version": 1,
}
self.assertEquals(db_data, expected)
base_row = dict(dbo.releases.t.select().where(dbo.releases.name == "a").execute().fetchall()[0])
base_expected = {
"name": "a", "product": "a", "read_only": False,
"data": {"name": "a", "hashFunction": "sha512", "schema_version": 1, "extv": "2.0"}, "data_version": 2,
}
self.assertEquals(base_row, base_expected)
def testEnactScheduledChangeNewRelease(self):
ret = self._post("/scheduled_changes/releases/1/enact")
self.assertEquals(ret.status_code, 200, ret.data)
r = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 1).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 1, "complete": True, "data_version": 2, "scheduled_by": "bill", "change_type": "insert", "base_name": "m", "base_product": "m",
"base_read_only": False, "base_data": {"name": "m", "hashFunction": "sha512", "schema_version": 1},
"base_data_version": None,
}
self.assertEquals(db_data, expected)
base_row = dict(dbo.releases.t.select().where(dbo.releases.name == "m").execute().fetchall()[0])
base_expected = {
"name": "m", "product": "m", "read_only": False,
"data": {"name": "m", "hashFunction": "sha512", "schema_version": 1}, "data_version": 1,
}
self.assertEquals(base_row, base_expected)
def testEnactScheduledChangeDeleteRelease(self):
ret = self._post("/scheduled_changes/releases/4/enact")
self.assertEquals(ret.status_code, 200, ret.data)
r = dbo.releases.scheduled_changes.t.select().where(dbo.releases.scheduled_changes.sc_id == 4).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
expected = {
"sc_id": 4, "complete": True, "data_version": 2, "scheduled_by": "bill", "change_type": "delete", "base_name": "ab", "base_product": None,
"base_read_only": False, "base_data": None, "base_data_version": 1,
}
self.assertEquals(db_data, expected)
base_row = dbo.releases.t.select().where(dbo.releases.name == "ab").execute().fetchall()
self.assertEquals(len(base_row), 0)
def testGetScheduledChangeHistoryRevisions(self):
ret = self._get("/scheduled_changes/releases/3/revisions")
self.assertEquals(ret.status_code, 200, ret.data)
ret = json.loads(ret.data)
expected = {
"count": 2,
"revisions": [
{
"change_id": 7, "changed_by": "bill", "timestamp": 25, "sc_id": 3, "scheduled_by": "bill", "change_type": "update", "data_version": 1,
"name": "b", "product": "b", "data": {"name": "b", "hashFunction": "sha512", "schema_version": 1}, "read_only": False,
"complete": True, "when": 10000000, "sc_data_version": 2,
},
{
"change_id": 6, "changed_by": "bill", "timestamp": 7, "sc_id": 3, "scheduled_by": "bill", "change_type": "update", "data_version": 1,
"name": "b", "product": "b", "data": {"name": "b", "hashFunction": "sha512", "schema_version": 1}, "read_only": False,
"complete": False, "when": 10000000, "sc_data_version": 1,
},
],
}
self.assertEquals(ret, expected)
@mock.patch("time.time", mock.MagicMock(return_value=100))
def testSignoffWithPermission(self):
ret = self._post("/scheduled_changes/releases/1/signoffs", data=dict(role="qa"), username="bill")
self.assertEquals(ret.status_code, 200, ret.data)
r = dbo.releases.scheduled_changes.signoffs.t.select().where(dbo.releases.scheduled_changes.signoffs.sc_id == 1).execute().fetchall()
self.assertEquals(len(r), 1)
db_data = dict(r[0])
self.assertEquals(db_data, {"sc_id": 1, "username": "bill", "role": "qa"})
r = dbo.releases.scheduled_changes.signoffs.history.t.select().where(dbo.releases.scheduled_changes.signoffs.history.sc_id == 1).execute().fetchall()
self.assertEquals(len(r), 2)
self.assertEquals(dict(r[0]), {"change_id": 3, "changed_by": "bill", "timestamp": 99999, "sc_id": 1, "username": "bill", "role": None})
self.assertEquals(dict(r[1]), {"change_id": 4, "changed_by": "bill", "timestamp": 100000, "sc_id": 1, "username": "bill", "role": "qa"})
def testSignoffWithoutPermission(self):
ret = self._post("/scheduled_changes/releases/1/signoffs", data=dict(role="relman"), username="bill")
self.assertEquals(ret.status_code, 403, ret.data)
def testSignoffWithoutRole(self):
ret = self._post("/scheduled_changes/releases/1/signoffs", data=dict(lorem="random"), username="bill")
self.assertEquals(ret.status_code, 400, ret.data)
def testRevokeSignoff(self):
ret = self._delete("/scheduled_changes/releases/2/signoffs", username="bill")
self.assertEquals(ret.status_code, 200, ret.data)
r = dbo.releases.scheduled_changes.signoffs.t.select().where(dbo.releases.scheduled_changes.signoffs.sc_id == 1).execute().fetchall()
self.assertEquals(len(r), 0)
class TestReleaseHistoryView(ViewTest):
def testGetRevisions(self):
# Make some changes to a release
data = json.dumps(dict(detailsUrl='blah', fakePartials=True, schema_version=1))
ret = self._post(
'/releases/d',
data=dict(
data=data,
product='d',
data_version=1,
)
)
self.assertStatusCode(ret, 200)
ret = self._post(
'/releases/d',
data=dict(
data=data,
product='d',
data_version=2,
)
)
self.assertStatusCode(ret, 200)
url = '/releases/d/revisions'
ret = self._get(url)
self.assertEquals(ret.status_code, 200, msg=ret.data)
data = json.loads(ret.data)
self.assertEquals(data["count"], 2)
self.assertEquals(len(data["revisions"]), 2)
with self.assertRaises(KeyError):
data['data']
def testPostRevisionRollback(self):
# Make some changes to a release
data = json.dumps(dict(detailsUrl='beep', fakePartials=True, schema_version=1))
ret = self._post(
'/releases/d',
data=dict(
data=data,
product='d',
data_version=1,
)
)
self.assertStatusCode(ret, 200)
data = json.dumps(dict(detailsUrl='boop', fakePartials=False, schema_version=1))
ret = self._post(
'/releases/d',
data=dict(
data=data,
product='d',
data_version=2,
)
)
self.assertStatusCode(ret, 200)
table = dbo.releases
row, = table.select(where=[table.name == 'd'])
self.assertEqual(row['data_version'], 3)
data = row['data']
self.assertEqual(data['fakePartials'], False)
self.assertEqual(data['detailsUrl'], 'boop')
query = table.history.t.count()
count, = query.execute().first()
self.assertEqual(count, 2)
row, = table.history.select(
where=[(table.history.product == 'd') & (table.history.data_version == 2)],
limit=1
)
change_id = row['change_id']
assert row['name'] == 'd' # one of the fixtures
url = '/releases/d/revisions'
ret = self._post(url, {'change_id': change_id})
self.assertEquals(ret.status_code, 200, ret.data)
query = table.history.t.count()
count, = query.execute().first()
self.assertEqual(count, 3)
row, = table.select(where=[table.name == 'd'])
self.assertEqual(row['data_version'], 4)
data = row['data']
self.assertEqual(data['fakePartials'], True)
self.assertEqual(data['detailsUrl'], 'beep')
def testPostRevisionRollbackBadRequests(self):
data = json.dumps(dict(detailsUrl='beep', fakePartials=True, schema_version=1))
ret = self._post(
'/releases/d',
data=dict(
data=data,
product='d',
data_version=1,
)
)
self.assertStatusCode(ret, 200)
# when posting you need both the release name and the change_id
ret = self._post('/releases/CRAZYNAME/revisions', data={'change_id': 1})
self.assertEquals(ret.status_code, 404, ret.data)
url = '/releases/d/revisions'
ret = self._post(url, {'change_id': 999})
self.assertEquals(ret.status_code, 400)
ret = self._post(url)
self.assertEquals(ret.status_code, 400)
class TestSingleColumn_JSON(ViewTest):
def testGetReleasesSingleColumn(self):
expected_product = ["a", "c", "b", "d"]
expected = dict(count=4, product=expected_product)
ret = self._get("/releases/columns/product")
ret_data = json.loads(ret.data)
self.assertEquals(ret_data['count'], expected['count'])
self.assertEquals(ret_data['product'].sort(), expected['product'].sort())
def testGetReleaseColumn404(self):
ret = self.client.get("/releases/columns/blah")
self.assertEquals(ret.status_code, 404)
class TestReadOnlyView(ViewTest):
def testReadOnlyGet(self):
ret = self._get('/releases/b/read_only')
is_read_only = dbo.releases.t.select(dbo.releases.name == 'b').execute().first()['read_only']
self.assertEqual(json.loads(ret.data)['read_only'], is_read_only)
def testReadOnlySetTrueAdmin(self):
data = dict(name='b', read_only=True, product='b', data_version=1)
ret = self._put('/releases/b/read_only', username='bill', data=data)
self.assertStatusCode(ret, 201)
read_only = dbo.releases.isReadOnly(name='b')
self.assertEqual(read_only, True)
def testReadOnlySetTrueNonAdmin(self):
data = dict(name='b', read_only=True, product='b', data_version=1)
ret = self._put('/releases/b/read_only', username='bob', data=data)
self.assertStatusCode(ret, 201)
read_only = dbo.releases.isReadOnly(name='b')
self.assertEqual(read_only, True)
def testReadOnlySetFalseAdmin(self):
dbo.releases.t.update(values=dict(read_only=True, data_version=2)).where(dbo.releases.name == "a").execute()
data = dict(name='b', read_only='', product='b', data_version=2)
ret = self._put('/releases/b/read_only', username='bill', data=data)
self.assertStatusCode(ret, 201)
read_only = dbo.releases.isReadOnly(name='b')
self.assertEqual(read_only, False)
def testReadOnlyUnsetWithoutPermissionForProduct(self):
dbo.releases.t.update(values=dict(read_only=True, data_version=2)).where(dbo.releases.name == "a").execute()
data = dict(name='b', read_only='', product='b', data_version=2)
ret = self._put('/releases/b/read_only', username='me', data=data)
self.assertStatusCode(ret, 403)
def testReadOnlyAdminSetAndUnsetFlag(self):
# Setting flag
data = dict(name='b', read_only=True, product='b', data_version=1)
ret = self._put('/releases/b/read_only', username='bill', data=data)
self.assertStatusCode(ret, 201)
# Resetting flag
data = dict(name='b', read_only='', product='b', data_version=2)
ret = self._put('/releases/b/read_only', username='bill', data=data)
self.assertStatusCode(ret, 201)
# Verify reset
read_only = dbo.releases.isReadOnly(name='b')
self.assertEqual(read_only, False)
def testReadOnlyNonAdminCanSetFlagButNotUnset(self):
# Setting read only flag
data_set = dict(name='b', read_only=True, product='b', data_version=1)
ret = self._put('/releases/b/read_only', username='bob', data=data_set)
self.assertStatusCode(ret, 201)
# Verifying if flag was set to true
read_only = dbo.releases.isReadOnly(name='b')
self.assertEqual(read_only, True)
# Resetting flag, which should fail with 403
data_unset = dict(name='b', read_only='', product='b', data_version=2)
ret = self._put('/releases/b/read_only', username='bob', data=data_unset)
self.assertStatusCode(ret, 403)
class TestRuleIdsReturned(ViewTest):
def testPresentRuleIdField(self):
releases = self._get("/releases")
releases_data = json.loads(releases.data)
self.assertTrue('rule_ids' in releases_data['releases'][0])
def testMappingIncluded(self):
rel_name = 'ab'
rule_id = 8
releases = self._get("/releases")
releases_data = json.loads(releases.data)
not_mapped_rel = next(rel for rel in releases_data['releases'] if rel['name'] == rel_name)
self.assertEqual(len(not_mapped_rel['rule_ids']), 0)
self.assertFalse(rule_id in not_mapped_rel['rule_ids'])
dbo.rules.t.insert().execute(id=rule_id, priority=100, version='3.5', buildTarget='d',
backgroundRate=100, mapping=rel_name, update_type='minor', data_version=1)
releases = self._get("/releases")
releases_data = json.loads(releases.data)
mapped_rel = next(rel for rel in releases_data['releases'] if rel['name'] == rel_name)
self.assertEqual(len(mapped_rel['rule_ids']), 1)
self.assertTrue(rule_id in mapped_rel['rule_ids'])
| mpl-2.0 | -5,560,149,751,817,180,000 | 41.393636 | 157 | 0.531345 | false |
ForToffee/UnicornHAT | wordclock.py | 1 | 4259 | #!/usr/bin/env python
# wordclock.py by Carl Monk (@ForToffee)
# https://github.com/ForToffee/UnicornHAT
# no unicorns were harmed in the making of this code
import unicornhat as UH
import time
#global variables
hourPattern = []
minPattern = []
#pre-defined patterns - groups of x,y co-ords - 0,0 is bottom right with GPIO at bottom
fivePattern = [[7,6],[6,6],[4,6],[2,6]]
tenPattern = [[1,7],[1,6],[0,6]]
fiftPattern = [[7,6],[6,6],[5,6],[3,6],[2,6],[1,6],[0,6]]
twenPattern = [[5,7],[4,7],[3,7],[2,7],[1,7],[0,7]]
halfPattern = [[7,7],[6,7],[7,5],[6,5]]
pastPattern = [[4,5],[3,5],[2,5],[1,5]]
toPattern = [[1,5],[0,5]]
#function to light the pixels we need to display the time
#pixels is a list of pixels
def showTime(pixels):
UH.clear()
for coords in pixels:
UH.set_pixel(coords[0],coords[1],255,0,255) #magenta
UH.show() #once pixels set, call .show() to enable them
#function to light the '*' character to show seconds and minutes elapsing
def showTick(m):
colour = []
minPart = m % 5
# % is modulo which gives us the remainder of m divided by 5
# this tells us the value 0 - 4 or the part of 5 minutes the time is
if m == -1: # for setting the '*' off or black
colour = [0,0,0]
elif minPart == 0: #:m0 or :m5
colour = [255,0,0] #red
elif minPart == 1 : #:m1 or :m6
colour = [0,255,0] #green
elif minPart == 2 : #:m2 or :m7
colour = [0,0,255] #blue
elif minPart == 3 : #:m3 or :m8
colour = [255,255,0] #yellow
elif minPart == 4 : #:m4 or :m9
colour = [0,255,255] #cyan
UH.set_pixel(5,5,colour[0],colour[1],colour[2]) #5,5 is the position of '*'
UH.show()
#takes the current hour and provides the required pattern of letters
def getHourPattern(h,m):
global hourPattern
hourPattern = []
#convert 24hr into 12hr
if h >= 12:
h -= 12
#if minutes > 35 then display will be 'to' the next hour
if m >= 35:
h = h + 1
#special case for 11:35 - 12:00. Hour is 0 to 11 so need to reset to 0
if h == 12:
h = 0
if h == 0: #aka Twelve
hourPattern = [[7,2],[6,2],[5,2],[4,2],[2,2],[1,2]]
elif h == 1:
hourPattern = [[7,3],[6,3],[5,3]]
elif h == 2:
hourPattern = [[7,2],[6,2],[6,1]]
elif h == 3:
hourPattern = [[4,3],[3,3],[2,3],[1,3],[0,3]]
elif h == 4:
hourPattern = [[7,1],[6,1],[5,1],[4,1]]
elif h == 5:
hourPattern = [[3,1],[2,1],[1,1],[0,1]]
elif h == 6:
hourPattern = [[7,0],[6,0],[5,0]]
elif h == 7:
hourPattern = [[4,0],[3,0],[2,0],[1,0],[0,0]]
elif h == 8:
hourPattern = [[4,4],[3,4],[2,4],[1,4],[0,4]]
elif h == 9:
hourPattern = [[7,4],[6,4],[5,4],[4,4]]
elif h == 10:
hourPattern = [[0,4],[0,3],[0,2]]
elif h == 11:
hourPattern = [[5,2],[4,2],[3,2],[2,2],[1,2],[0,2]]
#takes the current minute and provides the required pattern of letters
def getMinutePattern(m):
global minPattern
minPattern = []
if 10 > m >= 5 or m >= 55:
minPattern = fivePattern
elif 15 > m >= 10 or 55 > m >= 50:
minPattern = tenPattern
elif 20 > m >= 15 or 50 > m >= 45:
minPattern = fiftPattern
elif 25 > m >= 20 or 45 > m >= 40:
minPattern = twenPattern
elif 30 > m >= 25 or 40 > m >= 35:
minPattern = twenPattern + fivePattern
elif 35 > m >= 30:
minPattern = halfPattern
#if time between 5 and 34 we need to show 'past' the hour
if 35 > m >= 5:
minPattern = minPattern + pastPattern
elif m >= 35: #otherwise 'to' the hour
minPattern = minPattern + toPattern
#cycle through a full 12hrs minute by minute
def fullTest():
for n in range(12*60):
getHourPattern(n / 60, n % 60)
getMinutePattern(n % 60)
showTime(minPattern + hourPattern)
showTick(n)
time.sleep(.25)
#cycle through hours, then minutes
def quickTest():
for n in range(12):
getHourPattern(n, 0)
showTime(hourPattern)
time.sleep(.5)
for n in range(60):
getMinutePattern(n)
showTime(minPattern )
showTick(n)
time.sleep(.25)
#main function
quickTest()
#while True:
# fullTest()
while True:
#get time parts
h = time.localtime().tm_hour
m = time.localtime().tm_min
s = time.localtime().tm_sec
#get patterns
getHourPattern(h, m)
getMinutePattern(m)
#show patterns
showTime(minPattern + hourPattern)
#flash '*' to show time passing, lit every 2 seconds
if s % 2:
showTick(m)
else:
showTick(-1)
time.sleep(1)
| mit | 1,032,687,860,614,343,800 | 23.477011 | 87 | 0.61329 | false |
erikiado/jp2_online | familias/migrations/0004_alumno_tutor.py | 1 | 1205 | # -*- coding: utf-8 -*-
# Generated by Django 1.10.2 on 2017-02-23 05:32
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('familias', '0003_merge_20170223_0525'),
]
operations = [
migrations.CreateModel(
name='Alumno',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('activo', models.BooleanField(default=True)),
('integrante', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to='familias.Integrante')),
],
),
migrations.CreateModel(
name='Tutor',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('relacion', models.TextField(choices=[('madre', 'Madre'), ('padre', 'Padre'), ('tutor', 'Tutor')])),
('integrante', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to='familias.Integrante')),
],
),
]
| mit | -2,830,436,533,046,184,000 | 36.65625 | 124 | 0.587552 | false |
spnow/grr | gui/plugins/cron_view_test.py | 1 | 16455 | #!/usr/bin/env python
# -*- mode: python; encoding: utf-8 -*-
# Copyright 2012 Google Inc. All Rights Reserved.
"""Test the cron_view interface."""
import time
from grr.gui import runtests_test
from grr.lib import aff4
from grr.lib import config_lib
from grr.lib import flags
from grr.lib import rdfvalue
from grr.lib import test_lib
from grr.lib.aff4_objects import cronjobs
class TestCronView(test_lib.GRRSeleniumTest):
"""Test the Cron view GUI."""
def AddJobStatus(self, job, status):
with self.ACLChecksDisabled():
with aff4.FACTORY.OpenWithLock("aff4:/cron/OSBreakDown",
token=self.token) as job:
job.Set(job.Schema.LAST_RUN_TIME(rdfvalue.RDFDatetime().Now()))
job.Set(job.Schema.LAST_RUN_STATUS(status=status))
def setUp(self):
super(TestCronView, self).setUp()
with self.ACLChecksDisabled():
cronjobs.ScheduleSystemCronFlows(token=self.token)
cronjobs.CRON_MANAGER.RunOnce(token=self.token)
def testCronView(self):
self.Open("/")
self.WaitUntil(self.IsElementPresent, "client_query")
self.Click("css=a[grrtarget=ManageCron]")
# Table should contain Last Run
self.WaitUntil(self.IsTextPresent, "Last Run")
# Table should contain system cron jobs
self.WaitUntil(self.IsTextPresent, "GRRVersionBreakDown")
self.WaitUntil(self.IsTextPresent, "LastAccessStats")
self.WaitUntil(self.IsTextPresent, "OSBreakDown")
# Select a Cron.
self.Click("css=td:contains('OSBreakDown')")
# Check that there's one flow in the list.
self.WaitUntil(self.IsElementPresent,
"css=#main_bottomPane td:contains('OSBreakDown')")
def testMessageIsShownWhenNoCronJobSelected(self):
self.Open("/")
self.WaitUntil(self.IsElementPresent, "client_query")
self.Click("css=a[grrtarget=ManageCron]")
self.WaitUntil(self.IsTextPresent,
"Please select a cron job to see the details.")
def testShowsCronJobDetailsOnClick(self):
self.Open("/")
self.Click("css=a[grrtarget=ManageCron]")
self.Click("css=td:contains('OSBreakDown')")
# Tabs should appear in the bottom pane
self.WaitUntil(self.IsElementPresent, "css=#main_bottomPane #Details")
self.WaitUntil(self.IsElementPresent, "css=#main_bottomPane #Flows")
self.WaitUntil(self.IsTextPresent, "CURRENT_FLOW_URN")
self.WaitUntil(self.IsTextPresent, "CRON_ARGS")
# Click on "Flows" tab
self.Click("css=#main_bottomPane #Flows")
# Click on the first flow and wait for flow details panel to appear.
self.Click("css=#main_bottomPane td:contains('OSBreakDown')")
self.WaitUntil(self.IsTextPresent, "FLOW_STATE")
self.WaitUntil(self.IsTextPresent, "next_states")
self.WaitUntil(self.IsTextPresent, "outstanding_requests")
# Close the panel.
self.Click("css=#main_bottomPane .panel button.close")
self.WaitUntilNot(self.IsTextPresent, "FLOW_STATE")
self.WaitUntilNot(self.IsTextPresent, "next_states")
self.WaitUntilNot(self.IsTextPresent, "outstanding_requests")
def testToolbarStateForDisabledCronJob(self):
with self.ACLChecksDisabled():
cronjobs.CRON_MANAGER.DisableJob(
rdfvalue.RDFURN("aff4:/cron/OSBreakDown"))
self.Open("/")
self.Click("css=a[grrtarget=ManageCron]")
self.Click("css=td:contains('OSBreakDown')")
self.assertTrue(self.IsElementPresent(
"css=button[name=EnableCronJob]:not([disabled])"))
self.assertTrue(self.IsElementPresent(
"css=button[name=DisableCronJob][disabled]"))
self.assertTrue(self.IsElementPresent(
"css=button[name=DeleteCronJob]:not([disabled])"))
def testToolbarStateForEnabledCronJob(self):
with self.ACLChecksDisabled():
cronjobs.CRON_MANAGER.EnableJob(
rdfvalue.RDFURN("aff4:/cron/OSBreakDown"))
self.Open("/")
self.Click("css=a[grrtarget=ManageCron]")
self.Click("css=td:contains('OSBreakDown')")
self.assertTrue(self.IsElementPresent(
"css=button[name=EnableCronJob][disabled]"))
self.assertTrue(self.IsElementPresent(
"css=button[name=DisableCronJob]:not([disabled])"))
self.assertTrue(self.IsElementPresent(
"css=button[name=DeleteCronJob]:not([disabled])"))
def testEnableCronJob(self):
with self.ACLChecksDisabled():
cronjobs.CRON_MANAGER.DisableJob(
rdfvalue.RDFURN("aff4:/cron/OSBreakDown"))
self.Open("/")
self.Click("css=a[grrtarget=ManageCron]")
self.Click("css=td:contains('OSBreakDown')")
# Click on Enable button and check that dialog appears.
self.Click("css=button[name=EnableCronJob]")
self.WaitUntil(self.IsTextPresent,
"Are you sure you want to ENABLE this cron job?")
# Click on "Proceed" and wait for authorization dialog to appear.
self.Click("css=button[name=Proceed]")
# This should be rejected now and a form request is made.
self.WaitUntil(self.IsTextPresent, "Create a new approval")
self.Click("css=#acl_dialog button[name=Close]")
# Wait for dialog to disappear.
self.WaitUntilNot(self.IsVisible, "css=.modal-backdrop")
with self.ACLChecksDisabled():
self.GrantCronJobApproval(rdfvalue.RDFURN("aff4:/cron/OSBreakDown"))
# Click on Enable button and check that dialog appears.
self.Click("css=button[name=EnableCronJob]")
self.WaitUntil(self.IsTextPresent,
"Are you sure you want to ENABLE this cron job?")
# Click on "Proceed" and wait for success label to appear.
# Also check that "Proceed" button gets disabled.
self.Click("css=button[name=Proceed]")
self.WaitUntil(self.IsTextPresent, "Cron job was ENABLEd successfully!")
self.assertTrue(self.IsElementPresent("css=button[name=Proceed][disabled]"))
# Click on "Cancel" and check that dialog disappears.
self.Click("css=button[name=Cancel]")
self.WaitUntilNot(self.IsVisible, "css=.modal-backdrop")
# View should be refreshed automatically.
self.WaitUntil(self.IsTextPresent, "OSBreakDown")
self.WaitUntil(self.IsElementPresent,
"css=tr:contains('OSBreakDown') *[state=enabled]")
def testDisableCronJob(self):
with self.ACLChecksDisabled():
cronjobs.CRON_MANAGER.EnableJob(
rdfvalue.RDFURN("aff4:/cron/OSBreakDown"))
self.Open("/")
self.Click("css=a[grrtarget=ManageCron]")
self.Click("css=td:contains('OSBreakDown')")
# Click on Enable button and check that dialog appears.
self.Click("css=button[name=DisableCronJob]")
self.WaitUntil(self.IsTextPresent,
"Are you sure you want to DISABLE this cron job?")
# Click on "Proceed" and wait for authorization dialog to appear.
self.Click("css=button[name=Proceed]")
self.WaitUntil(self.IsTextPresent, "Create a new approval")
self.Click("css=#acl_dialog button[name=Close]")
# Wait for dialog to disappear.
self.WaitUntilNot(self.IsVisible, "css=.modal-backdrop")
with self.ACLChecksDisabled():
self.GrantCronJobApproval(rdfvalue.RDFURN("aff4:/cron/OSBreakDown"))
# Click on Disable button and check that dialog appears.
self.Click("css=button[name=DisableCronJob]")
self.WaitUntil(self.IsTextPresent,
"Are you sure you want to DISABLE this cron job?")
# Click on "Proceed" and wait for success label to appear.
# Also check that "Proceed" button gets disabled.
self.Click("css=button[name=Proceed]")
self.WaitUntil(self.IsTextPresent, "Cron job was DISABLEd successfully!")
self.assertTrue(self.IsElementPresent("css=button[name=Proceed][disabled]"))
# Click on "Cancel" and check that dialog disappears.
self.Click("css=button[name=Cancel]")
self.WaitUntilNot(self.IsVisible, "css=.modal-backdrop")
# View should be refreshed automatically.
self.WaitUntil(self.IsTextPresent, "OSBreakDown")
self.WaitUntil(self.IsElementPresent,
"css=tr:contains('OSBreakDown') *[state=disabled]")
def testDeleteCronJob(self):
with self.ACLChecksDisabled():
cronjobs.CRON_MANAGER.EnableJob(
rdfvalue.RDFURN("aff4:/cron/OSBreakDown"))
self.Open("/")
self.Click("css=a[grrtarget=ManageCron]")
self.Click("css=td:contains('OSBreakDown')")
# Click on Enable button and check that dialog appears.
self.Click("css=button[name=DeleteCronJob]")
self.WaitUntil(self.IsTextPresent,
"Are you sure you want to DELETE this cron job?")
# Click on "Proceed" and wait for authorization dialog to appear.
self.Click("css=button[name=Proceed]")
self.WaitUntil(self.IsTextPresent, "Create a new approval")
self.Click("css=#acl_dialog button[name=Close]")
# Wait for dialog to disappear.
self.WaitUntilNot(self.IsVisible, "css=.modal-backdrop")
with self.ACLChecksDisabled():
self.GrantCronJobApproval(rdfvalue.RDFURN("aff4:/cron/OSBreakDown"))
# Click on Disable button and check that dialog appears.
self.Click("css=button[name=DeleteCronJob]")
self.WaitUntil(self.IsTextPresent,
"Are you sure you want to DELETE this cron job?")
# Click on "Proceed" and wait for success label to appear.
# Also check that "Proceed" button gets disabled.
self.Click("css=button[name=Proceed]")
self.WaitUntil(self.IsTextPresent, "Cron job was DELETEd successfully!")
self.assertTrue(self.IsElementPresent("css=button[name=Proceed][disabled]"))
# Click on "Cancel" and check that dialog disappears.
self.Click("css=button[name=Cancel]")
self.WaitUntilNot(self.IsVisible, "css=.modal-backdrop")
# View should be refreshed automatically.
self.WaitUntil(self.IsElementPresent,
"css=#main_topPane td:contains('GRRVersionBreakDown')")
self.WaitUntilNot(self.IsElementPresent,
"css=#main_topPane td:contains('OSBreakDown')")
def testHuntSchedulingWorksCorrectly(self):
self.Open("/")
self.Click("css=a[grrtarget=ManageCron]")
self.Click("css=button[name=ScheduleHuntCronJob]")
self.WaitUntil(self.IsTextPresent, "What to run?")
# Click on Filesystem item in flows list
self.WaitUntil(self.IsElementPresent, "css=#_Filesystem > ins.jstree-icon")
self.Click("css=#_Filesystem > ins.jstree-icon")
# Click on Fetch Files item in Filesystem flows list
self.WaitUntil(self.IsElementPresent, "link=Fetch Files")
self.Click("link=Fetch Files")
# Wait for flow configuration form to be rendered (just wait for first
# input field).
self.WaitUntil(self.IsElementPresent,
"css=.Wizard input[id=args-paths-0]")
# Change "path", "pathtype", "depth" and "ignore_errors" values
self.Type("css=.Wizard input[id=args-paths-0]", "/tmp")
self.Select("css=.Wizard select[id=args-pathtype]", "TSK")
self.Type("css=.Wizard input[id=args-max_size]", "42")
# Click on "Next" button
self.Click("css=.Wizard button.Next")
self.WaitUntil(self.IsTextPresent, "Output Processing")
# Configure the hunt to use a collection and also send an email on results.
self.Click("css=.Wizard button:contains('Add Output Plugin')")
self.Select("css=.Wizard select[id=output_1-option]",
"Send an email for each result.")
self.Type("css=.Wizard input[id=output_1-email]",
"test@%s" % config_lib.CONFIG["Logging.domain"])
# Click on "Next" button
self.Click("css=.Wizard button.Next")
self.WaitUntil(self.IsTextPresent, "Where to run?")
# Create 3 foreman rules
self.WaitUntil(
self.IsElementPresent,
"css=.Wizard select[id=rule_1-option]")
self.Select("css=.Wizard select[id=rule_1-option]",
"Regular Expressions")
self.Select("css=.Wizard select[id=rule_1-attribute_name]",
"System")
self.Type("css=.Wizard input[id=rule_1-attribute_regex]",
"Linux")
# Make the button visible by scrolling to the bottom.
self.driver.execute_script("""
$("button:contains('Add Rule')").parent().scrollTop(10000)
""")
self.Click("css=.Wizard button:contains('Add Rule')")
self.Select("css=.Wizard select[id=rule_2-option]",
"Integer Rule")
self.Select("css=.Wizard select[id=rule_2-attribute_name]",
"Clock")
self.Select("css=.Wizard select[id=rule_2-operator]",
"GREATER_THAN")
self.Type("css=.Wizard input[id=rule_2-value]",
"1336650631137737")
# Make the button visible by scrolling to the bottom.
self.driver.execute_script("""
$("button:contains('Add Rule')").parent().scrollTop(10000)
""")
self.Click("css=.Wizard button:contains('Add Rule')")
self.Select("css=.Wizard select[id=rule_3-option]",
"OSX")
# Make the button visible by scrolling to the bottom.
self.driver.execute_script("""
$("button:contains('Add Rule')").parent().scrollTop(10000)
""")
# Click on "Next" button
self.Click("css=.Wizard button.Next")
self.WaitUntil(self.IsTextPresent, "When to run?")
# Select daily periodicity
self.Type("css=.Wizard input[id=cron-periodicity]", "1d")
# Click on "Next" button
self.Click("css=.Wizard button.Next")
self.WaitUntil(self.IsTextPresent, "Review")
# Check that the arguments summary is present.
self.assertTrue(self.IsTextPresent("Paths"))
self.assertTrue(self.IsTextPresent("/tmp"))
self.assertTrue(self.IsTextPresent("Max size"))
self.assertTrue(self.IsTextPresent("42"))
# Check that output plugins are shown.
self.assertTrue(self.IsTextPresent("EmailPlugin"))
self.assertTrue(self.IsTextPresent("test@%s" %
config_lib.CONFIG["Logging.domain"]))
# Check that rules summary is present.
self.assertTrue(self.IsTextPresent("Regex rules"))
# Check that periodicity information is present in the review.
self.assertTrue(self.IsTextPresent("Hunt Periodicity"))
self.assertTrue(self.IsTextPresent("Hunt will run 1d."))
# Click on "Schedule" button
self.Click("css=.Wizard button.Next")
# Anyone can schedule a hunt but we need an approval to actually start it.
self.WaitUntil(self.IsTextPresent,
"Hunt was successfully scheduled")
# Close the window and check that cron job object was created.
self.Click("css=button.Finish")
# Select newly created cron job.
self.Click("css=td:contains('cron/CreateGenericHuntFlow_')")
# Check that correct details are displayed in cron job details tab.
self.WaitUntil(self.IsTextPresent, "CreateGenericHuntFlow")
self.WaitUntil(self.IsTextPresent, "Flow args")
self.assertTrue(self.IsTextPresent("Paths"))
self.assertTrue(self.IsTextPresent("/tmp"))
self.assertTrue(self.IsTextPresent("Max size"))
self.assertTrue(self.IsTextPresent("42"))
def testStuckCronJobIsHighlighted(self):
# Make sure a lot of time has passed since the last
# execution
with test_lib.Stubber(time, "time", lambda: 0):
self.AddJobStatus("aff4:/cron/OSBreakDown",
rdfvalue.CronJobRunStatus.Status.OK)
self.Open("/")
self.WaitUntil(self.IsElementPresent, "client_query")
self.Click("css=a[grrtarget=ManageCron]")
# OSBreakDown's row should have a 'warn' class
self.WaitUntil(self.IsElementPresent,
"css=tr.warning td:contains('OSBreakDown')")
# Check that only OSBreakDown is highlighted
self.WaitUntilNot(self.IsElementPresent,
"css=tr.warning td:contains('GRRVersionBreakDown')")
def testFailingCronJobIsHighlighted(self):
for _ in range(4):
self.AddJobStatus("aff4:/cron/OSBreakDown",
rdfvalue.CronJobRunStatus.Status.ERROR)
self.Open("/")
self.WaitUntil(self.IsElementPresent, "client_query")
self.Click("css=a[grrtarget=ManageCron]")
# OSBreakDown's row should have an 'error' class
self.WaitUntil(self.IsElementPresent,
"css=tr.error td:contains('OSBreakDown')")
# Check that only OSBreakDown is highlighted
self.WaitUntilNot(self.IsElementPresent,
"css=tr.error td:contains('GRRVersionBreakDown')")
def main(argv):
# Run the full test suite
runtests_test.SeleniumTestProgram(argv=argv)
if __name__ == "__main__":
flags.StartMain(main)
| apache-2.0 | -7,085,412,603,742,628,000 | 36.397727 | 80 | 0.682528 | false |
ojosedo/programacion_morada | Pygame/juego/personaje.py | 1 | 11020 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Importa la librería de funciones llamada 'pygame'
import pygame
import pytmx
import copy
# Definimos algunos colores
NEGRO = [ 0, 0, 0]
BLANCO = [ 255, 255, 255]
VERDE = [ 0, 255, 0]
ROJO = [ 255, 0, 0]
# Constantes en mayúsculas
# Inicializa el motor de juegos
pygame.init()
ancho = 40
alto = 22
ancho_pixeles = 32 * ancho
alto_pixeles = 32 * alto
dimensiones = [ancho_pixeles, alto_pixeles]
# Abrir la pantalla (otra opción es open_window)
pantalla = pygame.display.set_mode(dimensiones)
pygame.display.set_caption("Mi primer juego")
# ESTE ES EL BUCLE PRINCIPAL DEL PROGRAMA
pygame.mouse.set_visible(False)
#Itera hasta que el usuario pincha sobre el botón de cierre.
hecho = False
informacion = False
# Se usa para gestionar cuan rápido se actualiza la pantalla
reloj = pygame.time.Clock()
class SpriteSheet(object):
""" Clase usada para sacar imágenes de la hoja de sprites."""
# inicializamos la hoja de sprites
sprite_sheet = None
def __init__(self, file_name):
""" Constructor. Le entra el nombre de archivo de la hoja
de sprites. """
# Carga la hoja de datos completa.
self.sprite_sheet = pygame.image.load(file_name).convert()
def get_image(self, fila, columna, ancho, alto):
""" retorna una única imagen
se le pasa la posición (x, y)
y el ancho y alto del sprite. """
# Crea una imagen en blanco
imagen = pygame.Surface([ancho, alto]).convert()
# Copia una parte de la hoja de sprites a la imagen
imagen.blit(self.sprite_sheet, (0, 0), (fila * ancho, columna * alto, ancho, alto))
# Asume que el negro es el color transparente
imagen.set_colorkey(NEGRO)
# Retorna la imagen
return imagen
hoja_completa = SpriteSheet("./imagenes/completa32.png")
class mapa(object):
"""en esta clase se definira el mapa"""
xmin = 0
xmax = 32*ancho
ymin = 0
ymax = 32*alto
#capas = 15
#personaje = 9
#datos = pytmx.load_pygame("./jardin.tmx")
def pintar_mapa(self,pantalla):
for capa in range(self.capas):
if capa == self.personaje:
for personaje in personajes:
personaje.pintese(pantalla)
else:
for x in range(ancho):
for y in range(alto):
imagen = self.datos.get_tile_image(x, y, capa)
if imagen==None:
continue
pantalla.blit(imagen, [x*32 , y*32])
def __init__(self, ruta, n_capas, c_personaje):
self.datos = pytmx.load_pygame(ruta)
self.capas = n_capas
self.personaje = c_personaje
def cambiar_mapa(self, ruta, n_capas, c_personaje):
self.datos = pytmx.load_pygame(ruta)
self.capas = n_capas
self.personaje = c_personaje
print("cambie el mapa, ", self)
class personaje(object):
"""este es tu personaje
le puedes dar atributos"""
direccion=""
x = ancho*16
y = alto*16
velocidad_x = 0
velocidad_y = 0
adelante = hoja_completa.get_image(3, 8, 32, 32)
derecha = hoja_completa.get_image(3,10,32,32)
izquierda = hoja_completa.get_image(3,9,32,32)
atras = hoja_completa.get_image(3,11,32,32)
imagen_actual = adelante
def cambiar_direccion(self,nueva_direccion):
if nueva_direccion == "derecha":
self.imagen_actual = self.derecha
self.direccion = "derecha"
if nueva_direccion == "izquierda":
self.imagen_actual = self.izquierda
self.direccion = "izquierda"
if nueva_direccion == "adelante":
self.imagen_actual = self.adelante
self.direccion = "adelante"
if nueva_direccion == "atras":
self.imagen_actual = self.atras
self.direccion = "atras"
def cambiar_velocidad(self, direccion, velocidad):
self.cambiar_direccion(direccion)
self.pare_seguro()
if direccion == "derecha":
self.velocidad_x += velocidad
if direccion == "izquierda":
self.velocidad_x -= velocidad
if direccion == "adelante":
self.velocidad_y += velocidad
if direccion == "atras":
self.velocidad_y -= velocidad
def pare(self, direccion):
if direccion == self.direccion:
self.velocidad_x = 0
self.velocidad_y = 0
def pare_seguro(self):
self.velocidad_x = 0
self.velocidad_y = 0
def muevase(self, mapa):
if (self.x + self.velocidad_x >= mapa.xmin
and self.x + self.velocidad_x + 16 <= mapa.xmax
and self.y + self.velocidad_y >= mapa.ymin
and self.y + self.velocidad_y + 16 <= mapa.ymax): #dentro del mapa
imagen = mapa.datos.get_tile_image((self.x+self.velocidad_x)//32, (self.y+self.velocidad_y)//32, 0)
if imagen==None:
self.x += self.velocidad_x
self.y += self.velocidad_y
def pintese(self, ventana):
ventana.blit(self.imagen_actual, [(self.x//32)*32, (self.y//32)*32]) #solo se pinta centrado en los cuadros, múltiplos de 32
def cambiar_apariencia(self, disfraz):
if disfraz == "niño":
self.adelante = hoja_completa.get_image(0, 8, 32, 32)
self.derecha = hoja_completa.get_image(0,10,32,32)
self.izquierda = hoja_completa.get_image(0,9,32,32)
self.atras = hoja_completa.get_image(0,11,32,32)
elif disfraz == "esqueleto":
self.adelante = hoja_completa.get_image(6, 8, 32, 32)
self.derecha = hoja_completa.get_image(6,10,32,32)
self.izquierda = hoja_completa.get_image(6,9,32,32)
self.atras = hoja_completa.get_image(6,11,32,32)
elif disfraz == "baba":
self.adelante = hoja_completa.get_image(0, 12, 32, 32)
self.derecha = hoja_completa.get_image(0,14,32,32)
self.izquierda = hoja_completa.get_image(0,13,32,32)
self.atras = hoja_completa.get_image(0,15,32,32)
elif disfraz == "murcielago":
self.adelante = hoja_completa.get_image(3, 12, 32, 32)
self.derecha = hoja_completa.get_image(3,14,32,32)
self.izquierda = hoja_completa.get_image(3,13,32,32)
self.atras = hoja_completa.get_image(3,15,32,32)
elif disfraz == "fantasma":
self.adelante = hoja_completa.get_image(6, 12, 32, 32)
self.derecha = hoja_completa.get_image(6,14,32,32)
self.izquierda = hoja_completa.get_image(6,13,32,32)
self.atras = hoja_completa.get_image(6,15,32,32)
elif disfraz == "araña":
self.adelante = hoja_completa.get_image(12, 12, 32, 32)
self.derecha = hoja_completa.get_image(12,14,32,32)
self.izquierda = hoja_completa.get_image(12,13,32,32)
self.atras = hoja_completa.get_image(12,15,32,32)
else:
self.adelante = hoja_completa.get_image(3, 8, 32, 32)
self.derecha = hoja_completa.get_image(3,10,32,32)
self.izquierda = hoja_completa.get_image(3,9,32,32)
self.atras = hoja_completa.get_image(3,11,32,32)
violeta = personaje()
monstruo1 = personaje()
monstruo1.cambiar_apariencia("esqueleto")
monstruo1.cambiar_velocidad("adelante", 5)
monstruo2 = personaje()
monstruo2.cambiar_apariencia("baba")
monstruo2.cambiar_velocidad("derecha", 5)
monstruo3 = personaje()
monstruo3.cambiar_apariencia("murcielago")
monstruo3.cambiar_velocidad("izquierda", 5)
monstruo4 = personaje()
monstruo4.cambiar_apariencia("fantasma")
monstruo4.cambiar_velocidad("atras", 5)
personajes = [violeta, monstruo1, monstruo2, monstruo3, monstruo4]
mapa_actual = mapa("./jardin.tmx", 15, 9)
jardin = mapa("./jardin.tmx", 15, 9)
laberinto = mapa("./laberinto.tmx", 13, 8)
def pintar_texto():
# Seleccionamos la fuente, tamaño, negrita, acostada
fuente = pygame.font.SysFont('Calibri', 25, True, False)
# Rendirazar, mi texto, suavizado, color
texto = fuente.render(str(violeta.x) + " " + str(violeta.y), True, NEGRO)
# Poner en pantalla el texto
pantalla.blit(texto, [0,0])
# -------- Bucle Principal del Programa -----------
while not hecho:
# TODOS LOS EVENTOS DE PROCESAMIENTO DEBERÍAN IR DEBAJO DE ESTE COMENTARIO
for evento in pygame.event.get(): # El usuario hizo algo
if evento.type == pygame.QUIT: # Si el usuario pincha sobre cerrar
hecho = True # Marca que indica que hemos acabado y sale de este bucle
if evento.type == pygame.MOUSEBUTTONDOWN:
pass
if evento.type==pygame.KEYDOWN:
if evento.key==pygame.K_UP:
violeta.cambiar_velocidad("atras", 5)
if evento.key==pygame.K_DOWN:
violeta.cambiar_velocidad("adelante", 5)
if evento.key==pygame.K_RIGHT:
violeta.cambiar_velocidad("derecha", 5)
if evento.key==pygame.K_LEFT:
violeta.cambiar_velocidad("izquierda", 5)
if evento.key==pygame.K_F3:
informacion = not informacion
mapa_actual = laberinto
if evento.key==pygame.K_F2:
mapa_actual = jardin
if evento.type==pygame.KEYUP:
if evento.key==pygame.K_UP:
violeta.pare("atras")
if evento.key==pygame.K_DOWN:
violeta.pare("adelante")
if evento.key==pygame.K_RIGHT:
violeta.pare("derecha")
if evento.key==pygame.K_LEFT:
violeta.pare("izquierda")
# TODOS LOS EVENTOS DE PROCESAMIENTO DEBERÍAN IR ENCIMA DE ESTE COMENTARIO
# TODA LA LÓGICA DEL JUEGO DEBERÍA IR DEBAJO DE ESTE COMENTARIO
for personaje in personajes:
personaje.muevase(mapa_actual)
# TODA LA LÓGICA DEL JUEGO DEBERÍA IR ENCIMA DE ESTE COMENTARIO
# TODO EL CÓDIGO DE DIBUJO DEBERÍA IR DEBAJO DE ESTE COMENTARIO
# Primero limpiamos pantalla. No dibujes por encima de esta linea
# o todo lo que escribas sera borrado por este comando.
pantalla.fill(BLANCO)
#todo(pasto,0,0,16,20)
#todo(pasto,0.5,0.5,15,19)
# pantalla.blit(pasto, [x, y])
mapa_actual.pintar_mapa(pantalla)
# DIBUJEMOS ALGUNAS FIGURAS
# DIBUJEMOS ALGUN TEXTO
if informacion:
pintar_texto()
# Avanza y actualiza la pantalla con lo que hemos dibujado.
pygame.display.flip()
# TODO EL CÓDIGO DE DIBUJO DEBERÍA IR ENCIMA DE ESTE COMENTARIO
# Limita a 20 fotogramas por segundo (frames per second)
reloj.tick(30)
# Cierra la ventana.
# Si olvidas poner esta linea el programa se 'colgara'.
pygame.quit()
| gpl-3.0 | 4,637,477,412,209,843,000 | 34.025478 | 132 | 0.602019 | false |
paul-jean/ud858 | Lesson_2/000_Hello_Endpoints/helloworld_api.py | 1 | 1742 | """Hello World API implemented using Google Cloud Endpoints.
Contains declarations of endpoint, endpoint methods,
as well as the ProtoRPC message class and container required
for endpoint method definition.
"""
import endpoints
from protorpc import messages
from protorpc import message_types
from protorpc import remote
# If the request contains path or querystring arguments,
# you cannot use a simple Message class.
# Instead, you must use a ResourceContainer class
REQUEST_CONTAINER = endpoints.ResourceContainer(
message_types.VoidMessage,
name=messages.StringField(1)
)
REQUEST_GREETING_CONTAINER = endpoints.ResourceContainer(
period=messages.StringField(1),
name=messages.StringField(2)
)
package = 'Hello'
class Hello(messages.Message):
"""String that stores a message."""
greeting = messages.StringField(1)
@endpoints.api(name='helloworldendpoints', version='v1')
class HelloWorldApi(remote.Service):
"""Helloworld API v1."""
@endpoints.method(message_types.VoidMessage, Hello,
path = "sayHello", http_method='GET', name = "sayHello")
def say_hello(self, request):
return Hello(greeting="Hello World")
@endpoints.method(REQUEST_CONTAINER, Hello,
path = "sayHelloByName", http_method='GET', name = "sayHelloByName")
def say_hello_by_name(self, request):
greet = "Hello {}".format(request.name)
return Hello(greeting=greet)
@endpoints.method(REQUEST_GREETING_CONTAINER, Hello,
path = "greetByPeriod", http_method='GET', name = "greetByPeriod")
def greet_by_period(self, request):
greet = "Good {}, {}!".format(request.period, request.name)
return Hello(greeting=greet)
APPLICATION = endpoints.api_server([HelloWorldApi])
| gpl-3.0 | -2,053,519,090,300,488,000 | 30.672727 | 74 | 0.729047 | false |
blurstudio/cross3d | cross3d/abstract/abstractapplication.py | 1 | 8664 | """
The AbstractApplication class will define all operations for application
interaction. It is a singleton class, so calling cross3d.Application() will
always return the same instance of Application. One of its main functions
is connecting application callbacks to cross3d.Dispatch. The
AbstractApplication is a QObject instance and any changes to the scene
data can be controlled by connecting to the signals defined here. When
subclassing the AbstractScene, methods tagged as @abstractmethod will be
required to be overwritten. Methods tagged with [virtual] are flagged
such that additional operations could be required based on the needs of
the method. All @abstractmethod methods MUST be implemented in a subclass.
"""
import re
import cross3d
from PyQt4.QtCore import QObject
from cross3d import abstractmethod
from contextlib import contextmanager
dispatch = None
class AbstractApplication(QObject):
"""
The Application class will define all operations for application
interaction. It is a singleton class, so calling cross3d.Application() will
always return the same instance of Application. One of its main functions
is connecting application callbacks to cross3d.Dispatch. The
Application is a QObject instance and any changes to the scene
data can be controlled by connecting to the signals defined here. When
subclassing the Scene, methods tagged as @abstractmethod will be
required to be overwritten. Methods tagged with [virtual] are flagged
such that additional operations could be required based on the needs of
the method. All @abstractmethod methods MUST be implemented in a subclass.
"""
_instance = None
_blockRefresh = False
def __init__(self):
QObject.__init__(self)
self._objectToBeDeleted = None
def connect(self):
"""
Responsible for setting up the application to connect to signals
using :meth:`cross3d.Dispatch.connectCallback`. Connect is
called when the first :class:`cross3d.Dispatch` signal is
connected.
:return: connection success
:rtype: bool
"""
# create a signal linking between 2 signals
import cross3d
global dispatch
dispatch = cross3d.dispatch
dispatch.linkSignals('sceneNewRequested', 'scenePreInvalidated')
dispatch.linkSignals('sceneOpenRequested', 'scenePreInvalidated')
dispatch.linkSignals('sceneMergeRequested', 'scenePreInvalidated')
# dispatch.linkSignals('sceneReferenceRequested', 'scenePreInvalidated')
dispatch.linkSignals('scenePreReset', 'scenePreInvalidated')
dispatch.linkSignals('sceneImportRequested', 'scenePreInvalidated')
dispatch.linkSignals('sceneNewFinished', 'sceneInvalidated')
dispatch.linkSignals('sceneOpenFinished', 'sceneInvalidated')
dispatch.linkSignals('sceneMergeFinished', 'sceneInvalidated')
# dispatch.linkSignals('sceneReferenceFinished', 'sceneInvalidated')
dispatch.linkSignals('sceneReset', 'sceneInvalidated')
dispatch.linkSignals('sceneImportFinished', 'sceneInvalidated')
dispatch.linkSignals('objectCreated', 'newObject')
dispatch.linkSignals('objectCloned', 'newObject')
dispatch.linkSignals('objectAdded', 'newObject')
return True
@abstractmethod
def imageSequenceRegex(self):
return re.compile('')
def conformObjectName(self, name):
return re.sub('[^%s]' % self.allowedCharacters(), '_', name)
@abstractmethod
def allowedCharacters(self):
return '.'
def clipboardCopyText(self, text):
""" Set the provided text to the system clipboard so it can be pasted
This function is used because QApplication.clipboard sometimes deadlocks in some
applications like XSI.
Args:
text (str): Set the text in the paste buffer to this text.
"""
from PyQt4.QtGui import QApplication
QApplication.clipboard().setText(text)
@abstractmethod
def connectCallback(self, signal):
"""
Connects a single callback. This allows cross3d to only have to
respond to callbacks that tools actually need, instead of all
callbacks. Called the first time a signal is connected to
this callback.
"""
return
def disconnect(self):
"""
Responsible for disabling all changes made in
:meth:`cross3d.Application.connect`. Disconnect is called when
the last :class:`cross3d.Dispatch` signal is disconnected.
"""
return
@abstractmethod
def disconnectCallback(self, signal):
"""
Disconnect a single callback when it is no longer used. Called
when the last signal for this callback is disconnected.
"""
return
def preDeleteObject(self, *args):
"""
Pre-process the object that is going to be deleted.
"""
return
def postDeleteObject(self, *args):
"""
Emits the signal that a object has been deleted. This method is
used for applications like max that generate a pre and post
delete signal.
"""
dispatch.objectPostDelete.emit()
@abstractmethod
def year(self):
"""
Returns the version year of the software.
:return: version number
:rtyp: int
"""
return 0
@abstractmethod
def version(self, major=True):
"""
Returns the version of the software.
:return: version number
:rtyp: various
"""
return 0 if major else '0.0.0'
@abstractmethod
def autokey(self):
return False
@abstractmethod
def exportAlembic(self, filename, **kwargs):
return False
@abstractmethod
def importAlembic(self, filename, **kwargs):
return False
@abstractmethod
def installDir(self):
""" Returns the path to the current application's install directory.
:return: path string
:rtyp: str
"""
import sys
import os
return os.path.dirname(sys.executable)
@abstractmethod
def nameSpaceSeparator(self):
return ''
@abstractmethod
def name(self):
"""
Returns the unique name of the software.
"""
return ''
@abstractmethod
def refresh(self):
return False
@abstractmethod
def id(self):
"""
Returns a unique version/bits string information that will
represent the exact version of the software being run.
:rtype: str
"""
return ''
@abstractmethod
def animationClipExtension(self):
return ''
@abstractmethod
def sceneFileExtension(self):
return ''
@abstractmethod
def modelFileExtension(self):
return ''
@abstractmethod
def nameAndVersion(self):
"""
Returns the unique name and version format needed for Assburner.
:rtype: str
"""
return ''
@abstractmethod
def log(self, message):
print message
def isSilent(self):
"""
Returns whether the application is currently running in silent mode.
"""
return False
def undoContext(self, name):
"""
Returns a context guard for the undo stack. Everything that takes
place within this context guard will appear as a single undo
operation in the stack.
"""
return cross3d.UndoContext(name)
def openUndo(self, name):
"""
Opens a new undo context. It is important that the user takes care
to call closeUndo() to close the context, even if an error or
exception occurs; otherwise, the undo stack will remain open and
unusable.
"""
cross3d.UndoContext.openUndo(name)
def closeUndo(self):
"""
Close the undo context. This call should always follw a call to
openUndo().
"""
cross3d.UndoContext.closeUndo()
@contextmanager
def blockRefreshContext(self, blockRefresh=True):
orig_blockRefresh = self.blockRefresh()
self.setBlockRefresh(blockRefresh)
yield
self.setBlockRefresh(orig_blockRefresh)
def blockRefresh(self):
"""
If returns true, the refresh method will not refresh.
"""
return self._blockRefresh
def setBlockRefresh(self, blockRefresh):
"""
If set to true, the refresh method will not refresh.
"""
if self._blockRefresh != blockRefresh:
self._blockRefresh = blockRefresh
cross3d.Scene().setUpdatesEnabled(not blockRefresh)
return True
return False
def shouldBlockSignal(self, signal, default):
""" Allows the Application to conditionally block a signal.
Normally you should pass cross3d.dispatch.signalsBlocked() to default.
In general if default is True this method should just return True. This will
prevent unexpected signal emits when a script called
cross3d.dispatch.blockSignals(True) to block all signals.
Args:
signal (str): The name of the signal to check if it should be blocked.
default (bool): Returned if signal doesn't match any requirements.
Returns:
bool: If the signal should be blocked.
"""
return default
# register the symbol
cross3d.registerSymbol('Application', AbstractApplication, ifNotFound=True)
# Creating a single instance of Application for all code to use.
cross3d.registerSymbol('application', AbstractApplication(), ifNotFound=True)
| mit | 2,690,035,886,214,266,000 | 26.075 | 82 | 0.742267 | false |
mezuro/kalibro_client_py | tests/processor/test_hotspot_metric_result.py | 1 | 1774 | from unittest import TestCase
from nose.tools import assert_equal, assert_true, raises
from mock import patch
from tests.factories import HotspotMetricResultFactory
from tests.helpers import not_raises
class TestHotspotMetricResult(TestCase):
def setUp(self):
self.subject = HotspotMetricResultFactory.build()
def test_properties_getters(self):
assert_true(hasattr(self.subject, 'line_number'))
assert_true(hasattr(self.subject, 'message'))
@not_raises((AttributeError, ValueError))
def test_properties_setters(self):
self.subject.line_number = 1
self.subject.message = "test message"
@raises(ValueError)
def test_properties_setters_with_invalid_parameters(self):
self.subject.line_number = "string"
def test_asdict(self):
dict_ = self.subject._asdict()
assert_equal(None, dict_["value"])
assert_equal(self.subject.metric_configuration_id, dict_["metric_configuration_id"])
assert_equal(self.subject.line_number, dict_["line_number"])
assert_equal(self.subject.message, dict_["message"])
def test_related_results(self):
related_results = [HotspotMetricResultFactory.build(id=id_) for id_ in range(3)]
related_results_hash = {'hotspot_metric_results': [related_result._asdict()
for related_result in related_results]}
with patch.object(self.subject, 'request', return_value=related_results_hash) as request_mock:
assert_equal(self.subject.related_results(), related_results)
request_mock.assert_called_once_with(action=':id/related_results', params={'id': self.subject.id},
method='get')
| lgpl-3.0 | -1,097,465,209,249,219,600 | 40.255814 | 110 | 0.657835 | false |
EconForge/dolo | dolo/misc/caching.py | 1 | 4370 | import functools
class memoized(object):
"""Decorator that caches a function's return value each time it is called.
If called later with the same arguments, the cached value is returned, and
not re-evaluated.
"""
def __init__(self, func):
self.func = func
self.cache = {}
def __call__(self, *args, **kargs):
targs = (e for e in args)
hh = tuple(hashable(e) for e in targs)
h2 = hashable(kargs)
h = hash((hh, h2))
try:
return self.cache[h]
except KeyError:
value = self.func(*args, **kargs)
self.cache[h] = value
return value
except TypeError:
# uncachable -- for instance, passing a list as an argument.
# Better to not cache than to blow up entirely.
return self.func(*args, **kargs)
def __repr__(self):
"""Return the function's docstring."""
return self.func.__doc__
def __get__(self, obj, objtype):
"""Support instance methods."""
return functools.partial(self.__call__, obj)
class cachedondisk(object):
"""Decorator that caches a function's return value each time it is called.
If called later with the same arguments, the cached value is returned, and
not re-evaluated.
"""
def __init__(self, func):
# create caching direcory if it is not there already
import os
if not os.path.isdir(".cache"):
os.mkdir(".cache")
self.func = func
self.fname = func.__name__
def __call__(self, *args, **kargs):
import pickle
hh = tuple(hashable(e) for e in args)
h2 = hashable(kargs)
h = hash((hh, h2))
try:
with open(".cache/{0}.{1}.pickle".format(self.fname, h), "rb") as f:
value = pickle.load(f)
return value
except IOError:
value = self.func(*args, **kargs)
if value is not None: # should there be other kinds of error values
# write file with h
with open(".cache/{0}.{1}.pickle".format(self.fname, h), "wb") as f:
pickle.dump(value, f)
return value
except TypeError:
# uncachable -- for instance, passing a list as an argument.
# Better to not cache than to blow up entirely.
return self.func(*args, **kargs)
def __repr__(self):
"""Return the function's docstring."""
return self.func.__doc__
def __get__(self, obj, objtype):
"""Support instance methods."""
return functools.partial(self.__call__, obj)
def clear_cache(function_name=None):
import os
try:
if function_name:
os.system("rm -rf .cache/{}.*.pickle".format(function_name))
else:
os.system("rm -rf .cache/*.pickle")
except:
pass
import os
class DiskDictionary:
def __init__(self, directory=".cache", funname="fun"):
self.funname = funname
if not os.path.isdir(directory):
os.mkdir(directory)
self.directory = directory
def get_filename(self, key):
import pickle
hh = tuple(hashable(k) for k in key)
h = hash(hh)
filename = "{0}/{1}.{2}.pickle".format(self.directory, self.funname, h)
return filename
def __setitem__(self, key, value):
import pickle
filename = self.get_filename(key)
try:
with open(filename, "w") as f:
pickle.dump(value, f)
except TypeError as e:
raise e
def get(self, item):
import pickle
filename = self.get_filename(item)
try:
with open(filename) as f:
value = pickle.load(f)
return value
except:
return None
import collections
def hashable(obj):
if hasattr(obj, "flatten"): # for numpy arrays
return tuple(obj.flatten().tolist())
if isinstance(obj, collections.abc.Hashable):
return obj
if isinstance(obj, collections.abc.Mapping):
items = [(k, hashable(v)) for (k, v) in obj.items()]
return frozenset(items)
if isinstance(obj, collections.abc.Iterable):
return tuple([hashable(item) for item in obj])
return TypeError(type(obj))
| bsd-2-clause | 8,237,001,637,224,577,000 | 27.376623 | 84 | 0.556979 | false |
daniellawrence/pyspeccheck | speccheck/file.py | 1 | 2560 | #!/usr/bin/env python
from .util import Spec
class File(Spec):
STATES = [
"directory", "file",
"owned_by",
"smaller_than", "larger_than"
]
def __init__(self, path):
self.path = path
self.state = {}
self.get_state()
self.WIN = "File %s is %%s" % self.path
def get_state(self):
import os
import stat
import pwd
import grp
s = os.stat(self.path)
self.state = {
'st_mode': s.st_mode,
'st_ino': s.st_ino,
'st_dev': s.st_dev,
'st_nlink': s.st_nlink,
'st_uid': s.st_uid,
'st_gid': s.st_gid,
'st_size': s.st_size,
'user': pwd.getpwuid(s.st_uid)[0],
'group': grp.getgrgid(s.st_gid)[0],
'directory': stat.S_ISDIR(s.st_mode),
'file': stat.S_ISREG(s.st_mode),
'full_mode': oct(stat.S_IMODE(s.st_mode)),
'mode': oct(stat.S_IMODE(s.st_mode))[1:],
}
def sb_smaller_than(self, size):
size_map = {
'k': 1024,
'm': 1024*1024,
'g': 1024*1024*1024
}
real_size = self.state['st_size']
size_units = size[-1].lower()
size_count = int(size[0:-1])
expected_size = size_count * size_map[size_units]
if expected_size > real_size:
return True, "File %s is smaller than %s" % (self.path, size)
else:
return False, "File %s is larger than %s" % (self.path, size)
def sb_larger_than(self, size):
x, msg = self.sb_smaller_than(size)
return x is False, msg
def sb_directory(self, *args):
if self._make_sure(self.state['directory']):
return True
return "%s is not a directory" % (self.path)
def sb_file(self, *args):
if self._make_sure(self.state['file']):
return True
return "%s is not a file" % (self.path)
def sb_owned_by(self, desired_owner):
user = None
group = None
problems = []
if ':' in desired_owner:
(user, group) = desired_owner.split(':')
else:
user = desired_owner
if user and self.state['user'] != user:
problems.append("owned %s not %s" % (self.state['user'], user))
if group and self.state['group'] != group:
problems.append("group %s not %s" % (self.state['group'], group))
if problems:
return ' and '.join(problems)
return True
| mit | -4,272,780,294,364,306,000 | 27.764045 | 77 | 0.494141 | false |
ahmadcahyana/xyberville | xyberville/apps/sales/migrations/0001_initial.py | 1 | 2125 | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
import django.utils.timezone
import model_utils.fields
class Migration(migrations.Migration):
dependencies = [
]
operations = [
migrations.CreateModel(
name='Item',
fields=[
('id', models.AutoField(auto_created=True, verbose_name='ID', primary_key=True, serialize=False)),
('quantity', models.PositiveSmallIntegerField()),
('price', models.FloatField(blank=True, null=True)),
('tax_amount', models.FloatField(blank=True, null=True)),
],
),
migrations.CreateModel(
name='Sale',
fields=[
('id', models.AutoField(auto_created=True, verbose_name='ID', primary_key=True, serialize=False)),
('number', models.CharField(max_length=8, db_index=True)),
('status', models.PositiveSmallIntegerField(choices=[(1, 'Pending'), (2, 'Paid'), (3, 'Completed'), (4, 'Canceled'), (5, 'Refunded')])),
('notes', models.TextField(blank=True)),
('created', model_utils.fields.AutoCreatedField(default=django.utils.timezone.now, editable=False)),
('price', models.FloatField(blank=True, null=True)),
('discount', models.FloatField(blank=True, null=True)),
('amount_to_collect', models.FloatField(blank=True, null=True)),
('paid', models.DateTimeField(blank=True, null=True)),
('completed', models.DateTimeField(blank=True, null=True)),
('canceled', models.DateTimeField(blank=True, null=True)),
('cancellation_note', models.TextField(blank=True)),
('refunded', models.DateTimeField(blank=True, null=True)),
('refund_notes', models.TextField(blank=True)),
('rating', models.PositiveSmallIntegerField(blank=True, null=True, choices=[(1, '1 - Bad'), (2, '2'), (3, '3 - Average'), (4, '4'), (5, '5 - Best')])),
],
),
]
| mit | -8,822,335,561,830,740,000 | 47.295455 | 167 | 0.568941 | false |
sserrot/champion_relationships | venv/Lib/site-packages/zmq/tests/test_pubsub.py | 1 | 1089 | # Copyright (C) PyZMQ Developers
# Distributed under the terms of the Modified BSD License.
from random import Random
import time
from unittest import TestCase
import zmq
from zmq.tests import BaseZMQTestCase, have_gevent, GreenTest
class TestPubSub(BaseZMQTestCase):
pass
# We are disabling this test while an issue is being resolved.
def test_basic(self):
s1, s2 = self.create_bound_pair(zmq.PUB, zmq.SUB)
s2.setsockopt(zmq.SUBSCRIBE, b'')
time.sleep(0.1)
msg1 = b'message'
s1.send(msg1)
msg2 = s2.recv() # This is blocking!
self.assertEqual(msg1, msg2)
def test_topic(self):
s1, s2 = self.create_bound_pair(zmq.PUB, zmq.SUB)
s2.setsockopt(zmq.SUBSCRIBE, b'x')
time.sleep(0.1)
msg1 = b'message'
s1.send(msg1)
self.assertRaisesErrno(zmq.EAGAIN, s2.recv, zmq.NOBLOCK)
msg1 = b'xmessage'
s1.send(msg1)
msg2 = s2.recv()
self.assertEqual(msg1, msg2)
if have_gevent:
class TestPubSubGreen(GreenTest, TestPubSub):
pass
| mit | 4,570,999,008,400,975,400 | 24.928571 | 66 | 0.640037 | false |
jslade/python-monque | examples/speed_test.py | 1 | 1859 | #!/usr/bin/env python
"""
speed_test -- test how fast tasks can be submitted and processed.
The client/submitter side will run forever, submitting dummy tasks (that don't do anything)
in a loop. Periodically (every few seconds), a status line is printed showing how many
tasks are in the queue, how many running, etc.
Start the submitter side as:
python speed_tests.py
Interrupt with Ctrl-C to end the test.
One or more workers should also be started to consume/execute the tasks:
python -m monque.worker --include speed_test --queue speed_test
Test pausing / resuming the queue while the workers are running:
python -m monque.worker --control [pause|resume] --queue speed_test
"""
from monque import Monque
from monque.task import Task
class NopTask(Task):
queue = 'speed_test'
def run(self):
pass
if __name__ == '__main__':
q = Monque()
nop = NopTask()
import time
started = time.time()
def stats():
return { 'posted': q.count_posted(),
'pending': q.count_pending(queue='speed_test'),
'completed': q.count_completed(queue='speed_test'),
'failed': q.count_failed(queue='speed_test') }
prev = stats()
while True:
nop.post()
now = time.time()
elapsed = now - started
if elapsed >= 5:
curr = stats()
print "Posted: %d(%.1f/s), Pending: %d(%.1f/s), Completed: %d(%.1f/s), Failed: %d(%.1f/s)" % \
(curr['posted'], (curr['posted']-prev['posted'])/elapsed,
curr['pending'], (curr['pending']-prev['pending'])/elapsed,
curr['completed'], (curr['completed']-prev['completed'])/elapsed,
curr['failed'], (curr['failed']-prev['failed'])/elapsed)
prev = curr
started = now
| mit | 8,231,868,192,520,842,000 | 27.6 | 106 | 0.592792 | false |
olkku/tf-info | apps/voteresults/views.py | 1 | 1866 | from django.shortcuts import render_to_response
from django.template import RequestContext
from django.http import HttpResponse
from django.utils import timezone
from django.conf import settings
from django.views.decorators.cache import cache_page
import urllib2
"""
Takes in results from a vote in the following format:
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
0:1<br>1:0<br>2:0<br>3:0<br>4:0<br>5:0<br>9:0<br></body>
</html>
Parses and adds colors
"""
class Result:
def __init__(self, voteid, count):
self.id = int (voteid)
self.count = int(count)
self.color = "#0F0F0F"
self.size = 0
self.pos = 0
def add_votes(self, add_count):
self.count += add_count
def set_color(self, color):
self.color = color
@cache_page(60 * 10)
def index(request):
try:
response = urllib2.urlopen(settings.VOTERESULTS_URL)
data = response.read()
except:
return HttpResponse("Unable to access stats.", status=500)
result = data.split("<body>")[1].split("</body>")[0].split("<br>")
votes = []
for x in result:
x = x.replace("\n","")
if len(x) == 0:
continue
xId = x.split(":")[0]
xCount = x.split(":")[1]
if xId == "1" or xId == "2":
votes[0].add_votes(int(xCount))
else:
votes.append(Result(xId, xCount))
for x in votes:
if x.id == 0:
x.set_color("#FF9900")
elif x.id == 3:
x.id = 1
x.set_color("#6699FF")
elif x.id == 4:
x.id = 2
x.set_color("#66FF33")
elif x.id == 5:
x.id = 4
x.set_color("#835C3B")
elif x.id == 9:
x.id = 3
x.set_color("#FF1919")
x.pos = x.id *22
if int(x.count) > 20:
x.size = 95
else:
x.size = int((float(x.count) / 20) * 95)
width = votes[-1].pos + 22 + 10
return render_to_response('voteresults/index.html', {"votes": votes, "width": width}, context_instance=RequestContext(request))
| bsd-3-clause | 1,497,367,023,401,473,300 | 19.282609 | 128 | 0.633976 | false |
srinivasanmit/all-in-all | DSAlgo/LinkedLists/linked_list.py | 1 | 4932 |
class Node() :
def __init__(self, data):
self.data = data
self.next = None
class LinkedList() :
def __init__(self):
self.head = None
self.tail = None
self.ll_length = 0
def appendNode(self, data):
new_node = Node(data)
self.ll_length += 1
if self.head == None :
self.head = new_node
self.tail = new_node
else :
self.tail.next = new_node
self.tail = new_node
def insertNode(self, data, position) :
new_node = Node(data)
curr_node = self.head
i = 1
self.ll_length += 1
if position > self.ll_length :
print "Position can't be greater than the length of LL"
elif position != 1 :
while i < position -1 :
curr_node = curr_node.next
i += 1
new_node.next = curr_node.next
curr_node.next = new_node
else :
new_node.next = curr_node
self.head = new_node
def insert_into_sorted(self, data) :
new_node = Node(data)
self.ll_length += 1
curr_node = self.head
print "inserting ", data
while curr_node.next != None :
if data < self.head.data :
new_node.next = self.head
self.head = new_node
break
elif data > curr_node.data and data < curr_node.next.data :
new_node.next = curr_node.next
curr_node.next = new_node
break
elif data > curr_node.next.data :
curr_node.next.next = new_node
curr_node = curr_node.next
if data > self.head.data :
self.head.next = new_node
else :
new_node.next = self.head
self.head = new_node
def deleteNode(self, data):
curr_node = self.head
prev_node = self.head
if self.head.data == data :
self.head = self.head.next
self.ll_length -= 1
return
while curr_node.next != None :
if curr_node.data == data :
prev_node.next = curr_node.next
del(curr_node)
self.ll_length -= 1
break
prev_node = curr_node
curr_node = curr_node.next
else :
print "Could not find item to delete in the linked list"
def reverseList(self):
tmp_curr_node = curr_node = self.head
prev_node = None
revList = LinkedList()
while curr_node :
tmp_current_node = curr_node.next
curr_node.next = prev_node
prev_node = curr_node
revList.appendNode(curr_node.data)
curr_node = tmp_current_node
self.head = prev_node
return revList
def printNodes(self) :
curr_node = self.head
while curr_node != None :
print curr_node.data
curr_node = curr_node.next
def getLength(self, head_pointer) :
count = 0
while head_pointer :
count += 1
head_pointer = head_pointer.next
return count
def checkPalindromeLists(self, revobj ) :
curr_node = self.head
rev_curr_node = revobj.head
if self.getLength(self.head) != self.getLength(revobj.head) :
print "Linked lists are not palidromes"
while curr_node :
if curr_node.data != rev_curr_node.data :
return False
curr_node = curr_node.next
rev_curr_node = rev_curr_node.next
else :
return True
if __name__ == "__main__":
ll_obj = LinkedList()
print "Appending 1 to the linked list"
ll_obj.appendNode(1)
ll_obj.printNodes()
print "Appending 3 to the linked list"
ll_obj.appendNode(3)
ll_obj.printNodes()
print "Appending 4 to the linked list"
ll_obj.appendNode(4)
ll_obj.printNodes()
print "Appending 5 to the linked list"
ll_obj.appendNode(5)
ll_obj.printNodes()
print "Inserting 2 at position 1 to the linked list"
ll_obj.insertNode(2,1)
ll_obj.printNodes()
print "Deleting node with data 4 in the linked list"
ll_obj.deleteNode(2)
ll_obj.printNodes()
print "Trying to delete an item not in the list - 20"
ll_obj.deleteNode(20)
ll_obj.printNodes()
rev_obj = ll_obj.reverseList()
print "Printing linked list after reversing"
ll_obj.printNodes()
print "Printing original linked list"
ll_obj.insert_into_sorted(2)
ll_obj.insert_into_sorted(0)
ll_obj.insert_into_sorted(21)
print ll_obj.printNodes()
rev_obj.printNodes()
if ll_obj.checkPalindromeLists(rev_obj) :
print "Linked lists are palindrome"
else :
print "Linked lists are not palindrome"
| gpl-3.0 | 134,500,026,237,291,900 | 30.018868 | 71 | 0.538727 | false |
bhecquet/seleniumRobot-server | snapshotServer/views/TestResultView.py | 1 | 3829 | '''
Created on 4 sept. 2017
@author: worm
'''
from django.views.generic.list import ListView
from snapshotServer.models import TestCaseInSession, StepResult, Snapshot
import json
from snapshotServer.views.LoginRequiredMixinConditional import LoginRequiredMixinConditional
class TestResultView(LoginRequiredMixinConditional, ListView):
"""
View displaying a single test result
"""
template_name = "snapshotServer/testResult.html"
@classmethod
def buildLogStringFromJson(cls, jsonString):
"""
{"name":"Login","type":"step","actions":[
{"messageType":"INFO","name":"everything OK","type":"message"},
{"name":"action2","failed":false,"type":"action"},
{"name":"subStep","type":"step","actions":[
{"messageType":"WARNING","name":"everything in subStep almost OK","type":"message"},
{"name":"action1","failed":false,"type":"action"}
]}
]}
to
<ul>
<li>everything OK</li>
<li>action2</li>
<ul>
<li>everything in subStep almost OK</li>
<li>action1</li>
</ul>
</ul>
"""
logStr = ""
def parseStep(step, firstCall=False):
nonlocal logStr
# do not reprint the main step name as test report will print it
if not firstCall:
logStr += "<li>%s</li>\n" % step['name']
logStr += "<ul>\n"
for action in step['actions']:
if action['type'] == 'message':
logStr += "<div class='message-%s'>%s: %s</div>\n" % (action['messageType'].lower(), action['messageType'], action['name'])
elif action['type'] == 'action':
if action['failed']:
logStr += "<li class='action-failed'>%s</li>\n" % (action['name'],)
else:
logStr += "<li class='action-success'>%s</li>\n" % (action['name'],)
elif action['type'] == 'step':
parseStep(action)
logStr += "</ul>\n"
logsDict = json.loads(jsonString)
parseStep(logsDict, True)
return logStr
def get_queryset(self):
try:
test_case_in_session = self.kwargs['testCaseInSessionId']
test_steps = TestCaseInSession.objects.get(id=test_case_in_session).testSteps.all()
stepSnapshots = {}
for step_result in StepResult.objects.filter(testCase=test_case_in_session, step__in=test_steps).order_by('id'):
# build logs from json string
if step_result.stacktrace:
logs = self.buildLogStringFromJson(step_result.stacktrace)
else:
logs = None
step_result.formattedLogs = logs
try:
stepSnapshots[step_result] = Snapshot.objects.get(stepResult = step_result)
except:
stepSnapshots[step_result] = None
return stepSnapshots
except:
return []
def get_context_data(self, **kwargs):
context = super(TestResultView, self).get_context_data(**kwargs)
context['currentTest'] = TestCaseInSession.objects.get(pk=self.kwargs['testCaseInSessionId'])
if context['currentTest'].stacktrace:
context['stacktrace'] = context['currentTest'].stacktrace.split('\n')
else:
context['stacktrace'] = ['no logs available']
return context | apache-2.0 | 8,277,047,193,499,717,000 | 34.794393 | 143 | 0.511883 | false |
h2oai/sparkling-water | py/tests/integration/external_only/test_stopping.py | 1 | 1727 | #
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import time
from tests.integration.external_only.external_backend_test_utils import *
from tests.integration.integ_test_utils import *
def testStoppingWithoutExplicitStop(integ_spark_conf):
return_code = launch(integ_spark_conf, "examples/tests/H2OContextWithoutExplicitStop.py")
time.sleep(10)
assert "Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):0" in listYarnApps()
assert return_code == 0, "Process ended in a wrong way. It ended with return code " + str(return_code)
def testStoppingWithExplicitStop(integ_spark_conf):
return_code = launch(integ_spark_conf, "examples/tests/H2OContextWithExplicitStop.py")
time.sleep(10)
assert "Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):0" in listYarnApps()
assert return_code == 0, "Process ended in a wrong way. It ended with return code " + str(return_code)
| apache-2.0 | 2,905,388,376,934,338,600 | 48.342857 | 128 | 0.762594 | false |
MattBlack85/dunning-cruncher | utils/func_utils.py | 1 | 4192 | #-*- coding: utf-8 -*-
from django.conf import settings
from django.http import HttpResponse
from django.template.context import Context
from django.template.loader import get_template
from xhtml2pdf import pisa # TODO: Change this when the lib changes.
import StringIO
import os
#===============================================================================
# HELPERS
#===============================================================================
class UnsupportedMediaPathException(Exception):
pass
def fetch_resources(uri, rel):
"""
Callback to allow xhtml2pdf/reportlab to retrieve Images,Stylesheets, etc.
`uri` is the href attribute from the html link element.
`rel` gives a relative path, but it's not used here.
"""
if uri.startswith(settings.MEDIA_URL):
path = os.path.join(settings.MEDIA_ROOT,
uri.replace(settings.MEDIA_URL, ""))
elif uri.startswith(settings.STATIC_URL):
path = os.path.join(settings.STATIC_ROOT,
uri.replace(settings.STATIC_URL, ""))
if not os.path.exists(path):
for d in settings.STATICFILES_DIRS:
path = os.path.join(d, uri.replace(settings.STATIC_URL, ""))
if os.path.exists(path):
break
else:
raise UnsupportedMediaPathException(
'media urls must start with %s or %s' % (
settings.MEDIA_ROOT, settings.STATIC_ROOT))
return path
def generate_pdf_template_object(template_object, file_object, context):
"""
Inner function to pass template objects directly instead of passing a filename
"""
html = template_object.render(Context(context))
pisa.CreatePDF(html.encode('utf-8'), file_object, link_callback=fetch_resources, encodiing='UTF-8')
return file_object
#===============================================================================
# Main
#===============================================================================
def generate_pdf(template_name, file_object=None, context=None): # pragma: no cover
"""
Uses the xhtml2pdf library to render a PDF to the passed file_object, from the
given template name.
This returns the passed-in file object, filled with the actual PDF data.
In case the passed in file object is none, it will return a StringIO instance.
"""
if not file_object:
file_object = StringIO.StringIO()
if not context:
context = {}
tmpl = get_template(template_name)
generate_pdf_template_object(tmpl, file_object, context)
file_object.close()
return file_object
def render_to_pdf_response2(template_name, context=None, pdfname=None):
file_object = open(os.path.dirname(os.path.dirname(__file__))+'/upload/'+pdfname, 'wb')
if not pdfname:
pdfname = '%s.pdf' % os.path.splitext(os.path.basename(template_name))[0]
#file_object['Content-Disposition'] = 'attachment; filename=%s' % pdfname
return generate_pdf(template_name, file_object, context)
def render_to_pdf_response(template_name, context=None, pdfname=None):
file_object = HttpResponse(content_type='application/pdf')
if not pdfname:
pdfname = '%s.pdf' % os.path.splitext(os.path.basename(template_name))[0]
file_object['Content-Disposition'] = 'attachment; filename=%s' % pdfname
return generate_pdf(template_name, file_object, context)
class rem_to_do():
MCODE = {'DE': ['DE2', 'DE3', 'DE4', 'DEP2', 'DEP3', 'DEP4'],
'PL': ['PLW'],
'AT': ['AT'],
'NL': ['NL2', 'NL3', 'NL4'],
'IT': ['ITFP3L', 'ITW3L'],
'FR': ['FRPD', 'FRWD', 'FRD'],
'BE': ['BEF', 'BEW'],
'PT': ['PTD'],
'DK': ['DK2', 'DK3'],
'SE': ['SE2', 'SE3'],
'FI': ['FI2', 'FI3'],
'NO': ['NO2', 'NO3'],
'CH': ['CH1T', 'CH2', 'CH3', 'CH4', 'CHW1T', 'CHW2', 'CHW3', 'CHW4', 'CHC1T', 'CHC2', 'CHC3', 'CHC4']
}
MAILSUBJECT = {'EN': "reply to reminder",
'DE': "Antwort auf Mahnung",
'PL': "odpowiedz na wezwanie do zaplaty",
}
| bsd-3-clause | -8,430,157,454,704,671,000 | 38.54717 | 114 | 0.558922 | false |
dknez/libmesh | doc/statistics/libmesh_pagehits.py | 1 | 7992 | #!/usr/bin/env python
import matplotlib.pyplot as plt
import numpy as np
# Import stuff for working with dates
from datetime import datetime
from matplotlib.dates import date2num
# Hits/month, pages, and gigabytes served.
# To get the Google analytics data:
# .) go to analytics.google.com
# .) click on libmesh
# .) click View Report
# .) Adjust date range to previous month
# .) Record the number of "Pageviews" in the "Hits" column below
# Hits, pages, GB served
data = [
# 'Jan 2003', 616, 616, 0
# 'Feb 2003', 2078, 2078, 0,
# 'Mar 2003', 3157, 3157, 0,
# 'Apr 2003', 7800, 7800, 0,
# 'May 2003', 4627, 4627, 0,
# 'Jun 2003', 6156, 6156, 0,
# 'Jul 2003', 6389, 6389, 0,
# 'Aug 2003', 10136, 10136, 0,
# 'Sep 2003', 8871, 8871, 0,
# 'Oct 2003', 9703, 9703, 0,
# 'Nov 2003', 9802, 9802, 0,
# 'Dec 2003', 9123, 9123, 0,
# 'Jan 2004', 13599, 13599, 0,
# 'Feb 2004', 11018, 11018, 0,
# 'Mar 2004', 11713, 11713, 0,
# 'Apr 2004', 14995, 14995, 0,
# 'May 2004', 11285, 11285, 0,
# 'Jun 2004', 12974, 12974, 0,
# 'Jul 2004', 12939, 12939, 0,
# 'Aug 2004', 9708, 9708, 0,
# 'Sep 2004', 7994, 7994, 0,
# 'Oct 2004', 6920, 6920, 0,
# 'Nov 2004', 10261, 10261, 0,
# 'Dec 2004', 7483, 7483, 0,
# 'Jan 2005', 3184, 3184, 0,
# 'Feb 2005', 37733, 14077, .4373,
# 'Mar 2005', 43927, 16408, .5637,
# 'Apr 2005', 29792, 8518, .2890,
# 'May 2005', 51288, 17629, .5689,
# 'Jun 2005', 40617, 16599, .5379,
# 'Jul 2005', 29944, 10006, .3363,
# 'Aug 2005', 39592, 14556, .4577,
# 'Sep 2005', 57638, 14666, .4881,
# 'Oct 2005', 48336, 17976, .5749,
# 'Nov 2005', 49563, 15308, .5810,
# 'Dec 2005', 90863, 40736, .9415,
# 'Jan 2006', 46723, 13487, .5662,
# 'Feb 2006', 62285, 26567, .8229,
# 'Mar 2006', 47446, 14711, .6534,
# 'Apr 2006', 90314, 29635, .9762,
# 'May 2006', 68209, 20998, .7949,
# 'Jun 2006', 50495, 17128, .6881,
# 'Jul 2006', 42387, 10958, .6016,
# 'Aug 2006', 55658, 11793, .6174,
# 'Sep 2006', 54919, 20591, .9056,
# 'Oct 2006', 52916, 17944, .9015,
# 'Nov 2006', 55382, 19833, .9439,
# 'Dec 2006', 54265, 22688, .9162,
# 'Jan 2007', 53813, 19881, 1.0 ,
# 'Feb 2007', 52434, 17920, .9472,
# 'Mar 2007', 61530, 21172, 1.2,
# 'Apr 2007', 125578, 77539, 1.3,
# 'May 2007', 182764, 129596, 1.6,
# 'Jun 2007', 115730, 38571, 1.7,
# 'Jul 2007', 121054, 42757, 1.8,
# 'Aug 2007', 81192, 28187, 1.3,
# 'Sep 2007', 143553, 39734, 2.3,
# 'Oct 2007', 110449, 42111, 2.4,
# 'Nov 2007', 128307, 57851, 2.3,
# 'Dec 2007', 80584, 42631, 2.0,
# 'Jan 2008', 69623, 34155, 2.0,
# 'Feb 2008', 144881, 111751, 2.5,
# 'Mar 2008', 69801, 29211, 1.9,
# 'Apr 2008', 74023, 31149, 2.0,
# 'May 2008', 63123, 23277, 1.8,
# 'Jun 2008', 66055, 25418, 2.1,
# 'Jul 2008', 60046, 22082, 2.0,
# 'Aug 2008', 60206, 24543, 2.0,
# 'Sep 2008', 53057, 18635, 1.6,
# 'Oct 2008', 64828, 27042, 2.1,
# 'Nov 2008', 72406, 29767, 2.3,
# 'Dec 2008', 76248, 31690, 2.3,
# 'Jan 2009', 73002, 29744, 2.0,
# 'Feb 2009', 70801, 29156, 2.1,
# 'Mar 2009', 78200, 31139, 2.1,
# 'Apr 2009', 70888, 26182, 1.7,
# 'May 2009', 67263, 26210, 1.8,
# 'Jun 2009', 73146, 31328, 2.6,
# 'Jul 2009', 77828, 33711, 2.4,
# 'Aug 2009', 64378, 28542, 1.9,
# 'Sep 2009', 76167, 33484, 2.2,
# 'Oct 2009', 95727, 41062, 2.8,
# 'Nov 2009', 88042, 38869, 2.5,
# 'Dec 2009', 76148, 37609, 2.3,
# 'Jan 2010', 268856, 45983, 3.2,
# 'Feb 2010', 208210, 42680, 3.0,
# 'Mar 2010', 116263, 42660, 2.6,
# 'Apr 2010', 102493, 32942, 2.4,
# 'May 2010', 117023, 37107, 2.5,
# 'Jun 2010', 128589, 38019, 2.5,
# 'Jul 2010', 87183, 34026, 2.2,
# 'Aug 2010', 99161, 33199, 2.5,
# 'Sep 2010', 81657, 32305, 2.5,
# 'Oct 2010', 98236, 42091, 3.4,
# 'Nov 2010', 115603, 48695, 3.4,
# 'Dec 2010', 105030, 45570, 3.4,
# 'Jan 2011', 133476, 43549, 3.1,
# 'Feb 2011', 34483, 15002, 1.1,
# 'Mar 2011', 0, 0, 0.0,
# 'Apr 2011', 0, 0, 0.0,
# 'May 2011', 0, 0, 0.0,
# 'Jun 2011', 0, 0, 0.0,
# 'Jul 2011', 0, 0, 0.0,
'Aug 2011', 10185, 0, 0.0, # New "Pageviews" data from google analytics, does not seem comparable to sf.net pagehits data
'Sep 2011', 10305, 0, 0.0,
'Oct 2011', 14081, 0, 0.0,
'Nov 2011', 13397, 0, 0.0,
'Dec 2011', 13729, 0, 0.0,
'Jan 2012', 11050, 0, 0.0,
'Feb 2012', 12779, 0, 0.0,
'Mar 2012', 12970, 0, 0.0,
'Apr 2012', 13051, 0, 0.0,
'May 2012', 11857, 0, 0.0,
'Jun 2012', 12584, 0, 0.0,
'Jul 2012', 12995, 0, 0.0,
'Aug 2012', 13204, 0, 0.0,
'Sep 2012', 13170, 0, 0.0,
'Oct 2012', 13335, 0, 0.0,
'Nov 2012', 11337, 0, 0.0,
'Dec 2012', 10108, 0, 0.0, # libmesh switched to github on December 10, 2012
'Jan 2013', 13029, 0, 0.0,
'Feb 2013', 10420, 0, 0.0,
'Mar 2013', 13400, 0, 0.0,
'Apr 2013', 14416, 0, 0.0,
'May 2013', 13875, 0, 0.0,
'Jun 2013', 13747, 0, 0.0,
'Jul 2013', 14019, 0, 0.0,
'Aug 2013', 10828, 0, 0.0,
'Sep 2013', 9969, 0, 0.0,
'Oct 2013', 13083, 0, 0.0,
'Nov 2013', 12938, 0, 0.0,
'Dec 2013', 9079, 0, 0.0,
'Jan 2014', 9736, 0, 0.0,
'Feb 2014', 11824, 0, 0.0,
'Mar 2014', 10861, 0, 0.0,
'Apr 2014', 12711, 0, 0.0,
'May 2014', 11177, 0, 0.0,
'Jun 2014', 10738, 0, 0.0,
'Jul 2014', 10349, 0, 0.0,
'Aug 2014', 8877, 0, 0.0,
'Sep 2014', 9226, 0, 0.0,
'Oct 2014', 8052, 0, 0.0, # Google analytics number moved over to libmesh.github.io in Oct 2014
'Nov 2014', 9243, 0, 0.0,
'Dec 2014', 10714, 0, 0.0,
'Jan 2015', 11508, 0, 0.0,
'Feb 2015', 11278, 0, 0.0,
'Mar 2015', 13305, 0, 0.0,
'Apr 2015', 12347, 0, 0.0,
'May 2015', 11368, 0, 0.0,
'Jun 2015', 11203, 0, 0.0,
'Jul 2015', 10419, 0, 0.0,
'Aug 2015', 11282, 0, 0.0,
'Sep 2015', 13535, 0, 0.0,
'Oct 2015', 12912, 0, 0.0,
'Nov 2015', 13894, 0, 0.0,
'Dec 2015', 11694, 0, 0.0,
]
# Extract number of hits/month
n_hits_month = data[1::4]
# Divide by 1000 for plotting...
n_hits_month = np.divide(n_hits_month, 1000.)
# Extract list of date strings
date_strings = data[0::4]
# Convert date strings into numbers
date_nums = []
for d in date_strings:
date_nums.append(date2num(datetime.strptime(d, '%b %Y')))
# Get a reference to the figure
fig = plt.figure()
# 111 is equivalent to Matlab's subplot(1,1,1) command
ax = fig.add_subplot(111)
# Make the bar chart. We have one number/month, there are about 30
# days in each month, this defines the bar width...
ax.bar(date_nums, n_hits_month, width=30, color='b')
# Create title
fig.suptitle('LibMesh Page Hits/Month (in Thousands)')
# Set up x-tick locations -- August of each year
ticks_names = ['Aug 2011', 'Aug 2012', 'Aug 2013', 'Aug 2014']
# Get numerical values for the names
tick_nums = []
for x in ticks_names:
tick_nums.append(date2num(datetime.strptime(x, '%b %Y')))
# Set tick labels and positions
ax.set_xticks(tick_nums)
ax.set_xticklabels(ticks_names)
# Set x limits for the plot
plt.xlim(date_nums[0], date_nums[-1]+30);
# Make x-axis ticks point outward
ax.get_xaxis().set_tick_params(direction='out')
# Save as PDF
plt.savefig('libmesh_pagehits.pdf')
# Local Variables:
# python-indent: 2
# End:
| lgpl-2.1 | -8,665,432,598,488,634,000 | 34.052632 | 131 | 0.519144 | false |
aisk/leancloud-python-sdk | tests/test_file.py | 1 | 4681 | # coding: utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import io
import six
import requests
from nose.tools import with_setup # type: ignore
from nose.tools import assert_raises # type: ignore
from nose.tools import raises # type: ignore
import leancloud
from leancloud import File
from leancloud import ACL
__author__ = 'asaka'
def setup_func():
leancloud.init(
os.environ['APP_ID'],
master_key=os.environ['MASTER_KEY']
)
def test_basic(): # type: () -> None
def fn(s):
f = File('Blah', s, mime_type='text/plain')
assert f.name == 'Blah'
assert f._metadata['size'] == 14
assert f.size == 14
b = b'blah blah blah'
fn(io.BytesIO(b))
fn(memoryview(b))
if six.PY2:
import StringIO
import cStringIO
fn(StringIO.StringIO(b))
fn(cStringIO.StringIO(b))
fn(buffer(b))
def test_create_with_url(): # type: () -> None
f = File.create_with_url('xxx', u'http://i1.wp.com/leancloud.cn/images/static/default-avatar.png', meta_data={})
assert f.url == 'http://i1.wp.com/leancloud.cn/images/static/default-avatar.png'
def test_create_without_data(): # type: () -> None
f = File.create_without_data('a123')
assert f.id == 'a123'
def test_acl(): # type: () -> None
acl_ = ACL()
f = File('Blah', io.BytesIO(b'xxx'))
assert_raises(TypeError, f.set_acl, 'a')
f.set_acl(acl_)
assert f.get_acl() == acl_
@with_setup(setup_func)
def test_save(): # type: () -> None
user = leancloud.User()
user.login('user1_name', 'password')
f = File('Blah.txt', open('tests/sample_text.txt', 'rb'))
f.save()
assert f.owner_id == user.id
assert f.id
assert f.name == 'Blah.txt'
assert f.mime_type == 'text/plain'
assert not f.url.endswith('.')
@with_setup(setup_func)
def test_query(): # type: () -> None
files = leancloud.Query('File').find()
for f in files:
assert isinstance(f, File)
assert f.url
assert f.name
assert f.metadata
assert isinstance(leancloud.File.query.first(), File)
@with_setup(setup_func)
def test_save_external(): # type: () -> None
f = File.create_with_url('lenna.jpg', 'http://i1.wp.com/leancloud.cn/images/static/default-avatar.png')
f.save()
assert f.id
@raises(ValueError)
def test_thumbnail_url_erorr(): # type: () -> None
f = File.create_with_url('xx', '')
f.get_thumbnail_url(100, 100)
@with_setup(setup_func)
@raises(ValueError)
def test_thumbnail_size_erorr(): # type: () -> None
r = requests.get('http://i1.wp.com/leancloud.cn/images/static/default-avatar.png')
b = io.BytesIO(r.content)
f = File('Lenna2.jpg', b)
f.save()
assert f.id
f.get_thumbnail_url(-1, -1)
f.get_thumbnail_url(1, 1, quality=110)
@with_setup(setup_func)
def test_thumbnail(): # type: () -> None
r = requests.get('http://i1.wp.com/leancloud.cn/images/static/default-avatar.png')
b = io.BytesIO(r.content)
f = File('Lenna2.jpg', b)
f.save()
assert f.id
url = f.get_thumbnail_url(100, 100)
assert url.endswith('?imageView/2/w/100/h/100/q/100/format/png')
@with_setup(setup_func)
def test_destroy(): # type: () -> None
r = requests.get('http://i1.wp.com/leancloud.cn/images/static/default-avatar.png')
b = io.BytesIO(r.content)
f = File('Lenna2.jpg', b)
f.save()
assert f.id
f.destroy()
@with_setup(setup_func)
def test_file_callback(): # type: () -> None
d = {}
def noop(token, *args, **kwargs):
d['token'] = token
f = File('xxx', io.BytesIO(b'xxx'))
f._save_to_s3 = noop
f._save_to_qiniu = noop
f._save_to_qcloud = noop
f.save()
f._save_callback(d['token'], False)
# time.sleep(3)
# File should be deleted by API server
# assert_raises(leancloud.LeanCloudError, File.query().get, f.id)
@with_setup(setup_func)
def test_fetch(): # type: () -> None
r = requests.get('http://i1.wp.com/leancloud.cn/images/static/default-avatar.png')
b = io.BytesIO(r.content)
f = File('Lenna2.jpg', b)
f.metadata['foo'] = 'bar'
f.save()
fetched = File.create_without_data(f.id)
fetched.fetch()
assert fetched.id == f.id
assert fetched.metadata == f.metadata
assert fetched.name == f.name
assert fetched.url == f.url
assert fetched.size == f.size
assert fetched.url == f.url
f.destroy()
def test_checksum(): # type: () -> None
f = File('Blah', open('tests/sample_text.txt', 'rb'))
assert f._metadata['_checksum'] == 'd0588d95e45eed70745ffabdf0b18acd'
| lgpl-3.0 | 791,541,468,818,069,400 | 25.005556 | 116 | 0.614826 | false |
cloudera/Impala | tests/query_test/test_insert_permutation.py | 1 | 2412 | # Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# Targeted Impala insert tests
from tests.common.impala_test_suite import ImpalaTestSuite
from tests.common.skip import SkipIfS3
from tests.common.test_dimensions import (
create_exec_option_dimension,
create_uncompressed_text_dimension)
class TestInsertQueriesWithPermutation(ImpalaTestSuite):
"""
Tests for the column permutation feature of INSERT statements
"""
@classmethod
def get_workload(self):
return 'functional-query'
@classmethod
def add_test_dimensions(cls):
super(TestInsertQueriesWithPermutation, cls).add_test_dimensions()
# Fix the exec_option vector to have a single value. This is needed should we decide
# to run the insert tests in parallel (otherwise there will be two tests inserting
# into the same table at the same time for the same file format).
# TODO: When we do decide to run these tests in parallel we could create unique temp
# tables for each test case to resolve the concurrency problems.
# TODO: do we need to run with multiple file formats? This seems to be really
# targeting FE behavior.
cls.ImpalaTestMatrix.add_dimension(create_exec_option_dimension(
cluster_sizes=[0], disable_codegen_options=[False], batch_sizes=[0]))
cls.ImpalaTestMatrix.add_dimension(
create_uncompressed_text_dimension(cls.get_workload()))
@SkipIfS3.eventually_consistent
def test_insert_permutation(self, vector):
map(self.cleanup_db, ["insert_permutation_test"])
self.run_test_case('QueryTest/insert_permutation', vector)
def teardown_method(self, method):
map(self.cleanup_db, ["insert_permutation_test"])
| apache-2.0 | -1,662,382,883,920,067,300 | 42.854545 | 88 | 0.75539 | false |
Urinx/Project_Euler_Answers | 050.py | 1 | 1316 | #!/usr/bin/env python
#coding:utf-8
"""
Consecutive prime sum
The prime 41, can be written as the sum of six consecutive primes:
41 = 2 + 3 + 5 + 7 + 11 + 13
This is the longest sum of consecutive primes that adds to a prime below one-hundred.
The longest sum of consecutive primes below one-thousand that adds to a prime, contains 21 terms, and is equal to 953.
Which prime, below one-million, can be written as the sum of the most consecutive primes?
"""
import math
def gen_primes():
D = {}
q = 2
while True:
if q not in D:
yield q
D[q * q] = [q]
else:
for p in D[q]:
D.setdefault(p + q, []).append(p)
del D[q]
q += 1
primes=[]
for p in gen_primes():
if p>10000: break
primes.append(p)
def is_prime(num):
for p in primes:
if p>math.sqrt(num): break
if num%p==0: return False
return True
def answer():
m=[0,0]
for i in xrange(0,29):
for j in xrange(len(primes)-680,i,-1):
s=sum(primes[i:j])
if s<1000000 and is_prime(s) and j-i>m[1]:
m=[s,j-i]
break
print m,len(primes)
import time
tStart=time.time()
answer()
print 'run time=',time.time()-tStart
# [997651, 543]
# run time= 0.111933946609 | gpl-2.0 | -2,962,537,939,399,148,000 | 22.517857 | 118 | 0.572188 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.