content
stringlengths 5
1.05M
|
|---|
# Make it possible to enable test coverage reporting for Python
# code run in children processes.
# http://coverage.readthedocs.io/en/latest/subprocess.html
import os.path as op
from distutils.sysconfig import get_python_lib
FILE_CONTENT = """\
import coverage; coverage.process_startup()
"""
filename = op.join(get_python_lib(), 'coverage_subprocess.pth')
with open(filename, mode='w') as f:
f.write(FILE_CONTENT)
print(f'Installed subprocess coverage support: {filename}')
|
from django.db import models
from django.utils.translation import gettext_lazy as _
from trade_system.users.models import User
from trade_system.items.models import Item
from trade_system.offers.choises import OrderType
class Offer(models.Model):
"""Request to buy or sell specific stocks"""
user = models.ForeignKey(User, blank=True, null=True, on_delete=models.SET_NULL)
item = models.ForeignKey(Item, blank=True, null=True, on_delete=models.SET_NULL)
entry_quantity = models.IntegerField(_("Requested quantity"))
quantity = models.IntegerField(_("Current quantity"))
order_type = models.PositiveSmallIntegerField(choices=OrderType)
price = models.DecimalField(max_digits=7, decimal_places=2, blank=True, null=True)
is_active = models.BooleanField(default=True)
def __str__(self):
return 'Offer {} {} {} {} {} {}'.format(self.user,
self.item,
self.quantity,
self.price,
self.item.currency,
self.order_type) |
from polylogyx.utils import js
class Testjs:
def test_pretty_operator(self):
assert js.pretty_operator("equal") == "equals"
def test_pretty_field(self):
assert js.pretty_field("action")=="Action"
def test_jinja2_esacpejs_filter_no_input(self):
assert js.jinja2_escapejs_filter(None) == ""
def test_jinja2_esacpejs_filter(self):
assert js.jinja2_escapejs_filter("test") == "test"
assert js.jinja2_escapejs_filter("=") == "\\u003D"
|
from scipy.ndimage import convolve
import numpy as np
class Solution:
def largestOverlap(self, A, B):
B = np.pad(B, len(A), mode='constant', constant_values=(0, 0))
return np.amax(convolve(B, np.flip(np.flip(A,1),0), mode='constant'))
|
import pygame
from pygame.sprite import Group
from src import game_functions as gf
from src.alien import Alien
from src.button import Button
from src.game_stats import GameStats
from src.scoreboard import ScoreBoard
from src.settings import Settings
from src.ship import Ship
def rungame():
# Initialize game,settings and create screen object.
pygame.init()
sett = Settings()
screen = pygame.display.set_mode((sett.screen_width, sett.screen_height))
pygame.display.set_caption("Alien Invasion")
""""Instance initialization"""
# Make instance of game stats.
stats = GameStats(sett)
# Make instance of scoreboard.
sb = ScoreBoard(sett, screen, stats)
# Make the play button.
b_play = Button(sett, screen, "PLAY")
# Make instance of ship.
ship = Ship(sett, screen)
# Make a group to store bullets and aliens.
aliens = Group()
bullets = Group()
# Make instance of alien.
alien = Alien(sett, screen)
gf.create_fleet(sett, screen, ship, aliens)
# Start the main loop for the game.
while True:
# Watch for keyboard and mouse events.
gf.check_events(sett, screen, stats, sb, b_play, ship, aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(sett, screen, stats, sb, ship, aliens, bullets)
gf.update_aliens(sett, stats, sb, screen, ship, aliens, bullets)
# Redraw the screen during each pass through the loop.
gf.update_screen(sett, screen, stats, sb, ship, aliens, bullets,
b_play)
rungame()
|
# -*- coding: utf-8 -*-
"""
@time : 2019/5/24 下午10:22
@author : [email protected]
@file : cache_man.py
@description : local_cache
##########################################################
#
#
#
#
##########################################################
"""
from core.utils.utils import load_yaml
from core.utils.udecorator import synchronized
import logging
from core.utils.ducc_utils import DuccClient
import json
class Config(object):
instance = None
@synchronized
def __new__(cls, *args, **kwargs):
if cls.instance is None:
cls.instance = super().__new__(cls)
return cls.instance
def __init__(self, f):
self._config = load_yaml(f)
# self.__init_config__()
self.contain = {}
logging.info('loading app config...%s' % json.dumps(self._config, sort_keys=False, indent=2))
def init_config(self, ducc):
req = ducc.querys()
data = json.loads(req.content)
config_data = data['data']
def __init_config_child(parent, config_data):
for key in parent.keys():
if type(parent[key]) is dict:
__init_config_child(parent[key], config_data)
else:
if type(parent[key]) is str and 'ducc:' in str(parent[key]):
v = self._find_ducc(str(parent[key]).replace('ducc:', ''), config_data)
parent[key] = v
for key in self._config.keys():
if type(self._config[key]) is dict:
__init_config_child(self._config[key], config_data)
else:
if type(self._config[key]) is str and 'ducc:' in str(self._config[key]):
self._config[key] = self._find_ducc(key, config_data)
def _find_ducc(self, key, config_data):
for d in config_data:
if key == d['key']:
v = d['value']
try:
v = json.loads(d['value'])
except RuntimeError as ex:
pass
return v
return None
def get_section(self):
return self._config
def get_rpcConfig(self):
return self.get_section()['rpc']
def get_zkConfig(self):
return self.get_section()['zk']
def get_env(self):
return self.get_section()['env']
def get_app_section(self):
return self._config['app']
def set_contain(self, p):
self.contain = p
@property
def host(self):
return self.get_app_section()['host']
@property
def port(self):
return self.get_app_section()['port']
@property
def root_rc_router(self):
return self.get_app_section()['root_rc_path']
#
# @property
# def root_sim_router(self):
# return self.get_app_section()['root_sim_path']
def get_cache_local_section(self):
return self._config['cache_local']
def get_repo_section(self):
return self._config['repo']
def get_rc_section(self):
return self._config['rc']
def get_jss_section(self):
return self._config['jss']
@property
def access_key(self):
return self.get_jss_section()['access_key']
@property
def secret_key(self):
return self.get_jss_section()['secret_key']
|
from sqlalchemy import Column, Integer, String, Boolean
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, sessionmaker
from sqlalchemy import create_engine
Base = declarative_base()
class Knowledge(Base):
__tablename__="knowledge"
knowledge_id=Column(Integer, primary_key=True)
article=Column(String)
topic=Column(String)
rating=Column(Integer)
def __repr__(self):
return(
"if you want to learn more about :{}\n"
"you should look at the article called:{}\n"
"and our rating of that article is:{}\n").format(
#self.knowledge_id,
self.topic,
self.article,
self.rating
)
# print(repr(Knowledge.__table__))
x=Knowledge(topic="food", article="gmo", rating=8)
y=Knowledge(topic="weather", article="rain", rating=5)
print(x)
print(y)
|
import logging
import os
import os.path
import shlex
import sys
import re
from io import StringIO
from dimcli import CLI, logger
cli = CLI()
# taken from unittest/python 2.7
def assertDictSubset(actual, expected, msg=None):
"""Checks whether actual is a superset of expected."""
missing = []
mismatched = []
for key, value in expected.items():
if key not in actual:
missing.append(key)
elif value != actual[key]:
mismatched.append('%s, expected: %s, actual: %s' %
(repr(key), repr(value),
repr(actual[key])))
if not (missing or mismatched):
return
msg = ''
if missing:
msg = 'Missing: %s' % ','.join(repr(m) for m in missing)
if mismatched:
if msg:
msg += '; '
msg += 'Mismatched values: %s' % ','.join(mismatched)
raise AssertionError(msg)
class NdcliResult(object):
def __init__(self, code, stdout, stderr):
self.code = code
self.stdout = stdout
self.stderr = stderr
@property
def ok(self):
return self.code == 0
@property
def err(self):
return self.code != 0
def __repr__(self):
return self.stdout
@property
def table(self):
return [l.split('\t') for l in self.stdout.splitlines()]
@property
def attrs(self):
return dict(l.split(':', 1) for l in self.stdout.splitlines())
def _ndcli(cmd, level=logging.WARNING):
stderr = StringIO()
stderrHandler = logging.StreamHandler(stderr)
stderrHandler.setFormatter(logging.Formatter('%(levelname)s - %(message)s'))
stderrHandler.setLevel(level)
logger.addHandler(stderrHandler)
old_stdout = sys.stdout
sys.stdout = stdout = StringIO()
code = cli.run(['ndcli'] + shlex.split(cmd))
sys.stdout = old_stdout
logger.removeHandler(stderrHandler)
return NdcliResult(code, stdout.getvalue(), stderr.getvalue())
# --username needs AUTHENTICATION_METHOD = None in dim.cfg
def reset_session():
try:
os.remove(os.path.expanduser('~/.ndcli.cookie'))
except:
pass
global cli
cli = CLI()
def admin(cmd):
reset_session()
return _ndcli("--username admin --password admin " + cmd)
ndcli = admin
def net(cmd):
reset_session()
return _ndcli("--username net --password net " + cmd)
def user(cmd):
reset_session()
return _ndcli("--username user --password user " + cmd)
def assert_match_table(table, matching_info):
def match(row, info):
if len(row) != len(info):
return False
for i in range(len(row)):
if type(info[i]) == str and info[i] != row[i]:
return False
elif re.match(info[i], row[i]) is None:
return False
return True
matches = {}
for t, row in enumerate(table):
matched = False
for m, info in enumerate(matching_info):
if match(row, info):
matched = True
matches[m] = t
break
if not matched:
raise AssertionError('Cannot match row %r' % row)
if len(matches) < len(matching_info):
raise AssertionError('Missing rows:\n' + '\n'.join(str(info) for m, info in enumerate(matching_info) if m not in matches))
|
'''
@author: aaditkamat
@date: 27/12/2018
'''
def reverse_words(string):
new_string = ''
for word in string.split(' '):
new_string += word[::-1] + ' '
return new_string
print("Enter a string: ", end= '')
string = input()
print("Reverse of string \'", string, "\': ", reverse_words(string), sep='') |
# -*- coding: utf-8 -*-
import unittest
from StringIO import StringIO
from mock import patch
from yalign.datatypes import Sentence
from yalign.train_data_generation import *
from yalign.train_data_generation import _aligned_samples, _misaligned_samples, _reorder, _random_range
def swap_start_and_end(xs):
xs[0], xs[-1] = xs[-1], xs[0]
def reader(N):
return StringIO('\n'.join([str(x) for x in xrange(N)]))
def sentences(xs):
return [Sentence([unicode(x)]) for x in xs]
class TestTrainingAlignmentsFromDocuments(unittest.TestCase):
def test_empty_inputs(self):
samples = list(training_alignments_from_documents([], []))
self.assertEquals(0, len(samples))
def test_samples_are_alignments_and_misalignments(self):
samples = list(training_alignments_from_documents(sentences([u'A', u'B', u'C']),
sentences([u'X', u'Y', u'Z'])))
self.assertEquals(6, len(samples))
self.assertEquals(3, len([x for x in samples if x.aligned]))
self.assertEquals(3, len([x for x in samples if not x.aligned]))
def test_documents_equal_length(self):
try:
list(training_alignments_from_documents([], sentences([u'A'])))
self.assertFalse("Failed to raise exception")
except ValueError as e:
self.assertEqual("Documents must be the same size", str(e))
class TestAlignedSamples(unittest.TestCase):
def test_empty_alignments(self):
A, B = [], []
samples = list(_aligned_samples(A, B, []))
self.assertEquals(0, len(samples))
def test_sample_values(self):
A, B = sentences([u'A', u'B']), sentences([u'Y', u'Z'])
samples = list(_aligned_samples(A, B, [(0, 1), (1, 0)]))
# Note alignments swapped so A -> Z and B-> Y
s0 = SentencePair(Sentence([u'A']), Sentence([u'Z']), aligned=True)
s1 = SentencePair(Sentence([u'B']), Sentence([u'Y']), aligned=True)
self.assertEquals(2, len(samples))
self.assertEquals([s0, s1], samples)
class TestNonAlignedSamples(unittest.TestCase):
def test_empty_alignments(self):
A, B = [], []
samples = list(_misaligned_samples(A, B, []))
self.assertEquals(0, len(samples))
def test_one_alignment(self):
# no misalignments when we have only one alignment
A, B = sentences(['A']), sentences(['Z'])
samples = list(_misaligned_samples(A, B, [(0, 0)]))
self.assertEquals(0, len(samples))
def test_sample_values(self):
A, B = sentences([u'A', u'B']), sentences([u'Y', u'Z'])
samples = list(_misaligned_samples(A, B, [(0, 0), (1, 1)]))
s0 = SentencePair(Sentence([u'A']), Sentence([u'Z']))
s1 = SentencePair(Sentence([u'B']), Sentence([u'Y']))
self.assertEquals(2, len(samples))
for sample in samples:
self.assertTrue(sample in [s0, s1])
def test_randomly(self):
for i in xrange(1000):
n = random.randint(2, 100)
A, B = sentences(xrange(n)), sentences(xrange(n))
alignments = zip(range(n), range(n))
samples = list(_misaligned_samples(A, B, alignments))
self.assertEquals(n, len(samples))
pairs = set([(a[0], b[0]) for a, b in samples])
#No duplicates
self.assertEquals(len(pairs), len(samples))
class TestReorder(unittest.TestCase):
def test_reoroder(self):
self.assertEquals([], _reorder([], []))
self.assertEquals([0], _reorder([0], [0]))
self.assertEquals([0, 1], _reorder([0, 1], [0, 1]))
self.assertEquals([1, 0], _reorder([0, 1], [1, 0]))
self.assertEquals([1, 2, 0], _reorder([0, 1, 2], [2, 0, 1]))
def test_indexes_size_correct(self):
self.assertRaises(ValueError, _reorder, [1, 2], [0])
self.assertRaises(ValueError, _reorder, [1], [0, 1])
class TestRandomAlign(unittest.TestCase):
def test_boundries(self):
self.assertEquals(([], [], []), training_scrambling_from_documents([], []))
self.assertEquals((sentences(['Y']), [], [(0, None)]), training_scrambling_from_documents(sentences(['Y']), []))
self.assertEquals(([], sentences(['Z']), [(None, 0)]), training_scrambling_from_documents([], sentences(['Z'])))
@patch('random.shuffle')
def test_unshuffled(self, mock_shuffle):
mock_shuffle.side_effect = lambda x: x
A, B = sentences(['A', 'B']), sentences(['Y', 'Z'])
self.assertEquals((A, B, [(0, 0), (1, 1)]), training_scrambling_from_documents(A, B))
A, B = sentences(['A', 'B']), sentences(['Y'])
self.assertEquals((A, B, [(0, 0), (1, None)]), training_scrambling_from_documents(A, B))
A, B = sentences(['A']), sentences(['Y', 'Z'])
self.assertEquals((A, B, [(None, 1), (0, 0)]), training_scrambling_from_documents(A, B))
@patch('random.randint')
@patch('random.shuffle')
def test_shuffled(self, mock_shuffle, mock_randint):
mock_randint.return_value = 2
mock_shuffle.side_effect = swap_start_and_end
A, B = sentences(['A', 'B']), sentences(['Y', 'Z'])
self.assertEquals((sentences(['B', 'A']), sentences(['Z', 'Y']), [(0, 0), (1, 1)]),
training_scrambling_from_documents(A, B))
A, B = sentences(['A', 'B']), sentences(['Y'])
self.assertEquals((sentences(['B', 'A']), B, [(0, None), (1, 0)]), training_scrambling_from_documents(A, B))
A, B = sentences(['A']), sentences(['Y', 'Z'])
self.assertEquals((A, sentences(['Z', 'Y']), [(None, 0), (0, 1)]), training_scrambling_from_documents(A, B))
class TestRandomRange(unittest.TestCase):
def test_boundries(self):
self.assertEquals([], _random_range(-1))
self.assertEquals([], _random_range(0))
self.assertEquals([0], _random_range(1))
self.assertEquals(5, len(_random_range(5)))
def test_span(self):
# any span <= 1 will lead to no shuffling
self.assertEquals(range(5), _random_range(5, span=1))
self.assertEquals(range(5), _random_range(5, span=0))
self.assertEquals(range(5), _random_range(5, span=-1))
self.assertEquals(3, len(_random_range(3, span=1000)))
def test_some_shuffling_happens(self):
self.assertNotEquals(range(100), _random_range(100))
@patch('random.randint')
@patch('random.shuffle')
def test_shuffling(self, mock_shuffle, mock_randint):
mock_randint.return_value = 2
mock_shuffle.side_effect = swap_start_and_end
self.assertEquals([1, 0, 3, 2], _random_range(4))
self.assertEquals([1, 0, 3, 2, 4], _random_range(5))
if __name__ == "__main__":
unittest.main()
|
"""
pyNRC - Python ETC and Simulator for JWST NIRCam
----------------------------------------------------------------------------
pyNRC is a set of Python-based tools for planning observations with JWST NIRCam,
such as an ETC, a simple image slope simulator, and an enhanced data simulator.
This package works for a variety of NIRCam observing modes including direct imaging,
coronagraphic imaging, slitless grism spectroscopy, DHS observations,
and weak lens imaging. All PSFs are generated via WebbPSF
(https://webbpsf.readthedocs.io) to reproduce realistic JWST images and spectra.
Developed by Jarron Leisenring and contributors at University of Arizona (2015-18).
"""
from __future__ import absolute_import, division, print_function, unicode_literals
from .version import __version__
import astropy
from astropy import config as _config
import tempfile
class Conf(_config.ConfigNamespace):
# Path to data files for pynrc.
# The environment variable $PYNRC_PATH takes priority.
import os
on_rtd = os.environ.get('READTHEDOCS') == 'True'
if on_rtd:
path = tempfile.gettempdir()
else:
path = os.getenv('PYNRC_PATH')
if path is None:
print("WARNING: Environment variable $PYNRC_PATH is not set!")
print(" Setting PYNRC_PATH to temporary directory.")
path = tempfile.gettempdir()
print(" {}".format(path))
#raise EnvironmentError("Environment variable $PYNRC_PATH is not set!")
if not os.path.isdir(path):
#print ("WARNING: PYNRC_PATH ({}) is not a valid directory path!".format(path))
raise IOError("PYNRC_PATH ({}) is not a valid directory path!".format(path))
if '/' not in path[-1]:
# Make sure there is a '/' at the end of the path name
path = path + '/'
PYNRC_PATH = _config.ConfigItem(path, 'Directory path to data files \
required for pynrc calculations.')
logging_level = _config.ConfigItem(
['INFO', 'DEBUG', 'WARN', 'WARNING', 'ERROR', 'CRITICAL', 'NONE'],
'Desired logging level for pyNRC.'
)
default_logging_level = _config.ConfigItem('INFO',
'Logging verbosity: one of {DEBUG, INFO, WARN, ERROR, or CRITICAL}')
logging_filename = _config.ConfigItem("none", "Desired filename to save log messages to.")
logging_format_screen = _config.ConfigItem(
'[%(name)10s:%(levelname)s] %(message)s', 'Format for lines logged to the screen.'
)
logging_format_file = _config.ConfigItem(
'%(asctime)s [%(name)s:%(levelname)s] %(filename)s:%(lineno)d: %(message)s',
'Format for lines logged to a file.'
)
conf = Conf()
from .logging_utils import setup_logging#, restart_logging
setup_logging(conf.default_logging_level, verbose=False)
from .nrc_utils import (read_filter, pix_noise, bp_2mass, bp_wise, \
stellar_spectrum, source_spectrum, planets_sb12)
from .pynrc_core import (DetectorOps, NIRCam)
from .obs_nircam import (obs_hci, nrc_hci)
from .detops import (multiaccum, det_timing, nrc_header)
#from .ngNRC import slope_to_ramp, nproc_use_ng
from .maths import *
from .simul import ngNRC
from .reduce import ref_pixels
from .reduce.calib import nircam_dark
from .testing import perform_benchmarks
def _reload(name="pynrc"):
"""
Simple reload function to test code changes without restarting python.
There may be some weird consequences and bugs that show up, such as
functions and attributes deleted from the code still stick around after
the reload. Although, this is even true with ``importlib.reload(pynrc)``.
Other possible ways to reload on-the-fly:
from importlib import reload
reload(pynrc)
# Delete classes/modules to reload
import sys
del sys.modules['pynrc.obs_nircam']
"""
import imp
imp.load_module(name,*imp.find_module(name))
print("{} reloaded".format(name))
|
"""
Tests that are reproductions of bugs found, to avoid regressions.
"""
from __future__ import print_function
from unittest import TestCase, skipIf
import numpy as np
from numpy.testing import run_module_suite, assert_allclose
from pkg_resources import parse_version
import gulinalg
class TestBugs(TestCase):
def test_uninit_gemm(self):
a = np.zeros((298, 64))
b = np.zeros((64, 298))
c = np.zeros((298, 298), order='F')
c.fill(np.nan)
gulinalg.matrix_multiply(a, b, out=c)
assert not np.isnan(c).any()
def test_zero_K_gemm(self):
a = np.zeros((2,0))
b = np.zeros((0,2))
c = np.empty((2,2), order="C")
c.fill(np.nan)
# make sure that the result is set to zero
gulinalg.matrix_multiply(a, b, out=c)
assert_allclose(c, np.zeros((2,2)))
# make sure that this works also when order is FORTRAN
c = np.empty((2,2), order="F")
c.fill(np.nan)
gulinalg.matrix_multiply(a, b, out=c)
assert_allclose(c, np.zeros((2,2)))
# check that the correct shape is created as well...
d = gulinalg.matrix_multiply(a,b)
assert_allclose(d, np.zeros((2,2)))
@skipIf(parse_version(np.__version__) < parse_version('1.13'),
"prior to numpy 1.13 gufunc machinery raises an error on this code")
def test_zero_MN_gemm(self):
# check other border cases...
e = gulinalg.matrix_multiply(np.zeros((0,2)), np.zeros((2,2)))
assert_allclose(e, np.zeros((0,2)))
f = gulinalg.matrix_multiply(np.zeros((2,2)), np.zeros((2,0)))
assert_allclose(f, np.zeros((2,0)))
if __name__ == '__main__':
run_module_suite()
|
from django.utils.translation import ugettext_lazy as _
from django_filters import RangeFilter, Filter
from mapentity.filters import MapEntityFilterSet
class OptionalRangeFilter(RangeFilter):
def __init__(self, *args, **kwargs):
super(OptionalRangeFilter, self).__init__(*args, **kwargs)
self.field.fields[0].label = _('min %s') % self.field.label
self.field.fields[1].label = _('max %s') % self.field.label
class YearFilter(Filter):
def do_filter(self, qs, year):
return qs.filter(**{
'%s__year' % self.field_name: year,
}).distinct()
def filter(self, qs, value):
try:
year = int(value)
except (ValueError, TypeError):
year = -1
return qs if year < 0 else self.do_filter(qs, year)
class ValueFilter(Filter):
def do_filter(self, qs, value):
return qs.filter(**{
'%s' % self.field_name: value,
}).distinct()
def filter(self, qs, value):
try:
new_value = int(value)
except (ValueError, TypeError):
new_value = -1
return qs if new_value < 0 else self.do_filter(qs, new_value)
class YearBetweenFilter(YearFilter):
def __init__(self, *args, **kwargs):
assert len(kwargs['field_name']) == 2
super(YearBetweenFilter, self).__init__(*args, **kwargs)
def do_filter(self, qs, year):
begin, end = self.field_name
qs = qs.filter(**{
'%s__lte' % begin: year,
'%s__gte' % end: year,
})
return qs
class StructureRelatedFilterSet(MapEntityFilterSet):
class Meta(MapEntityFilterSet.Meta):
fields = MapEntityFilterSet.Meta.fields + ['structure']
|
# Generated by Django 2.2.3 on 2019-07-13 07:27
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('rpsite', '0005_remove_evaluation_semaster'),
]
operations = [
migrations.RemoveField(
model_name='evaluationitem',
name='question',
),
]
|
import warnings
warnings.filterwarnings("ignore")
import sys
import time
sys.path.append("../")
from helper.utils import pd,random_seed_cpu_gpu,Print,read_pickle
from config import *
from tqdm import tqdm
from os.path import join
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os
import random
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from tqdm import tqdm
random_seed_cpu_gpu(RANDOM_STATE)
class Ae_data(Dataset):
def __init__(
self,
data,
ids,
swap_prob=swap_prob
):
self.data=data
self.ids=ids
self.swap_prob=swap_prob
def __getitem__(self, index):
x=self.data[index]
p=np.random.rand()<=self.swap_prob
if p :
swap_index=np.random.randint(self.__len__())
return x ,self.data[swap_index]
else :
return x,x
def __len__(self):
return len(self.data)
def train_func(
model,
criterion,
optimizer,
train_data_loader,
model_name,
n_epochs,
init_epoch=0,
path=""
):
train_losses = []
os.makedirs(path, exist_ok=True)
for epoch in range(init_epoch,n_epochs+1):
iterator_train = tqdm(train_data_loader)
epoch_train_losses = []
tr_loss=0
model.train()
for step, (x,y) in enumerate(iterator_train):
x = x.to(device).float()
y= y.to(device).float()
outputs=model(x)
loss = torch.sqrt(criterion(y, outputs))
loss.backward()
optimizer.step()
model.zero_grad()
epoch_train_losses.append(loss.item())
tr_loss+=loss.item()
iterator_train.set_postfix(epoch=epoch,loss=(loss.item()), loss_total=(tr_loss/((step+1))) )
train_losses.append(np.mean(epoch_train_losses))
if epoch%10==0:
torch.save(model.encoder.state_dict(),join(path,"encoder_{}".format(epoch)))
torch.save(model.decoder.state_dict(), join(path,"decoder_{}".format(epoch)))
return train_losses
class encoder_model(nn.Module):
def __init__(
self,
n_input
):
super(encoder_model, self).__init__()
self.lstm_1 = nn.LSTM(n_input,14, num_layers=1, batch_first=True, bidirectional=True)
self.lstm_2 = nn.LSTM(14*2,14, num_layers=1, batch_first=True, bidirectional=True)
self.latent = nn.LSTM(14*2,14,batch_first=True)
def forward(self, x):
lstm_1=self.lstm_1(x)[0]
lstm_2=self.lstm_2(lstm_1)[0]
latent=self.latent(lstm_2)[0]
return latent
class decoder_model(nn.Module):
def __init__(
self,
n_input,
n_output
):
super(decoder_model, self).__init__()
self.lstm_1 = nn.LSTM(n_input,14, num_layers=1, batch_first=True, bidirectional=True)
self.lstm_2 = nn.LSTM(14*2,14, num_layers=1, batch_first=True, bidirectional=True)
self.lstm_3 = nn.LSTM(14*2,14 ,batch_first=True)
self.output_layer=nn.Linear(14,n_output)
def forward(self, x):
lstm_1=self.lstm_1(x)[0]
lstm_2=self.lstm_2(lstm_1)[0]
lstm_3=self.lstm_3(lstm_2)[0]
output_layer=self.output_layer(lstm_3)
return output_layer
class AE_model(nn.Module):
def __init__(self,encoder,decoder ):
super(AE_model, self).__init__()
self.encoder=encoder
self.decoder=decoder
def forward(self, x):
encoder=self.encoder(x)
decoder=self.decoder(encoder)
return decoder
Print(" "*25+" Train denoising Autoencoder ")
Print("")
Print("1-Load the seq data ")
data=read_pickle(join(proc_data_path,"seq_data.p"))
train_batch_size=32
num_workers=8
model_name="final"
init_epoch=-1
Print("2- Create torch data loader ")
train_set = Ae_data(data=list(data.values()),ids=list(data.keys()))
train_loader = DataLoader(
train_set,
batch_size=train_batch_size,
shuffle=True,
num_workers=num_workers,
drop_last=True,
)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
Print("Device to use by torch is : "+ device.type)
Print("Create DAE model")
encoder=encoder_model(14)
decoderl=decoder_model(14,14)
ae=AE_model(encoder,decoderl)
ae.to(device)
optimizer = optim.Adam(ae.parameters(), lr=1e-4, eps=1e-8)
criterion = nn.MSELoss()
path =join(other_data_path,"ae",model_name)
if init_epoch > -1 :
ae.encoder.load_state_dict(torch.load(join(path,"encoder_{}".format(epoch)) ,map_location=device))
ae.decoder.load_state_dict(torch.load(join(path,"decoder_{}".format(epoch)) ,map_location=device))
n_epochs=2500
Print("Start training ")
start_time=time.time()
train_func(
ae,
criterion,
optimizer,
train_loader,
model_name,
n_epochs,
init_epoch+1,
path=path
)
end_time=start_time-time.time() |
import os
import sys
import time
import mimetypes
from http import HTTPStatus
import logging
from PIL import Image, ImageOps, ImageColor
# from PIL import ImageFile
# ImageFile.LOAD_TRUNCATED_IMAGES = True
from twms import config
from twms import correctify
from twms import fetchers
from twms import bbox as bbox_utils
from twms import projections
from twms import viewhtml
from twms import viewwms
sys.path.append(os.path.join(os.path.dirname(__file__)))
install_path = os.path.realpath(os.path.join(os.path.dirname(__file__), '../'))
class TWMSMain(object):
"""Inside tWMS, only EPSG:4326 latlon should be used for transmitting coordinates.
WMS http://cite.opengeospatial.org/OGCTestData/wms/1.1.1/spec/wms1.1.1.html
TMS
https://wiki.osgeo.org/wiki/Tile_Map_Service_Specification
https://gis-lab.info/docs/tms-specification-ru.html
WMTS
Web Map Tile Service Implementation Standard 2010-04-06 1.0.0
http://www.opengeospatial.org/standards/wmts
https://sampleserver6.arcgisonline.com/arcgis/rest/services/WorldTimeZones/MapServer/WMTS
Usually link to WMTSCapabilities.xml
"""
def __init__(self):
super(TWMSMain, self).__init__()
self.cached_objs = dict() # a dict. (layer, z, x, y): PIL image
self.cached_hist_list = list()
self.fetchers_pool = dict() # self.fetchers_pool[layer['prefix']]
def wms_handler(self, data):
"""Do main TWMS work. Some WMS implementation.
data - dictionary of params.
returns (HTTP_code, content_type, resp)
http://127.0.0.1:8080/?request=GetCapabilities&
http://127.0.0.1:8080/?request=GetCapabilities&version=1.0.0
"""
# WMS request keys must be case insensitive, values must not
data = {k.lower(): v for k, v in data.items()}
start_time = time.time()
srs = data.get("srs", "EPSG:4326")
wkt = data.get("wkt", "")
# color = data.get("color", data.get("colour", "")).split(",")
req_type = data.get("request", "GetMap")
version = data.get("version", "1.1.1")
ref = data.get("ref", config.service_url)
if req_type == "GetCapabilities":
content_type, resp = viewwms.get(version, ref)
return HTTPStatus.OK, content_type, resp
layer = data.get('layers', config.default_layers).split(",")
if 'layers' in data and not layer[0]:
layer = ['transparent']
if req_type == "GetCorrections":
points = data.get('points', '').split('=')
points = [a.split(",") for a in points]
points = [(float(a[0]), float(a[1])) for a in points]
resp = ""
for lay in layer:
for point in points:
resp += "%s,%s;" % (correctify.rectify(config.layers[lay], point))
resp += "\n"
return HTTPStatus.OK, 'text/plain', resp
force = data.get("force", "")
if force != "":
force = force.split(",")
force = tuple(force)
if layer == [""]:
return HTTPStatus.OK, 'text/html', viewhtml.html()
# Serving imagery
content_type = 'image/jpeg' # Default content type of image to serve
try:
# Get requested content type from standard WMS 'format' parameter,
# https://docs.geoserver.org/stable/en/user/services/wms/outputformats.html
content_type = data['format']
if content_type not in mimetypes.types_map.values():
return HTTPStatus.INTERNAL_SERVER_ERROR, 'text/plain', f"Invalid image format '{content_type}' requested"
except KeyError:
pass
width = 0
height = 0
z = int(data.get("z", 0))
x = int(data.get("x", 0))
y = int(data.get("y", 0))
if req_type == "GetTile":
# Both TMS and WMS
width = 256
height = 256
height = int(data.get("height", height))
width = int(data.get("width", width))
srs = data.get('srs', 'EPSG:3857')
# Try to return tile as is, if possible
if all((
len(layer) == 1,
layer[0] in config.layers,
'cache_ttl' not in config.layers[layer[0]], # Need to check time in fetcher
srs == config.layers[layer[0]]['proj'],
width == height == 256,
not force,
not correctify.has_corrections(config.layers[layer[0]]))):
tile_path = config.tiles_cache + config.layers[layer[0]]['prefix'] + "/{:.0f}/{:.0f}/{:.0f}{}".format(
z, x, y, config.layers[layer[0]]['ext'])
logging.debug(f"{layer[0]} z{z}/x{x}/y{y} query cache {tile_path}")
if os.path.exists(tile_path):
# Not returning HTTP 404
logging.info(f"{layer[0]} z{z}/x{x}/y{y} wms_handler cache hit {tile_path}")
with open(tile_path, 'rb') as f:
# Note: image file validation performed only in TileFetcher
return HTTPStatus.OK, content_type, f.read()
req_bbox = projections.from4326(projections.bbox_by_tile(z, x, y, srs), srs)
if data.get("bbox", None):
req_bbox = tuple(map(float, data.get("bbox", req_bbox).split(",")))
req_bbox = projections.to4326(req_bbox, srs)
req_bbox, flip_h = bbox_utils.normalize(req_bbox)
box = req_bbox
width = int(data.get("width", width))
height = int(data.get("height", height))
width = min(width, config.max_width)
height = min(height, config.max_height)
if width == height == 0:
width = 350
imgs = 1.0
ll = layer.pop(0)
if ll[-2:] == "!c":
ll = ll[:-2]
if wkt:
wkt = "," + wkt
wkt = correctify.corr_wkt(config.layers[ll]) + wkt
srs = config.layers[ll]["proj"]
try:
# WMS image
result_img = self.getimg(box, srs, (height, width), config.layers[ll], start_time, force)
except KeyError:
result_img = Image.new("RGBA", (width, height))
for ll in layer:
if ll[-2:] == "!c":
ll = ll[:-2]
if wkt:
wkt = "," + wkt
wkt = correctify.corr_wkt(config.layers[ll]) + wkt
srs = config.layers[ll]["proj"]
im2 = self.getimg(box, srs, (height, width), config.layers[ll], start_time, force)
if "empty_color" in config.layers[ll]:
ec = ImageColor.getcolor(config.layers[ll]["empty_color"], "RGBA")
sec = set(ec)
if "empty_color_delta" in config.layers[ll]:
delta = config.layers[ll]["empty_color_delta"]
for tr in range(-delta, delta):
for tg in range(-delta, delta):
for tb in range(-delta, delta):
if (
(ec[0] + tr) >= 0
and (ec[0] + tr) < 256
and (ec[1] + tr) >= 0
and (ec[1] + tr) < 256
and (ec[2] + tr) >= 0
and (ec[2] + tr) < 256
):
sec.add((ec[0] + tr, ec[1] + tg, ec[2] + tb, ec[3]))
i2l = im2.load()
for x in range(0, im2.size[0]):
for y in range(0, im2.size[1]):
t = i2l[x, y]
if t in sec:
i2l[x, y] = (t[0], t[1], t[2], 0)
if not im2.size == result_img.size:
im2 = im2.resize(result_img.size, Image.ANTIALIAS)
im2 = Image.composite(im2, result_img, im2.split()[3]) # imgs/(imgs+1.))
if 'noblend' in force:
result_img = im2
else:
result_img = Image.blend(im2, result_img, 0.5)
imgs += 1.0
if flip_h:
result_img = ImageOps.flip(result_img)
return HTTPStatus.OK, content_type, fetchers.im_convert(result_img, content_type)
def tiles_handler(self, layer_id, z, x, y, content_type):
"""Partial slippy map implementation. Serve tiles by index, reproject, if required.
Experimental handler.
http://localhost:8080/tiles/vesat/0/0/0.jpg
Return 404 instead of blank tile.
"""
logging.debug(f"{layer_id} z{z}/x{x}/y{y} tiles_handler")
if config.layers[layer_id]['proj'] != 'EPSG:3857':
raise NotImplementedError("Reprojection is not supported, use wms for this tile set")
z, x, y = int(z), int(x), int(y)
im = self.tile_image(config.layers[layer_id], z, x, y, time.time(), real=True)
if im:
return HTTPStatus.OK, content_type, fetchers.im_convert(im, content_type)
else:
return HTTPStatus.NOT_FOUND, 'text/plain', "404 Not Found"
def getimg(self, bbox, request_proj, size, layer, start_time, force):
"""Get tile by a given bbox.
"""
orig_bbox = bbox
## Making 4-corner maximal bbox
bbox_p = projections.from4326(bbox, request_proj)
bbox_p = projections.to4326(
(bbox_p[2], bbox_p[1], bbox_p[0], bbox_p[3]), request_proj)
bbox_4 = (
(bbox_p[2], bbox_p[3]),
(bbox[0], bbox[1]),
(bbox_p[0], bbox_p[1]),
(bbox[2], bbox[3]))
if 'nocorrect' not in force:
bb4 = []
for point in bbox_4:
bb4.append(correctify.rectify(layer, point))
bbox_4 = bb4
bbox = bbox_utils.expand_to_point(bbox, bbox_4)
H, W = size
max_zoom = layer.get("max_zoom", config.default_max_zoom)
min_zoom = layer.get("min_zoom", config.default_min_zoom)
zoom = bbox_utils.zoom_for_bbox(
bbox, size, layer, min_zoom, max_zoom, (config.max_height, config.max_width)
)
from_tile_x, from_tile_y, to_tile_x, to_tile_y = projections.tile_by_bbox(
bbox, zoom, layer["proj"]
)
cut_from_x = int(256 * (from_tile_x - int(from_tile_x)))
cut_from_y = int(256 * (from_tile_y - int(from_tile_y)))
cut_to_x = int(256 * (to_tile_x - int(to_tile_x)))
cut_to_y = int(256 * (to_tile_y - int(to_tile_y)))
from_tile_x, from_tile_y = int(from_tile_x), int(from_tile_y)
to_tile_x, to_tile_y = int(to_tile_x), int(to_tile_y)
bbox_im = (
cut_from_x,
cut_to_y,
256 * (to_tile_x - from_tile_x) + cut_to_x,
256 * (from_tile_y - to_tile_y) + cut_from_y,
)
x = 256 * (to_tile_x - from_tile_x + 1)
y = 256 * (from_tile_y - to_tile_y + 1)
out = Image.new("RGBA", (x, y))
for x in range(from_tile_x, to_tile_x + 1):
for y in range(to_tile_y, from_tile_y + 1):
im1 = self.tile_image(layer, zoom, x, y, start_time, real=True)
if not im1:
ec = ImageColor.getcolor(
layer.get("empty_color", config.default_background), "RGBA")
im1 = Image.new("RGBA", (256, 256), ec)
out.paste(im1, ((x - from_tile_x) * 256, (-to_tile_y + y) * 256))
## TODO: Here's a room for improvement. we could drop this crop in case user doesn't need it.
out = out.crop(bbox_im)
if "noresize" not in force:
if (H == W) and (H == 0):
W, H = out.size
if H == 0:
H = out.size[1] * W // out.size[0]
if W == 0:
W = out.size[0] * H // out.size[1]
# bbox = orig_bbox
quad = list()
trans_needed = False
for point in bbox_4:
x = (point[0] - bbox[0]) / (bbox[2] - bbox[0]) * (out.size[0])
y = (1 - (point[1] - bbox[1]) / (bbox[3] - bbox[1])) * (out.size[1])
x = int(round(x))
y = int(round(y))
if (x != 0 and x != out.size[0]) or (y != 0 and y != out.size[1]):
trans_needed = True
quad.append(x)
quad.append(y)
if trans_needed:
quad = tuple(quad)
out = out.transform((W, H), Image.QUAD, quad, Image.BICUBIC)
elif (W != out.size[0]) or (H != out.size[1]):
"just resize"
out = out.resize((W, H), Image.ANTIALIAS)
return out
def tile_image(self, layer, z, x, y, start_time, trybetter=True, real=False):
"""Get tile by given coordinates.
Returns asked tile (from cache, fetcher, or recursively rescaled).
again - is this a second pass on this tile?
trybetter - should we try to combine this tile from better ones?
real - should we return the tile even in not good quality?
dsc.downscale?
ups.upscale?
Function must return None if image is invalid or unavailable
"""
tile = None
# Dedicated fetcher for each imagery layer - if one fetcher hangs,
# others should be responsive
if layer['prefix'] not in self.fetchers_pool:
self.fetchers_pool[layer['prefix']] = fetchers.TileFetcher(layer)
x = x % (2 ** z)
if y < 0 or y >= (2 ** z) or z < 0:
logging.warning(f"{layer['prefix']}/z{z}/x{x}/y{y} impossible tile coordinates")
return None
if not bbox_utils.bbox_is_in(
projections.bbox_by_tile(z, x, y, layer["proj"]), layer.get('bounds', config.default_bbox), fully=False):
logging.info(f"{layer['prefix']}/z{z}/x{x}/y{y} ignoring request for a tile outside configured bounds")
return None
if 'prefix' in layer:
if (layer['prefix'], z, x, y) in self.cached_objs:
logging.debug(f"{layer['prefix']}/z{z}/x{x}/y{y} RAM cache hit")
return self.cached_objs[(layer["prefix"], z, x, y)]
# Working with cache
if layer['scalable'] and (z < layer.get('max_zoom', config.default_max_zoom)) and trybetter:
# Second, try to glue image of better ones
logging.info(f"{layer['prefix']}/z{z}/x{x}/y{y} downscaling from 4 subtiles")
# # Load upscaled images
# if os.path.exists(local + "ups" + ext):
# try:
# im = Image.open(local + "ups" + ext)
# return im
# except OSError:
# pass
ec = ImageColor.getcolor(layer.get("empty_color", config.default_background), "RGBA")
ec = (ec[0], ec[1], ec[2], 0)
im = Image.new("RGBA", (512, 512), ec)
im1 = self.tile_image(layer, z + 1, x * 2, y * 2, start_time)
if im1:
im2 = self.tile_image(layer, z + 1, x * 2 + 1, y * 2, start_time)
if im2:
im3 = self.tile_image(layer, z + 1, x * 2, y * 2 + 1, start_time)
if im3:
im4 = self.tile_image(layer, z + 1, x * 2 + 1, y * 2 + 1, start_time)
if im4:
im.paste(im1, (0, 0))
im.paste(im2, (256, 0))
im.paste(im3, (0, 256))
im.paste(im4, (256, 256))
tile = im.resize((256, 256), Image.ANTIALIAS)
# if layer.get("cached", True):
# try:
# im.save(local + "ups" + ext)
# except OSError:
# pass
if tile is None and 'fetch' in layer:
seconds_spent = time.time() - start_time
if (config.deadline > seconds_spent) or (z < 4):
# Try fetching img from outside
logging.debug(f"{layer['prefix']}/z{z}/x{x}/y{y} creating dl thread")
tile = self.fetchers_pool[layer['prefix']].fetch(z, x, y)
if tile is None and real and z > 0:
# Downscale?
logging.info(f"{layer['prefix']}/z{z}/x{x}/y{y} upscaling from top tile")
im = self.tile_image(layer, z - 1, int(x // 2), int(y // 2), start_time, trybetter=False, real=True)
if im:
im = im.crop(
(
128 * (x % 2),
128 * (y % 2),
128 * (x % 2) + 128,
128 * (y % 2) + 128,
)
)
tile = im.resize((256, 256), Image.BILINEAR)
# RAM cache. Better use decorator?
if (layer['prefix'], z, x, y) not in self.cached_objs:
self.cached_objs[(layer['prefix'], z, x, y)] = tile
self.cached_hist_list.append((layer['prefix'], z, x, y))
if len(self.cached_objs) >= config.max_ram_cached_tiles:
del self.cached_objs[self.cached_hist_list.pop(0)]
return tile
|
# Consult the ruby example |
# Copyright (c) 2016 Ericsson AB.
# 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 collections
import time
from cinderclient import client as ci_client
from keystoneclient.auth.identity import v3
from keystoneclient import session
from keystoneclient.v3 import client as ks_client
from kingbirdclient.api.v1 import client as kb_client
from neutronclient.neutron import client as nt_client
from novaclient import client as nv_client
from oslo_log import log as logging
from tempest import config
CONF = config.CONF
NOVA_API_VERSION = "2.1"
NEUTRON_API_VERSION = "2.0"
CINDER_API_VERSION = "2"
VOLUME_SIZE = 1
VOLUME_NAME = "kb_test_volume"
FLAVOR_NAME = "kb_test_flavor"
NETWORK_NAME = "kb_test_network"
SUBNET_NAME = "kb_test_subnet"
SERVER_NAME = "kb_test_server"
SUBNET_RANGE = "192.168.199.0/24"
KINGBIRD_URL = CONF.kingbird.endpoint_url + CONF.kingbird.api_version
LOG = logging.getLogger(__name__)
def get_session():
return get_current_session(
CONF.auth.admin_username,
CONF.auth.admin_password,
CONF.auth.admin_project_name
)
def get_current_session(username, password, tenant_name):
auth = v3.Password(
auth_url=CONF.identity.uri_v3,
username=username,
password=password,
project_name=tenant_name,
user_domain_name=CONF.auth.admin_domain_name,
project_domain_name=CONF.auth.admin_domain_name)
sess = session.Session(auth=auth)
return sess
def get_openstack_drivers(keystone_client, region, project_name, user_name,
password, target_project_name, target_user_name):
resources = dict()
# Create Project, User and assign role to new user
project = keystone_client.projects.create(project_name,
CONF.auth.admin_domain_name)
user = keystone_client.users.create(user_name, CONF.auth.admin_domain_name,
project.id, password)
target_project = keystone_client.projects.create(
target_project_name, CONF.auth.admin_domain_name)
target_user = keystone_client.users.create(target_user_name,
CONF.auth.admin_domain_name,
target_project.id, password)
admin_role = [current_role.id for current_role in
keystone_client.roles.list()
if current_role.name == 'admin'][0]
mem_role = [current_role.id for current_role in
keystone_client.roles.list()
if current_role.name == 'Member'][0]
keystone_client.roles.grant(admin_role, user=user, project=project)
keystone_client.roles.grant(mem_role, user=target_user,
project=target_project)
session = get_current_session(user_name, password, project_name)
target_session = get_current_session(target_user_name, password,
target_project_name)
target_keystone_client = ks_client.Client(session=target_session)
target_token = target_keystone_client.session.get_token()
new_keystone_client = ks_client.Client(session=session)
token = new_keystone_client.session.get_token()
nova_client = nv_client.Client(NOVA_API_VERSION,
session=session,
region_name=region)
neutron_client = nt_client.Client(NEUTRON_API_VERSION, session=session,
region_name=region)
cinder_client = ci_client.Client(CINDER_API_VERSION, session=session,
region_name=region)
kingbird_client = kb_client.Client(kingbird_url=KINGBIRD_URL,
auth_token=token,
project_id=project.id)
dummy_kingbird_client = kb_client.Client(kingbird_url=KINGBIRD_URL,
auth_token='fake_token',
project_id=project.id)
resources = {"user_id": user.id, "project_id": project.id,
"session": session, "token": token,
"target_token": target_token,
"target_project_id": target_project.id,
"target_user_id": target_user.id,
"os_drivers": {'keystone': keystone_client,
'nova': nova_client,
'neutron': neutron_client,
'cinder': cinder_client,
'kingbird': kingbird_client,
'dummy_kb': dummy_kingbird_client}}
return resources
def get_keystone_client(session):
return ks_client.Client(session=session)
def create_instance(openstack_drivers, resource_ids, count=1):
nova_client = openstack_drivers['nova']
server_ids = []
image = nova_client.images.find(id=CONF.compute.image_ref)
flavor = nova_client.flavors.find(id=resource_ids['flavor_id'])
try:
for x in range(count):
server = nova_client.servers.create(
SERVER_NAME, image, flavor,
nics=[{'net-id': resource_ids['network_id']}])
server_ids.append(server.id)
return server_ids
except Exception as e:
e.args = tuple(server_ids)
raise e
def create_custom_kingbird_quota(openstack_drivers, project_id, new_quota):
kingbird_client = openstack_drivers['kingbird']
kwargs = new_quota
response = kingbird_client.quota_manager.\
update_global_limits(project_id, **kwargs)
result = {i._data: i._Limit for i in response}
return result
def get_kingbird_quota_another_tenant(openstack_drivers, project_id):
kingbird_client = openstack_drivers['kingbird']
response = kingbird_client.quota_manager.\
global_limits(project_id)
result = {i._data: i._Limit for i in response}
return result
def get_own_kingbird_quota(token, project_id):
kingbird_client = kb_client.Client(kingbird_url=KINGBIRD_URL,
auth_token=token,
project_id=project_id)
response = kingbird_client.quota_manager.\
global_limits(project_id)
result = {i._data: i._Limit for i in response}
return result
def delete_custom_kingbird_quota(openstack_drivers, target_project_id):
kingbird_client = openstack_drivers['kingbird']
kingbird_client.quota_manager.delete_quota(target_project_id)
def get_default_kingbird_quota(token, project_id):
kingbird_client = kb_client.Client(kingbird_url=KINGBIRD_URL,
auth_token=token,
project_id=project_id)
response = kingbird_client.quota_manager.\
list_defaults()
result = {i._data: i._Limit for i in response}
return result
def kingbird_create_quota_wrong_token(openstack_drivers,
project_id, new_quota):
kingbird_client = openstack_drivers['dummy_kb']
kwargs = new_quota
kingbird_client.quota_manager.\
update_global_limits(project_id, **kwargs)
def quota_sync_for_project(openstack_drivers, project_id):
kingbird_client = openstack_drivers['kingbird']
kingbird_client.quota_manager.sync_quota(project_id)
def get_quota_usage_for_project(openstack_drivers, project_id):
kingbird_client = openstack_drivers['kingbird']
data = kingbird_client.quota_manager.quota_detail(project_id)
response = {items._data: [items._Limit, items._Usage] for items in data}
return response
def get_regions(keystone_client):
return [current_region.id for current_region in
keystone_client.regions.list()]
def delete_resource_with_timeout(service_client, resource_ids, service_type):
# Delete the resources based on service_type argument
for resource_id in resource_ids:
if service_type == 'nova':
# Delete nova servers
service_client.servers.delete(resource_id)
elif service_type == 'cinder':
# Delete cinder volumes
service_client.volumes.delete(resource_id)
else:
LOG.exception('Invalid service type: %s' % service_type)
return
retries = 6
# Delete may take time, So wait(with timeout) till the
# resources are deleted
while retries > 0:
LOG.debug("waiting for resources to get deleted")
time.sleep(1)
if service_type == 'nova':
resource_list = [current_server.id for current_server in
service_client.servers.list()]
elif service_type == 'cinder':
resource_list = [current_volume.id for current_volume in
service_client.volumes.list()]
# Check if there is any resource left in resource list
if len(set(resource_ids) & set(resource_list)):
continue
else:
# Deleted all the resources
return
LOG.exception('Resource deleting failed, manually delete with IDs %s'
% resource_ids)
def delete_instance(openstack_drivers, resource_ids):
delete_resource_with_timeout(
openstack_drivers['nova'],
resource_ids['server_ids'], 'nova')
resource_ids['server_ids'] = []
def delete_volume(openstack_drivers, resource_ids):
delete_resource_with_timeout(
openstack_drivers['cinder'],
resource_ids['volume_ids'], 'cinder')
resource_ids['volume_ids'] = []
def resource_cleanup(openstack_drivers, resource_ids):
keystone_client = openstack_drivers['keystone']
nova_client = openstack_drivers['nova']
neutron_client = openstack_drivers['neutron']
delete_instance(openstack_drivers, resource_ids)
delete_volume(openstack_drivers, resource_ids)
nova_client.flavors.delete(resource_ids['flavor_id'])
neutron_client.delete_subnet(resource_ids['subnet_id'])
neutron_client.delete_network(resource_ids['network_id'])
keystone_client.projects.delete(resource_ids['project_id'])
keystone_client.projects.delete(resource_ids['target_project_id'])
keystone_client.users.delete(resource_ids['user_id'])
keystone_client.users.delete(resource_ids['target_user_id'])
def get_usage_from_os_client(session, regions, project_id):
resource_usage_all = collections.defaultdict(dict)
neutron_opts = {'tenant_id': project_id}
cinder_opts = {'all_tenants': 1, 'project_id': project_id}
for current_region in regions:
resource_usage = collections.defaultdict(dict)
nova_client = nv_client.Client(NOVA_API_VERSION,
session=session,
region_name=current_region)
neutron_client = nt_client.Client(NEUTRON_API_VERSION,
session=session,
region_name=current_region)
cinder_client = ci_client.Client(CINDER_API_VERSION,
session=session,
region_name=current_region)
limits = nova_client.limits.get().to_dict()
# Read nova usages
resource_usage['ram'] = limits['absolute']['totalRAMUsed']
resource_usage['cores'] = limits['absolute']['totalCoresUsed']
resource_usage['instances'] = limits['absolute']['totalInstancesUsed']
resource_usage['key_pairs'] = len(nova_client.keypairs.list())
# Read neutron usages
resource_usage['network'] = len(neutron_client.list_networks(
**neutron_opts)['networks'])
resource_usage['subnet'] = len(neutron_client.list_subnets(
**neutron_opts)['subnets'])
# Read cinder usages
resource_usage['volumes'] = len(cinder_client.volumes.list(
search_opts=cinder_opts))
resource_usage_all[current_region] = resource_usage
return resource_usage_all
def get_actual_limits(session, regions, project_id):
resource_usage = collections.defaultdict(dict)
for current_region in regions:
nova_client = nv_client.Client(NOVA_API_VERSION,
session=session,
region_name=current_region)
neutron_client = nt_client.Client(NEUTRON_API_VERSION,
session=session,
region_name=current_region)
cinder_client = ci_client.Client(CINDER_API_VERSION,
session=session,
region_name=current_region)
updated_nova_quota = nova_client.quotas.get(project_id)
updated_neutron_quota = neutron_client.show_quota(
project_id)['quota']['network']
updated_cinder_quota = cinder_client.quotas.get(project_id)
resource_usage.update({current_region: [updated_nova_quota.instances,
updated_neutron_quota,
updated_cinder_quota.volumes]})
return resource_usage
def create_resources(openstack_drivers):
nova_client = openstack_drivers['nova']
neutron_client = openstack_drivers['neutron']
cinder_client = openstack_drivers['cinder']
volume = cinder_client.volumes.create(VOLUME_SIZE,
name=VOLUME_NAME)
flavor = nova_client.flavors.create(
FLAVOR_NAME, 128, 1, 1, flavorid='auto')
network_body = {'network': {'name': NETWORK_NAME, 'admin_state_up': True}}
network = neutron_client.create_network(body=network_body)
body_create_subnet = {
"subnets": [
{
'cidr': SUBNET_RANGE,
'ip_version': 4,
'network_id': network['network']['id'],
'name': SUBNET_NAME
}
]
}
subnet = neutron_client.create_subnet(body=body_create_subnet)
return {
'subnet_id': subnet['subnets'][0]['id'],
'network_id': network['network']['id'],
'flavor_id': flavor.id,
'volume_ids': [volume.id]
}
def set_default_quota(session, regions, project_id, **quota_to_set):
for current_region in regions:
nova_client = nv_client.Client(NOVA_API_VERSION,
session=session,
region_name=current_region)
nova_client.quotas.update(project_id, **quota_to_set)
def update_quota_for_class(openstack_drivers, class_name, new_quota_values):
kingbird_client = openstack_drivers['kingbird']
kwargs = new_quota_values
response = kingbird_client.quota_class_manager.\
quota_class_update(class_name, **kwargs)
result = {i._data: i._Limit for i in response}
return result
def get_quota_for_class(openstack_drivers, class_name):
kingbird_client = openstack_drivers['kingbird']
response = kingbird_client.quota_class_manager.\
list_quota_class(class_name)
result = {i._data: i._Limit for i in response}
return result
def delete_quota_for_class(openstack_drivers, class_name):
kingbird_client = openstack_drivers['kingbird']
kingbird_client.quota_class_manager.\
delete_quota_class(class_name)
|
from .bloom_filter import BloomFilter
from .counting_bloom_filter import CountingBloomFilter
__all__ = ["BloomFilter", "CountingBloomFilter"]
|
import json
from typing import Dict, Any, List, Optional
from app.components.servers.game_server import GameServer
from app.components.servers.server_config import ServerConfig
class Config:
def __init__(self, config_text: Optional[str]) -> None:
if config_text is None:
self.servers = []
else:
config = json.loads(config_text)
self.servers = self.load_server_configs(config)
@staticmethod
def load_server_configs(config: Dict[str, Any]) -> List[ServerConfig]:
return [ServerConfig(server_data) for server_data in config['servers']]
def create_servers(self) -> Dict[str, GameServer]:
return {server_config.name: server_config.get_server() for server_config in self.servers}
|
from rest_framework import serializers
from .models import Profile,Post
from django.contrib.auth.models import User
class ProfileSerializer(serializers.ModelSerializer):
class Meta:
model = Profile
fields = ('name', 'bio','photo')
class UserSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = ('username', 'email')
class PostSerializer(serializers.ModelSerializer):
class Meta:
model = Post
fields = ('title', 'description','url','category','image') |
#!/usr/bin/env python3
import fileinput
import math
if __name__ == '__main__':
factor = 1 / (2. * math.pi)
for n in fileinput.input():
n = int(n)
if n == 0:
break
print('%.2f' % (math.pow(n, 2)*factor))
|
from flask import render_template
def city404(func):
def wrapper():
try:
return func()
except KeyError:
return render_template('error.html')
return wrapper |
#!/usr/bin/env python3
#
# Copyright (c) 2020 Intel Corporation
#
# SPDX-License-Identifier: Apache-2.0
from gdbstubs.arch.x86 import GdbStub_x86
from gdbstubs.arch.x86_64 import GdbStub_x86_64
from gdbstubs.arch.arm_cortex_m import GdbStub_ARM_CortexM
from gdbstubs.arch.risc_v import GdbStub_RISC_V
from gdbstubs.arch.xtensa import GdbStub_Xtensa
class TgtCode:
UNKNOWN = 0
X86 = 1
X86_64 = 2
ARM_CORTEX_M = 3
RISC_V = 4
XTENSA = 5
def get_gdbstub(logfile, elffile):
stub = None
tgt_code = logfile.log_hdr['tgt_code']
if tgt_code == TgtCode.X86:
stub = GdbStub_x86(logfile=logfile, elffile=elffile)
elif tgt_code == TgtCode.X86_64:
stub = GdbStub_x86_64(logfile=logfile, elffile=elffile)
elif tgt_code == TgtCode.ARM_CORTEX_M:
stub = GdbStub_ARM_CortexM(logfile=logfile, elffile=elffile)
elif tgt_code == TgtCode.RISC_V:
stub = GdbStub_RISC_V(logfile=logfile, elffile=elffile)
elif tgt_code == TgtCode.XTENSA:
stub = GdbStub_Xtensa(logfile=logfile, elffile=elffile)
return stub
|
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: pogoprotos/data/pokemon_display.proto
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflection
from google.protobuf import symbol_database as _symbol_database
from google.protobuf import descriptor_pb2
# @@protoc_insertion_point(imports)
_sym_db = _symbol_database.Default()
from pogoprotos.enums import costume_pb2 as pogoprotos_dot_enums_dot_costume__pb2
from pogoprotos.enums import form_pb2 as pogoprotos_dot_enums_dot_form__pb2
from pogoprotos.enums import gender_pb2 as pogoprotos_dot_enums_dot_gender__pb2
DESCRIPTOR = _descriptor.FileDescriptor(
name='pogoprotos/data/pokemon_display.proto',
package='pogoprotos.data',
syntax='proto3',
serialized_pb=_b('\n%pogoprotos/data/pokemon_display.proto\x12\x0fpogoprotos.data\x1a\x1epogoprotos/enums/costume.proto\x1a\x1bpogoprotos/enums/form.proto\x1a\x1dpogoprotos/enums/gender.proto\"\x9b\x01\n\x0ePokemonDisplay\x12*\n\x07\x63ostume\x18\x01 \x01(\x0e\x32\x19.pogoprotos.enums.Costume\x12(\n\x06gender\x18\x02 \x01(\x0e\x32\x18.pogoprotos.enums.Gender\x12\r\n\x05shiny\x18\x03 \x01(\x08\x12$\n\x04\x66orm\x18\x04 \x01(\x0e\x32\x16.pogoprotos.enums.Formb\x06proto3')
,
dependencies=[pogoprotos_dot_enums_dot_costume__pb2.DESCRIPTOR,pogoprotos_dot_enums_dot_form__pb2.DESCRIPTOR,pogoprotos_dot_enums_dot_gender__pb2.DESCRIPTOR,])
_sym_db.RegisterFileDescriptor(DESCRIPTOR)
_POKEMONDISPLAY = _descriptor.Descriptor(
name='PokemonDisplay',
full_name='pogoprotos.data.PokemonDisplay',
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
name='costume', full_name='pogoprotos.data.PokemonDisplay.costume', index=0,
number=1, type=14, cpp_type=8, label=1,
has_default_value=False, default_value=0,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='gender', full_name='pogoprotos.data.PokemonDisplay.gender', index=1,
number=2, type=14, cpp_type=8, label=1,
has_default_value=False, default_value=0,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='shiny', full_name='pogoprotos.data.PokemonDisplay.shiny', index=2,
number=3, type=8, cpp_type=7, label=1,
has_default_value=False, default_value=False,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
_descriptor.FieldDescriptor(
name='form', full_name='pogoprotos.data.PokemonDisplay.form', index=3,
number=4, type=14, cpp_type=8, label=1,
has_default_value=False, default_value=0,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
options=None),
],
extensions=[
],
nested_types=[],
enum_types=[
],
options=None,
is_extendable=False,
syntax='proto3',
extension_ranges=[],
oneofs=[
],
serialized_start=151,
serialized_end=306,
)
_POKEMONDISPLAY.fields_by_name['costume'].enum_type = pogoprotos_dot_enums_dot_costume__pb2._COSTUME
_POKEMONDISPLAY.fields_by_name['gender'].enum_type = pogoprotos_dot_enums_dot_gender__pb2._GENDER
_POKEMONDISPLAY.fields_by_name['form'].enum_type = pogoprotos_dot_enums_dot_form__pb2._FORM
DESCRIPTOR.message_types_by_name['PokemonDisplay'] = _POKEMONDISPLAY
PokemonDisplay = _reflection.GeneratedProtocolMessageType('PokemonDisplay', (_message.Message,), dict(
DESCRIPTOR = _POKEMONDISPLAY,
__module__ = 'pogoprotos.data.pokemon_display_pb2'
# @@protoc_insertion_point(class_scope:pogoprotos.data.PokemonDisplay)
))
_sym_db.RegisterMessage(PokemonDisplay)
# @@protoc_insertion_point(module_scope)
|
import csv
#-------------------------------------------------------------------------------
def dSdt(beta, gamma, N, t_n, s_n, i_n):
return (-beta*i_n*s_n)/N
def dIdt(beta, gamma, N, t_n, s_n, i_n):
return ((beta*i_n*s_n)/N)-gamma*i_n
def dRdt(beta, gamma, N, t_n, s_n, i_n):
return gamma*i_n
#-------------------------------------------------------------------------------
def Runge_Kutta(beta, gamma, N, dF, F, t_n, s_n, i_n, r_n, dt):
k1 = dF(beta, gamma, N, t_n, s_n, i_n)
k2 = dF(beta, gamma, N, t_n + dt/2, s_n + dt*k1/2, i_n + dt*k1/2)
k3 = dF(beta, gamma, N, t_n + dt/2, s_n + dt*k2/2, i_n + dt*k2/2)
k4 = dF(beta, gamma, N, t_n + dt, s_n + dt*k3, i_n + dt*k3)
F_n_plus_one= F[-1] + dt/6*(k1 + 2*k2 + 2*k3 + k4)
F.append(F_n_plus_one)
#-------------------------------------------------------------------------------
def Create_Table(T, S, I, R):
myFile = open('Tabla_SIR.csv', 'w')
with myFile:
writer = csv.writer(myFile)
writer.writerow(["t", "S(t)", "I(t)", "R(t)", "N"])
for t_n in T:
writer.writerow([t_n, S[t_n], I[t_n], R[t_n], S[t_n]+I[t_n]+R[t_n]])
#-------------------------------------------------------------------------------
|
from unittest import TestCase
from unittest import main
from integer_difference import int_diff
class TestIntegerDifference(TestCase):
def test_int_diff(self):
ptr = [
([1, 1, 5, 6, 9, 16, 27], 4, 3),
([1, 1, 3, 3], 2, 4),
]
for inp, d, exp in ptr:
with self.subTest(inp=inp, d=d, exp=exp):
self.assertEqual(int_diff(arr=inp, n=d), exp)
if __name__ == "__main__":
main(verbosity=2)
|
import torch
# TODO: write docstrings
class SimpleDynamics(torch.nn.Module):
def __init__(self, dynamics_function, divergence_estimator):
super().__init__()
self._dynamics_function = dynamics_function
self._divergence_estimator = divergence_estimator
def forward(self, *xs, compute_divergence=True):
if compute_divergence:
*dxs, divergence = self._divergence_estimator(
self._dynamics_function, *xs
)
else:
dxs = self._dynamics_function(xs)
divergence = None
return (*dxs, divergence) |
from DealUUIDGenerator import DealUUIDGenerator
class TestClass(object):
def test_singleExchangeConstantProfit(self):
dealUUIDGenerator = DealUUIDGenerator()
id1 = dealUUIDGenerator.getUUID(timestamp=1, volBTC=1, nodesStr="bitstamp,coinbasepro", profitPerc=0.5)
id2 = dealUUIDGenerator.getUUID(timestamp=2, volBTC=1, nodesStr="bitstamp,coinbasepro", profitPerc=0.5)
id3 = dealUUIDGenerator.getUUID(timestamp=7, volBTC=1, nodesStr="bitstamp,coinbasepro", profitPerc=0.5)
id4 = dealUUIDGenerator.getUUID(timestamp=12.1, volBTC=1, nodesStr="bitstamp,coinbasepro", profitPerc=0.5)
id5 = dealUUIDGenerator.getUUID(timestamp=12.2, volBTC=1, nodesStr="bitstamp,coinbasepro", profitPerc=0.5)
id6 = dealUUIDGenerator.getUUID(timestamp=12.3, volBTC=1, nodesStr="bitstamp,coinbasepro", profitPerc=0.51)
assert id1 == id2 == id3 != id4 == id5 != id6
assert id5[:-2] == id6[:-2]
def test_variedExchangesConstantProfit(self):
dealUUIDGenerator = DealUUIDGenerator()
id1 = dealUUIDGenerator.getUUID(timestamp=1, volBTC=1, nodesStr="bitstamp,coinbasepro", profitPerc=0.5)
id2 = dealUUIDGenerator.getUUID(timestamp=2, volBTC=1, nodesStr="coinbasepro-BTC,coinbasepro-EUR,kraken-EUR,kraken-BTC,coinbasepro-BTC", profitPerc=0.5)
id3 = dealUUIDGenerator.getUUID(timestamp=7, volBTC=1, nodesStr="coinbasepro-BTC,coinbasepro-EUR,kraken-EUR,kraken-BTC,coinbasepro-BTC", profitPerc=0.5)
id4 = dealUUIDGenerator.getUUID(timestamp=12.1, volBTC=1, nodesStr="bitstamp,coinbasepro", profitPerc=0.5)
id5 = dealUUIDGenerator.getUUID(timestamp=12.2, volBTC=1, nodesStr="coinbasepro-BTC,coinbasepro-EUR,kraken-EUR,kraken-BTC,coinbasepro-BTC", profitPerc=0.51)
assert id1 != id2 == id3 != id4 != id5
assert id4[:-2] != id5[:-2]
|
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes
import gc
class RSA_key_gen():
def __init__(self):
self.person = input('What is your name? ')
self.save_pass = input("Please enter one-time pass for saving credentials. SAVE IT. This won't be restored. ")
def generate_pem(self):
print('Generating your private key...')
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=4048,
backend=default_backend())
chosen_pass = self.save_pass
# serialize the key for saving
pem = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.BestAvailableEncryption(chosen_pass.encode('utf-8'))
)
# save key
print('Saving to pem file...')
with open(f'{self.person}_key.pem','w') as f:
f.write(pem.decode("utf-8"))
print('Done!')
print('Generating public keys...')
public_key = private_key.public_key()
pubkey = public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
print(f'You public key is: \n {pubkey.decode("utf-8")}')
print('Saving the public key to file...')
with open(f'pubkey.pem','w') as f:
f.write(pubkey.decode('utf-8'))
print('Public key saved as well!')
del pem
gc.collect()
if __name__ == '__main__':
keygen = RSA_key_gen()
keygen.generate_pem() |
from . import deploy
|
import time
root = 'own/'
buffer = 'buffer.txt'
memory = 'memory.txt'
# python own/test.py | ./pokemon-showdown simulate-battle > own/buffer.txt
def empty_files():
fmemory = open(root + buffer, mode='w')
fmemory.close()
fbuffer = open(root + memory, mode='w')
fbuffer.close()
def read_last_showdown_message():
fbuffer = open(root + buffer, mode='r+')
fbuffer.seek(0)
output = fbuffer.read()
fbuffer.close()
return output
def send_message_to_showdown(message):
# write to stdout (which is piped directly into stdin of pokemon-showdown)
print(message, end='', flush=True)
def record_message_to_memory(message):
fmemory = open(root + memory, mode='a')
fmemory.write(message)
fmemory.close()
# empty files
empty_files()
inputs = [
'>start {"formatid":"gen7randombattle"}',
'>player p1 {"name":"Scott"}',
'>player p2 {"name":"Lars"}'
]
for line in inputs:
#time.sleep(0.5)
# send to showdown
send_message_to_showdown(line + '\n')
record_message_to_memory(line + '\n')
# receive from showdown
time.sleep(0.5)
message = read_last_showdown_message()
record_message_to_memory(message + '\n')
|
# -*- coding: utf-8 -*-
"""Forms to process attributes and sharing."""
from django import forms
from django.contrib.auth import get_user_model
from django.utils.translation import ugettext_lazy as _
from ontask import is_legal_name
from ontask.models import Condition
CHAR_FIELD_SIZE = 1024
class AttributeItemForm(forms.Form):
"""Form to get a key/value pair as attribute."""
key = forms.CharField(
max_length=CHAR_FIELD_SIZE,
strip=True,
required=True,
label=_('Name'))
# Field for the value
attr_value = forms.CharField(max_length=CHAR_FIELD_SIZE, label='Value')
def __init__(self, *args, **kwargs):
"""Set keys and values."""
self.keys = kwargs.pop('keys')
self.workflow = kwargs.pop('workflow', None)
key = kwargs.pop('key', '')
att_value = kwargs.pop('value', '')
super().__init__(*args, **kwargs)
self.fields['key'].initial = key
self.fields['attr_value'].initial = att_value
def clean(self):
"""Check that the name is correct and is not duplicated."""
form_data = super().clean()
attr_name = form_data['key']
# Name is legal
msg = is_legal_name(attr_name)
if msg:
self.add_error('key', msg)
return form_data
if attr_name in self.keys:
self.add_error(
'key',
_('Name has to be different from all existing ones.'))
return form_data
# Enforce the property that Attribute names, column names and
# condition names cannot overlap.
if attr_name in self.workflow.get_column_names():
self.add_error(
'key',
_('There is a column with this name. Please change.'),
)
return form_data
# Check if there is a condition with that name
if (
Condition.objects.filter(
action__workflow=self.workflow,
name=attr_name,
).exists()
):
self.add_error(
'key',
_('There is a condition already with this name.'),
)
return form_data
return form_data
class SharedForm(forms.Form):
"""Form to ask for a user email to add to those sharing the workflow.
The form uses two parameters:
:param user: The user making the request (to detect self-sharing)
:param workflow: The workflow to share (to detect users already in the
list)
"""
user_email = forms.CharField(
max_length=CHAR_FIELD_SIZE,
strip=True,
label=_('User email'))
def __init__(self, *args, **kwargs):
"""Set the request user, workflow."""
self.request_user = kwargs.pop('user', None)
self.workflow = kwargs.pop('workflow')
self.user_obj = None
super().__init__(*args, **kwargs)
def clean(self):
"""Check that the request has the correct user."""
form_data = super().clean()
self.user_obj = get_user_model().objects.filter(
email__iexact=form_data['user_email'],
).first()
if not self.user_obj:
self.add_error('user_email', _('User not found'))
return form_data
if self.user_obj == self.request_user:
self.add_error(
'user_email',
_('You do not need to add yourself to the share list'))
if self.user_obj in self.workflow.shared.all():
self.add_error('user_email', _('User already in the list'))
return form_data
|
from django.shortcuts import render, redirect, get_object_or_404
from django.urls import reverse_lazy
from django.views.generic import ListView, DetailView
from django.views.generic.edit import CreateView, UpdateView, DeleteView
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required
from .models import Post
from .forms import PostForm
# Create your views here.
class PostListView(ListView):
model = Post
paginate_by = 6
class PostDetailView(DetailView):
model = Post
@method_decorator(login_required, name='dispatch')
class PostCreateView(CreateView):
form_class = PostForm
model = Post
def form_valid(self, form):
post = form.save(commit=False)
post.created_by = self.request.user
post.save()
return redirect('post_detail', pk=post.pk)
@method_decorator(login_required, name='dispatch')
class PostUpdateView(UpdateView):
form_class = PostForm
model = Post
template_name = 'lost/post_form_update.html'
def get_queryset(self):
queryset = super().get_queryset()
return queryset.filter(created_by=self.request.user)
@method_decorator(login_required, name='dispatch')
class PostDeleteView(DeleteView):
model = Post
success_url = reverse_lazy('posts')
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#__author__ = 'ifk'
#Refer http://www.wooyun.org/bugs/wooyun-2010-043380
import urlparse
def assign(service, arg):
if service == "fsmcms":
return True, arg
def audit(arg):
payload = '/setup/index.jsp'
code, head, res, errcode, _ = curl.curl2(arg+payload)
if code == 200 and '</font><input type="text" name="SetUpPath"' in res :
security_hole('FSMCMS网站重装漏洞 '+ arg + payload)
if __name__ == '__main__':
from dummy import *
audit(assign('fsmcms', 'http://www.wuda.gov.cn/')[1])
|
#!/usr/bin/env python
"""
nxosm was written to extract and build a road network using OSM data;
to build adjacency matrix with geolocation information for each node.
Citation Format:
Legara, E.F. (2014) nxosm source code (Version 2.0) [source code].
http://www.erikalegara.net
"""
__author__ = "Erika Fille Legara"
__date__ = "22 January 2014"
__programname__ = "nxosm.py"
__codeversion__ = "2.0"
__status__ = "Complete"
__datasource__ = "http://labs.geofabrik.de/haiyan/"
from itertools import tee, izip
from osmread import parse_file, Way, Node #https://github.com/dezhin/osmread
# import shapefile
import networkx as nx
global highway_types
'''
For more highway types, visit http://wiki.openstreetmap.org/wiki/Key:highway
'''
highway_types = ['secondary', 'secondary_link', 'primary', 'primary_link',\
'tertiary', 'tertiary_link', 'motorway','motorway_link','trunk','trunk_link',\
'residential','road','track','Track']
def load_osm_pbf():
return parse_file('latest.osm.pbf')
def load_osm(path):
return parse_file(path)
# def load_intersection_nodes_file():
# '''
# The intersection file can be generated using QGIS.
# '''
# #shp = shapefile.Reader("small_set_intersection.shp")
# shp = shapefile.Reader("For HaiyanPH Paper.shp")
# shp_iter = shp.iterRecords()
# return shp_iter
# def load_road_shapefile():
# shp = shapefile.Reader("latest.shp/roads")
# fields = shp.fields
# return shp, fields
def pairwise(nodes):
''' From a list of nodes = [1,2,3,4,5],
produce: (1,2), (2,3), (3,4), (4,5)'''
a, b = tee(nodes)
next(b, None)
return izip(a,b)
def build_road_network(pbf):
G = nx.Graph()
node_locations = {}
for entity in pbf:
if isinstance(entity, Way) and 'highway' in entity.tags:
if entity.tags['highway'] in highway_types:
nodes = list(entity.nodes)
edges = pairwise(nodes)
edges = [e for e in edges]
G.add_edges_from(edges)
for e in edges:
G.edge[e[0]][e[1]]['tipo'] = entity.tags['highway']
elif isinstance(entity,Node):
node_locations[entity.id] = (entity.lon, entity.lat)
return G, node_locations
def build_road_network_2(fil):
G = nx.Graph()
ndes = {}
segments = []
node_locations = {}
for entity in fil:
if isinstance (entity, Way) and 'highway' in entity.tags:
#print "highway", entity.tags['highway']
if entity.tags['highway'] in highway_types:
nodes = list(entity.nodes)
for n in nodes:
# Set flag that node n does belong to the road network
ndes[n]['way_part'] = True
edges = pairwise(nodes)
edges = [e for e in edges]
G.add_edges_from(edges)
for e in edges:
segment = {}
segment['node_1'] = e[0]
segment['node_2'] = e[1]
segment['highway_type'] = entity.tags['highway']
segment['status'] = 'ok'
G.edge[e[0]][e[1]]['highway_type'] = entity.tags['highway']
G.edge[e[0]][e[1]]['status'] = 'ok'
# initialize road segment status tag such that we don't get a KeyError
if 'status' in entity.tags:
G.edge[e[0]][e[1]]['status'] = entity.tags['status']
segment['status'] = entity.tags['status']
segments.append(segment)
elif isinstance(entity, Node):
#print "Node!"
#print entity.id. entity.lat, entity.lon
node_locations[entity.id] = (entity.lat, entity.lon)
#print node_locations[entity.id]
nde = {}
nde['nodeid'] = entity.id
#print nde['nodeid']
nde['latitude'] = entity.lat
#print nde['latitude']
nde['longitude'] = entity.lon
#print nde['longitude']
# Default node isn't a barrier so None. set otherwise
nde['barrier'] = 'None'
if 'barrier' in entity.tags:
nde['barrier'] = entity.tags['barrier']
#print nde['barrier']
#print nde
# Set flag that this node does not belong to the road network.
# Since in an OSM file nodes are listed ahead of ways, the way-handling code
# above will set to true.
nde['way_part'] = False
ndes[entity.id] = nde # check for bug later
# Before returning, remove all nodes in ndes which are not in G.
# nodes_in_graph = [ndes[entry] for entry in G.nodes()]
#return G, nodes_in_graph, node_locations, segments
return G, ndes.values(), node_locations, segments
def get_nodes_locations(G):
pbf = load_osm_pbf()
nodes = G.nodes()
node_attrib = {}
for entity in pbf:
if isinstance(entity, Node) and entity.id in nodes:
node_attrib[entity.id] = (entity.lon, entity.lat)
return node_attrib
def reduce_nodes(G):
'''
The reduce_nodes() function reduces the bigger and more complete
graph G by identifying all nodes with degree 2 and removing them
in the graph, and connecting their adjacent nodes to one another.
'''
g = G.copy()
degree2 = [] #list of all nodes with degree 2
for n in G.nodes():
if G.degree(n) == 2:
degree2.append(n)
for v in degree2:
edges = g.edges(v)
try:
first_edge = edges[0]
last_edge = edges[-1]
type1 = G[first_edge[1]][first_edge[0]]['tipo']
type2 = G[last_edge[0]][last_edge[1]]['tipo']
if type1 == type2:
g.add_edge(first_edge[1],last_edge[1], tipo = type1)
g.remove_edge(first_edge[0], first_edge[1])
g.remove_edge(last_edge[0], last_edge[1])
except:
pass
for v in degree2:
if g.degree(v) == 0:
g.remove_node(v)
return g
if __name__ == "__main__":
pbf = load_osm_pbf()
G, node_locations = build_road_network(pbf)
#shp = load_intersection_nodes_file()
#node_attrib = get_nodes_locations(G)
latlong_ids = {}
for n in G.nodes():
lat, lng = node_locations[n][1], node_locations[n][0]
G.node[n]['latitude'] = node_locations[n][1]
G.node[n]['longitude'] = node_locations[n][0]
latlong_ids[(lat,lng)] = n
'''
The reduce_nodes() function reduces the bigger and more complete
graph G by identifying all nodes with degree 2 and removing them
in the graph, and connecting their adjacent nodes.
'''
#small_g = reduce_nodes(G)
'''
Here, we are writing out the network data structures to .gexf format.
'''
#nx.write_gexf(G,'road_network_all_nodes.gexf')
#nx.write_gexf(small_g,'road_network_reduced.gexf')
#np.save("all_nodes.npy",G.nodes())
|
# Generated by Django 2.1.9 on 2019-07-23 08:14
import django.contrib.postgres.fields.jsonb
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("terra_layer", "0032_auto_20190718_1742")]
operations = [
migrations.AddField(
model_name="layergroup",
name="settings",
field=django.contrib.postgres.fields.jsonb.JSONField(default=dict),
)
]
|
# https://leetcode.com/problems/pascals-triangle-ii/
# Related Topics: Array
# Difficulty: Easy
# Initial thoughts:
# The naive solution is to handle this problem like with did Pascal's Triangle where we create a two dimensional array
# with the values of Pascal's triangle up to the row that we need to return and then return the last row.
# Optimization:
# Since we only need the last row, we can have a one dimensional array that initially holds the first row of
# Pascal's triangle and build uppon it by changing the values in place. This way we will decrease the space complexity
# by a factor of n.
# Time complexity: O(n^2) where n === index of the required row
# Space complexity: O(n) where n === index of the required row
from typing import List
class Solution:
def getRow(self, rowIndex: int) -> List[int]:
result = [1]
for i in range(1, rowIndex+1):
prev = result[0]
for j in range(1, len(result)):
curr = result[j]
result[j] = curr+prev
prev = curr
result.append(1)
return result
|
import unittest
import euler
class TestGCD(unittest.TestCase):
def test_gcd(self):
self.assertEqual(euler.gcd(3, 5), 1)
self.assertEqual(euler.gcd(5, 13), 1)
self.assertEqual(euler.gcd(2, 10), 2)
self.assertEqual(euler.gcd(5, 10), 5)
self.assertEqual(euler.gcd(10, 25), 5)
|
###########################################################################
#
# Copyright 2018 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://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 re
from starthinker.util.project import project
from starthinker.util.sheets import sheets_read, sheets_tab_copy
from starthinker.util.bigquery import get_schema, query_to_view
from starthinker.util.csv import rows_to_type, rows_to_csv
TEMPLATE_SHEET = 'https://docs.google.com/spreadsheets/d/1_faknNlaPlltLwsleMyQH0Gis5ixJODLGJHLovY3Ycg/edit?usp=sharing'
TEMPLATE_TAB = 'Mapping'
RE_SQLINJECT = re.compile(r'[^a-z0-9_\-, ]+', re.UNICODE|re.IGNORECASE)
@project.from_parameters
def mapping():
if project.verbose: print('MAPPING')
# create the sheet from template if it does not exist
sheets_tab_copy(project.task['auth'], TEMPLATE_SHEET, TEMPLATE_TAB, project.task['sheet'], project.task['tab'])
# move if specified
dimensions = {}
defaults = {}
rows = sheets_read(project.task['auth'], project.task['sheet'], project.task['tab'], 'A1:D')
# if rows don't exist, query is still created without mapping ( allows blank maps )
if rows:
# sanitize mapping
# 0 = Dimension, 1 = Tag, 2 = Column, 3 = Keyword
for row in rows[1:]:
if project.verbose: print('ROW: ', row)
# sanitize row
#row = map(lambda c: RE_SQLINJECT.sub('', c.strip()), row)
row = [RE_SQLINJECT.sub('', r.strip()) for r in row]
if len(row) == 2: # default
defaults.setdefault(row[0], row[1])
else: # tag
dimensions.setdefault(row[0], {}) # dimension
dimensions[row[0]].setdefault(row[1], {})
dimensions[row[0]].setdefault(row[1], {}) # tag
dimensions[row[0]][row[1]].setdefault(row[2], []) # column
dimensions[row[0]][row[1]][row[2]].extend([k.strip() for k in row[3].split(',') if k]) # keywords
# construct query
query = 'SELECT\n *,\n'
for dimension, tags in dimensions.items():
query += ' CASE\n'
for tag, columns in tags.items():
query += ' WHEN '
for column, keywords in columns.items():
for count, keyword in enumerate(keywords):
if count != 0: query += 'OR '
query += '%s CONTAINS "%s" ' % (column, keyword)
query += 'THEN "%s"\n' % tag
query += ' ELSE "%s"\n END AS %s,\n' % (defaults.get(dimension, ''), dimension)
query += 'FROM [%s.%s]' % (project.task['in']['dataset'], project.task['in']['table'])
if project.verbose: print('QUERY: ', query)
# write to view
query_to_view(
project.task['out']['auth'],
project.id,
project.task['out']['dataset'],
project.task['out']['view'],
query,
replace=True
)
if __name__ == "__main__":
mapping()
|
import typing
from ParadoxTrading.Fetch.ChineseFutures.FetchBase import FetchBase
from ParadoxTrading.Utils import DataStruct
class FetchInstrumentTickData(FetchBase):
def __init__(
self, _mongo_host='localhost', _psql_host='localhost',
_psql_user='', _psql_password='', _cache_path='cache'
):
super().__init__(
_mongo_host, _psql_host, _psql_user, _psql_password, _cache_path
)
self.psql_dbname: str = 'ChineseFuturesInstrumentTickData'
self.market_key: str = 'ChineseFuturesInstrumentTickData_{}_{}'
self.columns = [
'tradingday',
'lastprice', 'highestprice', 'lowestprice',
'volume', 'turnover', 'openinterest',
'upperlimitprice', 'lowerlimitprice',
'askprice', 'askvolume', 'bidprice', 'bidvolume',
'happentime',
]
|
"""
Syntax
^^^^^^
lambda arguments : expression
"""
fx = lambda: print("This is lambda")
fx()
fx = lambda arg: print(f'This is {arg}')
fx("lambda")
# Variable Arguments (Positional)
fx = lambda *arg: print(f'This is {arg[0]}')
fx("lambda1", "lambda2")
# Variable Arguments (Key Value pairs)
fx = lambda **arg: print(f'This is {arg["key2"]}')
fx(key1="lambda1", key2="lambda2")
# Implicit return
fx = lambda k: k ** 2
print(fx(10)) # 100
# Implicit return dict
fx = lambda k, v : {k:v}
d1 = fx("key", "value")
print(d1)
print(type(d1)) # <class 'dict'>
# Implicit return set
fx = lambda k, v : {k, v}
d1 = fx("key", "value")
print(d1)
print(type(d1)) # <class 'set'>
print(type(fx)) # <class 'function'>
# Both do same thing - One is a pythonic way !! - https://realpython.com/python-lambda/#alternatives-to-lambdas
print(list(map(lambda x: x.capitalize(), ['cat', 'dog', 'cow'])))
print([x.capitalize() for x in ['cat', 'dog', 'cow']])
# Examples of Default arguments
fx = lambda v, k="Key" : {k: v}
print(fx(10)) # {'Key': 10}
print(fx(10, "myKey")) # {'myKey': 10}
# Variable list of arguments
fx = lambda *args : max(args)
print(fx(1,2,3,4)) |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import json
import hmac
import requests
from time import time
from hashlib import sha256
from .exceptions import AuthorizedError
class _TuyaApi:
"""
Private class for API requests
"""
def __init__(self, client_id: str, secret_key: str, region_key: str):
self._client_id = client_id
self._secret_key = secret_key
self._region_key = region_key
self._base_url = f"https://openapi.tuya{self._region_key}.com/v1.0"
self.__sign_method: str = "HMAC-SHA256"
self.__access_token = self.__token()
@staticmethod
def __generate_signature(msg: str, key: str) -> str:
"""
Generates the signature required to send the request.
:param msg: hmac.new(msg)
:param key: hmac.new(key)
:return: hexdigest string
"""
output = (
hmac.new(
msg=bytes(msg, "latin-1"), key=bytes(key, "latin-1"), digestmod=sha256
)
.hexdigest()
.upper()
)
return output
@staticmethod
def __get_timestamp() -> str:
"""
Return the current timestamp * 1000.
:return: timestamp * 1000
"""
timestamp = str(int(time() * 1000))
return timestamp
def __request_template(self) -> dict:
"""
Default request type.
:return: default headers
"""
t = self.__get_timestamp()
sign = self.__generate_signature(
self._client_id + self.__access_token + t, self._secret_key
)
default_headers = {
"client_id": self._client_id,
"access_token": self.__access_token,
"sign_method": self.__sign_method,
"sign": sign,
"t": t,
}
return default_headers
def __token(self) -> str:
"""
Get the access token.
:return: access token
"""
t = self.__get_timestamp()
uri = self._base_url + "/token?grant_type=1"
sign = self.__generate_signature(self._client_id + t, self._secret_key)
headers_pattern = {
"client_id": self._client_id,
"secret": self._secret_key,
"sign_method": self.__sign_method,
"sign": sign,
"t": t,
}
try:
response = requests.get(uri, headers=headers_pattern).json()
except Exception:
raise Exception
else:
if not response["success"]:
raise AuthorizedError(
target=response["code"], msg=str(response["msg"]).capitalize()
)
try:
token = response["result"]["access_token"]
except KeyError:
raise KeyError("Failed to get access_token")
return token
def _get(self, postfix: str) -> dict:
"""
Performs a GET request at the specified address.
:param postfix: request address. Example: /device/{device_id}/commands
:return: response dict
"""
uri = self._base_url + postfix
headers = self.__request_template()
try:
response = requests.get(uri, headers=headers).json()
except Exception:
raise Exception
return response
def _post(self, postfix: str, body=None) -> dict:
"""
Performs a POST request at specified address.
:param postfix: request address. Example: /device/{device_id}/commands
:param body: request body
:return: response dict
"""
if body is None:
body = {}
body = json.dumps(body)
uri = self._base_url + postfix
headers = self.__request_template()
try:
response = requests.post(uri, headers=headers, data=body).json()
except Exception:
raise Exception
return response
|
from django.urls import path
from . import views
from django.contrib.auth import views as auth_views
from django.conf.urls import url
app_name = 'accounts'
urlpatterns = [
path('signup/', views.signup_view, name='signup'),
path('login/', views.login_view, name='login'),
path('logout/', views.logout_view, name='logout'),
path('ngo/register/',views.ngo_register,name='ngo_register'),
path('accountcreate/',views.accountcreate,name='accountcreate'),
path('ngodetail/',views.ngodetail,name='ngodetail'),
path('create/', views.edit_view_add, name='edit_view_add'),
path('delete/',views.delete_view, name='delete_view'),
path('edit/',views.edit_view, name='edit_view'),
path('donate/',views.donator_view,name='donator'),
path('donate/<phone>/',views.donation_confirm,name='don_confirm'),
path('change-password/', views.MyPasswordChangeView.as_view(), name='reset'),
path('ngodetail/donators/', views.donators, name='donators'),
path('donater/signup/',views.d_signup,name='d_signup'),
path('donators/', views.donators, name='donators'),
path('contact/',views.contactus, name='contact')
]
|
start = [8,13,1,0,18,9]
last_said = None
history = {}
def say(num, turn_no):
print(f'turn {i}\tsay {num}')
for i in range(30000000):
if i < len(start):
num = start[i]
else:
# print(f'turn {i} last said {last_said} {history}')
if last_said in history:
# print('in')
num = i - history[last_said] - 1
else:
num = 0
# print(history)
if last_said is not None:
history[last_said] = i - 1
# say(num, i)
if i % 1000000 == 0: print(i, num)
last_said = num
print(i, num) |
import torch
from torch import Tensor
from tree_expectations import N
from tree_expectations.utils import device
def laplacian(A: 'Tensor[N, N]', rho: 'Tensor[N]') -> 'Tensor[N, N]':
"""
Compute the root-weighted Laplacian.
Function has a runtime of O(N^2).
"""
L = -A + torch.diag_embed(A.sum(dim=0)).to(device)
L[0] = rho
return L
def lap(w: 'Tensor[N, N]') -> 'Tensor[N, N]':
"""
Compute the root-weighted Laplacian.
Function has a runtime of O(N^2).
"""
rho = torch.diag(w)
A = w * (torch.tensor(1).double().to(device) - torch.eye(w.size(0)).double().to(device))
return laplacian(A, rho)
def dlap(k, l):
"""
Index over sparsity in the Jacobian of the Laplacian
Given (k,l), return (i,j) such that for a
dL[i,j] / ∂A[k,l] ≠ 0
Done in O(1), see Proposition of paper (see README)
"""
if k == l:
return [(0, k, 1.)]
out = []
if l != 0:
out.append((l, l, 1.))
if k != 0:
out.append((k, l, -1.))
return out
def adj(A: 'Tensor[N, N]') -> 'Tensor[N, N]':
"""
Compute the adjugate of a matrix A.
The adjugate can be used for calculating the derivative of a determinants.
Function has a runtime of O(N^3).
"""
Ad = torch.slogdet(A)
Ad = Ad[0] * torch.exp(Ad[1])
return Ad * torch.inverse(A).t()
def matrix_tree_theorem(w: 'Tensor[N, N]', use_log: bool = False) -> 'Tensor[1]':
"""
Compute the sum over all spanning trees in W using the Matrix--Tree Theorem.
Function has a runtime of O(N^3).
This relates to Section 2, Proposition 1 of paper (see README)
"""
r = torch.diag(w)
A = w * (torch.tensor(1).double().to(device) - torch.eye(w.size(0)).double().to(device))
sign, logZ = torch.slogdet(laplacian(A, r))
return logZ if use_log else sign * torch.exp(logZ)
def _dz_base(w: 'Tensor[N, N]', B: 'Tensor[N, N]' = None):
"""
Evaluate the base of the derivative of the Matrix--Tree Theorem
using a possibly cached transpoed inverse Laplacian matrix.
To get the full derivative, we must multiply by Z.
To get mu, we must multiply by w.
This function runs in O(N^2) if B is provided and O(N^3) otherwise.
"""
n = w.size(0)
if B is None:
B = torch.inverse(lap(w)).t()
base = torch.zeros((n, n)).double().requires_grad_(True)
for i in range(n):
for j in range(n):
for i_, j_, dL in dlap(i, j):
base[i, j] += B[i_, j_] * dL
return base
|
# Generated by Django 3.1.5 on 2021-04-21 07:38
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
('posts', '0001_initial'),
('groups', '0001_initial'),
('profiles', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='group',
name='created_by',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='group_creator', to='profiles.profile'),
),
migrations.AddField(
model_name='group',
name='members',
field=models.ManyToManyField(blank=True, related_name='members', to='profiles.Profile'),
),
migrations.AddField(
model_name='group',
name='posts',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='group_posts', to='posts.post'),
),
]
|
import torch
import torch.nn as nn
from block import FC_block
sp = torch.zeros((1, 1))
counter = 0
class SNN(nn.Module):
def __init__(self, hyperparams, hidden_size, layers=3, sbp=False, bp_mark=None):
super(SNN, self).__init__()
self.hyperparams = hyperparams
self.hidden_size = hidden_size
self.layers = nn.ModuleList()
self.layers_size = [self.hyperparams[1]] + [self.hidden_size] * (layers - 2) + [self.hyperparams[2], None]
print('layers size:', self.layers_size[:-1])
self.len = len(self.layers_size) - 2
self.error = None
for i in range(self.len):
self.layers.append(FC_block(self.hyperparams, self.layers_size[i], self.layers_size[i + 1], self.layers_size[i + 2]))
def hook_fc_backward(module, grad_input, grad_output):
global sp, counter
# grad_input:[grad_b, grad_x, grad_w]
grad_b = grad_input[0]
grad_w = grad_input[2]
if module.last_layer:
# calculate inductor 'sp' from gradients of the last layer
counter += 1
sp = torch.diag(torch.sum(grad_w.abs(), 1)) / (grad_w.shape[0] * grad_w.shape[1]) * 0.01
result = (torch.zeros(grad_b.shape).cuda(), grad_input[1], grad_input[2])
else:
# use 'sp' to calculate new grad_w
grad_b_new = torch.zeros(grad_b.shape).cuda()
tp = torch.mm(torch.mm(torch.mm(sp, module.rand), module.error.t()), module.input).t()
hebb_use = torch.mm(module.hebb_delta, sp) * 1e-2
grad_w_new = tp + hebb_use
result = (grad_b_new, grad_input[1], grad_w_new)
if bp_mark and (counter == bp_mark):
result = (torch.zeros(grad_b.shape).cuda(), grad_input[1], grad_input[2])
counter = 0
return result
if sbp:
for name, module in self.layers[i].named_children():
if name is 'fc':
module.register_backward_hook(hook_fc_backward)
def forward(self, input, labels=None):
for step in range(self.hyperparams[4]):
if self.hyperparams[5] == 'MNIST':
x = input > torch.rand(input.size()).cuda()
elif self.hyperparams[5] == 'NETTalk':
x = input.cuda()
elif self.hyperparams[5] == 'DVSGesture':
x = input[:, 0 + step * 5, :]
x = x.float()
x = x.view(self.hyperparams[0], -1)
for i in range(self.len):
x = self.layers[i](x)
if i != 0:
self.layers[i].h_last = self.layers[i - 1].h_now
outputs = self.layers[-1].sumspike / self.hyperparams[4]
if labels is not None:
error = labels - outputs
for i in range(self.len):
self.layers[i].fc.error = error
if i != self.len - 1:
self.layers[i].fc.hebb_delta = self.layers[i + 1].hebb_last[-1] + self.layers[i + 1].hebb_last[-2] - self.layers[i + 1].hebb_last[0] - self.layers[i + 1].hebb_last[1]
potential = 0
for i in range(self.len - 1):
l_potential = torch.mm(self.layers[i + 1].h_now, torch.mm(self.layers[i].fc.weight.data, self.layers[i].h_now.t())).mean() / float(self.layers[i].input_size * self.layers[i].output_size) + torch.mm(self.layers[i + 1].h_now, self.layers[i + 1].h_now.t()).mean() / float(self.layers[i].output_size * self.layers[i].output_size)
potential = potential + l_potential.abs()
l_potential = torch.mm(x, torch.mm(self.layers[-1].fc.weight.data, self.layers[-1].h_now.t())).mean() / float(self.layers[-1].input_size * self.layers[-1].output_size) + torch.mm(x, x.t()).mean() / float(self.layers[-1].output_size * self.layers[-1].output_size)
potential = potential + l_potential.abs()
return outputs, potential |
# Copyright 2017 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.
"""Module to handle interactions with Windows Firmware Passwords."""
from cauliflowervest.server import permissions
from cauliflowervest.server.handlers import firmware_handler
from cauliflowervest.server.models import firmware as firmware_model
class WindowsFirmwarePassword(firmware_handler.FirmwarePasswordHandler):
"""Handler for /windows_firmware URL."""
AUDIT_LOG_MODEL = firmware_model.WindowsFirmwarePasswordAccessLog
SECRET_MODEL = firmware_model.WindowsFirmwarePassword
PERMISSION_TYPE = permissions.TYPE_WINDOWS_FIRMWARE
|
"""
*********************************************************
* *
* Project Name: Recursive Fibonacci Sequence *
* Author: github.com/kirigaine *
* Description: A simple program to put in how many *
* numbers of the Fibonacci Sequence you would like. *
* Requirements: Python Standard Library (re) *
* *
*********************************************************
"""
import re
def main():
while True:
# Prompt user, exit program if "-1"
x = userPrompt()
if x == -1:
break
print("------------------------------------------------------------")
print(str(fibonacci(x)))
print("------------------------------------------------------------\n")
def userPrompt():
# Prompt user for nth number to print up to
temp_nth = ""
regex_passed = None
# Accept only integers and negative one
while not regex_passed:
temp_nth = input("How many digits of the Fibonacci Sequence would you like (-1 to quit): ")
regex_passed = re.search("^(([0-9]*)|(-1))$", temp_nth)
if not regex_passed:
print("Invalid integer. Please try again entering a positive integer (or -1 to quit).\n")
return int(temp_nth)
def fibonacci(x):
# fibonacci(x) == fibonacci(x-1) + fibonacci(x-2)
# ...
# fibonacci(4) = fibonacci(3) + fibonacci(2)
# fibonacci(3) = fibonacci(2) + fibonacci(1)
# fibonacci(2) = 1
# fibonacci(1) = 0
if x is not None:
if x==0:
# If you request none, you get none!
return None
elif x==1:
return 0
elif x==2:
return 1
else:
# print(f"{x-1} {x-2}")
return(fibonacci(x-1) + fibonacci(x-2))
main() |
# Copyright 2020 Skillfactory 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
#
# https://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 argparse import Namespace
TEST_DATA_DIRECTORY = './tests/test_data/'
DEFAULT_CONFIG = Namespace(attention_dropout=0.1,
batch_size=64,
bidirectional_encoder=False,
bos_index=1,
checkpoint_path='./data/checkpoints/checkpoint',
decoder_num_layers=2,
directory='./data/',
dropout=0.25,
embedding_dim=128,
encoder_num_layers=2,
eos_index=2,
epochs=3,
gpu=1,
learning_rate=0.001,
load_data=False,
max_length=32,
max_norm=3.0,
model_dim=256,
n_batch_accumulate=1,
pad_index=0,
project_name='NMT',
seed=42,
train_n_pairs=5000000,
train_tokenizers=False,
use_attention=False,
valid_n_pairs=25000,
verbose=False,
vocab_size=30000,
weight_decay=0.0,
weight_tying=False)
|
import lionchief
import time
import logging
import sys
logging.basicConfig()
logging.getLogger('bluetooth').setLevel(logging.DEBUG)
# Replace this mac address with the one
# belonging to your train
#chief = lionchief.LionChief("44:A6:E5:48:7F:73") #steam engine
chief = lionchief.LionChief("44:A6:E5:35:54:88") #GE
# speed = 0
class LionApi(object):
# speed = 0
def __init__(self):
self.online=True
self._speed=0
self._reverse = False
def start(self):
try:
chief.connect()
except Exception as e:
print(e)
sys.exit(0)
def go(self,newSpeed=0):
# global speed
chief.ramp(self._speed, newSpeed)
self._speed = newSpeed
def horn(self):
chief.set_horn(True)
time.sleep(.5)
chief.set_horn(False)
#trying to emulate a twil horn sound for a steam engine. Can't find a way to make it sound even yet
def hornTwil(self):
chief.set_horn_pitch(0)
chief.set_horn(True)
time.sleep(.3)
chief.set_horn_pitch(4)
time.sleep(2)
chief.set_horn(False)
def reverse(self):
chief.set_reverse(True)
print('going in reverse')
self._reverse = True
self._speed = 0
def forward(self):
chief.set_reverse(False)
self._reverse = False
self._speed = 0 |
"""
set and catch alarm timeout signals in Python; time.sleep doesn't play
well with alarm (or signal in general in my Linux PC), so we call
signal.pause here to do nothing until a signal is received;
"""
import sys, signal, time
def now(): return time.asctime()
def onSignal(signum, stackframe): # python signal handler
print('Got alarm', signum, 'at', now()) # most handlers stay in effect
while True:
print('Setting at', now())
signal.signal(signal.SIGALRM, onSignal) # install signal handler
signal.alarm(5) # do signal in 5 seconds
signal.pause() # wait for signals; pause() is a built-in function
|
#!/usr/bin/env python
#
# Copyright 2007 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""Tests for devappserver2.admin.mail_request_handler."""
import email.message
import unittest
import google
import mox
import webapp2
from google.appengine.tools.devappserver2 import dispatcher
from google.appengine.tools.devappserver2.admin import mail_request_handler
class MailRequestHandlerTest(unittest.TestCase):
def setUp(self):
self.mox = mox.Mox()
def tearDown(self):
self.mox.UnsetStubs()
def test_generate_email(self):
message = mail_request_handler.MailRequestHandler._generate_email(
'to', 'from', 'cc', 'subject', 'body')
self.assertEqual('from', message['From'])
self.assertEqual('to', message['To'])
self.assertEqual('cc', message['Cc'])
self.assertEqual('subject', message['Subject'])
text, html = message.get_payload()
self.assertEqual('text/plain', text.get_content_type())
self.assertEqual('utf-8', text.get_content_charset())
content = text.get_payload()
if text['content-transfer-encoding'] != '7bit':
content = content.decode(text['content-transfer-encoding'])
self.assertEqual('body', content)
self.assertEqual('text/html', html.get_content_type())
self.assertEqual('utf-8', html.get_content_charset())
content = html.get_payload()
if html['content-transfer-encoding'] != '7bit':
content = content.decode(html['content-transfer-encoding'])
self.assertEqual('body', content)
def test_send_email(self):
response = webapp2.Response()
handler = mail_request_handler.MailRequestHandler(None, response)
message = object()
self.mox.StubOutWithMock(handler, '_send')
self.mox.StubOutWithMock(handler, '_generate_email')
handler._generate_email('to', 'from', 'cc', 'subject', 'body').AndReturn(
message)
handler._send('/_ah/mail/to', message).AndReturn(
dispatcher.ResponseTuple('500 Internal Server Error', [], 'Response'))
self.mox.ReplayAll()
handler._send_email('to', 'from', 'cc', 'subject', 'body')
self.mox.VerifyAll()
self.assertEqual(500, response.status_int)
def test_send(self):
self.mox.StubOutWithMock(mail_request_handler.MailRequestHandler,
'dispatcher')
handler = mail_request_handler.MailRequestHandler(None, None)
handler.dispatcher = self.mox.CreateMock(dispatcher.Dispatcher)
handler.dispatcher.add_request(
method='POST',
relative_url='URL',
headers=[('Content-Type', 'message/rfc822')],
body='mail message',
source_ip='0.1.0.20')
message = self.mox.CreateMock(email.message.Message)
message.as_string().AndReturn('mail message')
self.mox.ReplayAll()
handler._send('URL', message)
self.mox.VerifyAll()
def test_post(self):
request = webapp2.Request.blank('/mail', POST={
'to': 'to', 'from': 'from', 'cc': 'cc', 'subject': 'subject',
'body': 'body'})
response = webapp2.Response()
handler = mail_request_handler.MailRequestHandler(request, response)
self.mox.StubOutWithMock(handler, '_send_email')
handler._send_email('to', 'from', 'cc', 'subject', 'body')
self.mox.ReplayAll()
handler.post()
self.mox.VerifyAll()
if __name__ == '__main__':
unittest.main()
|
from sklearn.metrics import silhouette_samples, silhouette_score
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from matplotlib import ticker
from matplotlib.colors import to_hex
import numpy as np
import pandas as pd
import os
import argparse
from .utils import str2bool,setColorConf
USAGE="""
Desc:
script to draw sample-wise silhouette coeffient plot.
"""
def checkIndexIdenticcal(featureDataFrame,metadataDataFrame):
return np.sum(featureDataFrame.index != metadataDataFrame.index)
def plotSampleWiseSilhouetteScore(featureDataFrame,
metadataDataFrame,
cluster_name,
features_are_row=True,
n_clusters = None,
metric = "euclidean",
order=None,
colors="tab20",
xlim=(-1,1),
y_lower = 10,
interval=15,
figsize = (5,10),**kwargs):
"""
featureDataFrame(Required):,pd.DataFrame
row per feature(taxonomy),col per sample. If setting metric = "precomputed",
then featureDataFrame should be distance dataframe precomputed.
metadataDataFrame(Required): pd.DataFrame
metadata containing group information(make sure the index same with featureDataFrame: feature).
cluster_name(Required):
column name of cluster in the metadataDataFrame.
n_clusters(Required):
order:list
the plot order of each cluster.
metric:str
default = "precomputed".
If metric is a string, it must be one of the options allowed by sklearn.metrics.pairwise.pairwise_distances.
If using "precomputed" as the metric, then the featureDataFrame should be the distance dataframe itself.
Precomputed distance matrices must have 0 along the diagonal.
color:str or list.
color of each cluster.
If passing str, then calling matplotlib inner palette.
If passing list, then using the list color directly.
"""
# average silhouette_score
if features_are_row:
featureDataFrame = featureDataFrame.T.sort_index()
else:
featureDataFrame = featureDataFrame.sort_index()
metadataDataFrame = metadataDataFrame.sort_index()
unIdenticalNum = checkIndexIdenticcal(featureDataFrame,metadataDataFrame)
if unIdenticalNum !=0:
raise IndexError("Exist un-identical index between 2 dataframe.")
X = featureDataFrame.values
if cluster_name not in metadataDataFrame.columns:
raise ValueError(cluster_name + " not exist in metadata.")
cluster_labels = metadataDataFrame.loc[:,cluster_name].values
unique_labels = np.unique(cluster_labels)
if not n_clusters:
n_clusters = len(unique_labels)
if metric =="precomputed":
np.fill_diagonal(X, 0)
silhouette_avg = silhouette_score(X, cluster_labels,metric=metric)
print("For n_clusters =", n_clusters,
"The average silhouette_score is :", silhouette_avg)
# visualization
plt.rc('font', family='Arial')
fig = plt.figure(1, figsize=figsize)
ax = fig.add_subplot(1,1,1)
ax.set_xlim([xlim[0], xlim[1]])
# Compute the silhouette scores for each sample
sample_silhouette_values = silhouette_samples(X, cluster_labels,metric=metric)
y_lower = y_lower
if not order: # if not specified.
order = np.sort(unique_labels)
if not set(order).issubset(set(unique_labels)):
raise ValueError("provided order does not match the exact cluster label.")
# color
# if specified by user(passing a list).
if isinstance(colors,list):
colors_list = colors
## TODO:raise warning if len of list not consistent with ngroups.
# if using matplotlib inner palette
elif isinstance(colors,str):
if colors:
colors_list = setColorConf(colors=colors,ngroups = n_clusters)
else:
colors_list = None
for i,cs in enumerate(order):
# Aggregate the silhouette scores for samples belonging to cluster i, and sort them
ith_cluster_silhouette_values = \
sample_silhouette_values[cluster_labels == cs]
ith_cluster_silhouette_values.sort()
size_cluster_i = ith_cluster_silhouette_values.shape[0]
y_upper = y_lower + size_cluster_i
#color = cm.nipy_spectral(float(i) / n_clusters)
ax.fill_betweenx(np.arange(y_lower, y_upper),
0, # start
ith_cluster_silhouette_values, # end
facecolor=colors_list[i],
edgecolor=colors_list[i],
alpha=0.7,**kwargs)
# Label the silhouette plots with their cluster numbers at the middle
ax.text(-0.05, y_lower + 0.5 * size_cluster_i, str(cs))
# Compute the new y_lower for next plot
y_lower = y_upper + interval
#ax1.set_title("The silhouette plot")
ax.set_title("Silhouette Coefficient",size=15)
#ax.set_xlabel("Silhouette Coefficient",size=15)
#ax.set_ylabel("Cluster",size=15,rotation="horizontal")
# The vertical line for average silhouette score of all the values
#ax.axvline(x=silhouette_avg, color="red", linestyle="--")
ax.set_yticks([]) # Clear the yaxis labels / ticks
#ax.set_xticks([-0., 0, 0.2, 0.4, 0.6, 0.8, 1])
## set spines invisible
ax.spines['left'].set_color(None)
ax.spines['right'].set_color(None)
ax.spines['top'].set_color(None)
ax.spines['bottom'].set_linewidth(1.5)
ax.xaxis.set_minor_locator(ticker.MultipleLocator(0.2))
for i in ax.xaxis.get_ticklines():
i.set_linewidth(1.5)
i.set_markeredgewidth(1.5)
for i in ax.xaxis.get_ticklabels():
i.set_fontsize(13)
#i.set_fontfamily('serif')
#plt.show()
return fig,ax
if __name__ == "__main__":
args = argparse.ArgumentParser(description=USAGE)
args.add_argument('-f','--featureDataFrame')
args.add_argument('-m','--metadataDataFrame')
args.add_argument('-x','--metric')
args.add_argument('-n','--clustername')
args.add_argument('-far','--feature_are_row',default="True",type=str2bool)
args.add_argument('-o','--output',default = './SilhouetteScore.pdf')
args = args.parse_args()
df = args.featureDataFrame
metadata = args.metadataDataFrame
metric = args.metric
far = args.feature_are_row
try:
if ".csv" in df:
df = pd.read_csv(df,index_col=0)
elif ".txt" in df:
df = pd.read_csv(df,index_col=0,sep="\t")
elif ".tsv" in df:
df = pd.read_csv(df,index_col=0,sep="\t")
elif ".xlsx" in df:
df = pd.read_excel(df,index_col=0)
except:
print("Unrecognized format, please check your feature dataframe.")
try:
if ".csv" in metadata:
metadata = pd.read_csv(metadata,index_col=0)
elif ".txt" in metadata:
metadata = pd.read_csv(metadata,index_col=0,sep="\t")
elif ".tsv" in metadata:
metadata = pd.read_csv(metadata,index_col=0,sep="\t")
elif ".xlsx" in metadata:
metadata = pd.read_excel(metadata,index_col=0)
except:
print("Unrecognized format, please check your metadata dataframe.")
cs = args.clustername
fname = args.output
fig = plotSampleWiseSilhouetteScore(df,metadata,cluster_name=cs,metric = metric,features_are_row=far)
plt.savefig(fname)
|
from keras.models import Sequential
from keras.layers import Dense, LSTM
import keras.backend as K
import numpy as np
import tensorflow as tf
a = [1, 0, 0]
b = [0, 1, 0]
c = [0, 0, 1]
seq = [a, b, c, b, a]
x = seq[:-1]
y = seq[1:]
window_size = 1
x = np.array(x).reshape((len(x), window_size, 3))
y = np.array(y)
num_fit_loop_iters = 10
eps = 1
bs = 1
lstm_input_layer_num_units = 20
input_tensor_shape = (1, 3)
dense_layer_num_units = 3
act_func = "softmax"
loss_metric = "mean_squared_error"
opt = "adam"
array_2_pred_1 = np.array([[a], [b]])
array_2_pred_2 = np.array([[b], [c]])
array_2_pred_3 = np.array([[c], [b]])
# training_method_desc_info = f"""The network is being trained via the combination of the .fit(.)
# method and a for loop. The for loop performs {}"""
# def run_with_batch_size(batch_size=bs, epochs=eps, num_fit_loop_iters=num_fit_iters):
# def run_with_batch_size(batch_size=bs, epochs=eps, num_fit_loop_iters=num_fit_iters):
def run_with_batch_size(bs, eps, num_fit_loop_iters):
print("~" * 10 + "\tLSTM Network Creation: Start\t" + "~" * 10)
model = Sequential()
model.add(LSTM(lstm_input_layer_num_units, input_shape=input_tensor_shape))
model.add(Dense(dense_layer_num_units, activation=act_func))
model.compile(loss=loss_metric, optimizer=opt)
print(model.summary())
print(f"""\nLSTM Network Parameters (& Hypterparameters?):
Batch size: {bs}
Epochs: {eps}
LSTM input layer number of units (dim of output space): {lstm_input_layer_num_units}
Input tensor shape: {input_tensor_shape}
Dense (final) layer number of units (dim of output space): {dense_layer_num_units}
Dense (final) layer activation function: {act_func}
Optimizer: {loss_metric}
Loss metric: {opt}""")
print(f"""\nData Properties:
A single sequence of data: {seq}
Window size: {window_size}
Shape of training input data, x: {x.shape}
Shape of training output data, y: {y.shape}""")
print("~" * 10 + "\tLSTM Network Creation: End\t" + "~" * 10)
print("\n")
print("~"*10+"\tTraining Phase: Start\t"+"~"*10)
# print(f"Training methodology detailed description:\n\t{training_method_desc_info}")
print("Starting model.fit(.) & for loop training...")
for i in range(num_fit_loop_iters):
print("Fit Iteration Loop Number #: {0} out of {1}".format(i+1, num_fit_loop_iters))
model.fit(x, y,
batch_size=bs,
epochs=eps,
verbose=2,
shuffle=False
)
print("Ending of model.fit(.) & for loop training...")
print("~" * 10 + "\tTraining Phase: End\t" + "~" * 10)
print("\n")
print("~" * 10 + "\tPrediction Phase: Start\t" + "~" * 10)
print("~" * 5 + "\tPrediction # 1\t" + "~" * 5)
print(f"Predicting the array:\n\t{array_2_pred_1}")
print(f"Prediction result:\n\t{model.predict(array_2_pred_1, bs)}")
print("\n")
print("~" * 5 + "\tPrediction # 2\t" + "~" * 5)
print(f"Predicting the array:\n\t{array_2_pred_2}")
print(f"Prediction result:\n\t{model.predict(array_2_pred_2, bs)}")
print("\n")
print("~" * 5 + "\tPrediction # 3\t" + "~" * 5)
print(f"Predicting the array:\n\t{array_2_pred_3}")
print(f"Prediction result:\n\t{model.predict(array_2_pred_3, bs)}")
print("~" * 10 + "\tPrediction Phase: End\t" + "~" * 10)
# print(f"""\nLSTM Network Parameters (& Hypterparameters?):
# Batch size: {bs}
# Epochs: {eps}
# LSTM input layer number of units (dim of output space): {lstm_input_layer_num_units}
# Input tensor shape: {input_tensor_shape}
# Dense (final) layer number of units (dim of output space): {dense_layer_num_units}
# Dense (final) layer activation function: {act_func}
# Optimizer: {loss_metric}
# Loss metric: {opt}""")
#
# print(f"""\nData Properties:
# \tA single sequence of data: {seq}
# \tWindow size: {window_size}
# \tTraining input and output (equivalentX_train &y_train) data properties:
# \t\tShape of training input data, x: {x.shape}
# \t\tShape of training output data, y: {y.shape}""")
print("\nStarting LSTM training and prediction demo...")
run_with_batch_size(bs, eps, num_fit_loop_iters)
print("\nLSTM training and prediction demo complete!")
def print_additional_info():
print("\nAdditional notes on findings from the dude who asked the question:")
findings_from_author = """I have an alphabet consisting of a, b, and c
I have a sequence which is a,b,c,b,a
In this sequence a and c are always followed by b, and b is followed by c (if b was preceded by a) or by a (if b was preceded by c)
When my batch_size is 1:
I would expect that running model.predict([a, b]) gives the same result for b as when I run model.predict([b, c]) as the state was reset to zero between the two batches
The results I get match these expectations
When my batch_size is 2:
I would expect that when running model.predict([a, b]) the result for b should be affected by the result for a (since the output of a will be fed into the input of b). This means that it should have a different result for b then when I run model.predict([b, c])
The result I get is that actually the two b outputs are identical, implying that within my batch (a, b) the hidden state was reset between my two samples.
I'm still pretty fresh to this area, so it's very possible that I'm misunderstanding something. Is the initial state reset between each sample in a batch rather than between each batch?"""
print(findings_from_author)
print("Source: https://stackoverflow.com/questions/54187504/initial-states-in-keras-lstm")
# print('-'*30)
# run_with_batch_size(1)
# print('**')
# run_with_batch_size(2)
|
from Hw.H8_Seq2Seq.config import configurations
from Hw.H8_Seq2Seq.train import train_process
import torch
import os
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 判斷是用 CPU 還是 GPU 執行運算
config = configurations()
if not os.path.isdir(config.store_model_path):
os.mkdir(config.store_model_path)
print('config:\n', vars(config))
train_losses, val_losses, bleu_scores = train_process(config, device)
|
# (c) Copyright IBM Corp. 2019. All Rights Reserved.
# -*- coding: utf-8 -*-
"""Generate the Resilient customizations required for fn_service_now"""
from __future__ import print_function
from resilient_circuits.util import *
def codegen_reload_data():
"""Parameters to codegen used to generate the fn_service_now package"""
reload_params = {"package": u"fn_service_now",
"incident_fields": [u"sn_snow_record_id", u"sn_snow_record_link"],
"action_fields": [u"sn_assignment_group", u"sn_close_code", u"sn_close_notes", u"sn_initial_note", u"sn_record_state"],
"function_params": [u"attachment_id", u"incident_id", u"sn_close_code", u"sn_close_notes", u"sn_close_work_note", u"sn_init_work_note", u"sn_note_text", u"sn_note_type", u"sn_optional_fields", u"sn_query_field", u"sn_query_value", u"sn_record_state", u"sn_res_id", u"sn_resilient_status", u"sn_table_name", u"sn_update_fields", u"task_id"],
"datatables": [u"sn_records_dt"],
"message_destinations": [u"fn_service_now"],
"functions": [u"fn_snow_add_attachment_to_record", u"fn_snow_add_note_to_record", u"fn_snow_close_record", u"fn_snow_create_record", u"fn_snow_helper_add_task_note", u"fn_snow_helper_update_datatable", u"fn_snow_lookup_sysid", u"fn_snow_update_record"],
"phases": [],
"automatic_tasks": [],
"scripts": [],
"workflows": [u"example_snow_add_attachment_to_record", u"example_snow_add_comment_to_record", u"example_snow_add_worknote_to_record", u"example_snow_close_record_from_data_table", u"example_snow_close_record_incident", u"example_snow_close_record_task", u"example_snow_create_record_incident", u"example_snow_create_record_task", u"example_snow_update_datatable_on_status_change_incident", u"example_snow_update_datatable_on_status_change_task", u"example_snow_update_record_on_severity_change"],
"actions": [u"SNOW: Add Attachment to Record", u"SNOW: Close Record [Incident]", u"SNOW: Close Record [Task]", u"SNOW: Close Record from Data Table", u"SNOW: Create Record [Incident]", u"SNOW: Create Record [Task]", u"SNOW: Send as Additional Comment", u"SNOW: Send as Work Note", u"SNOW: Update Data Table on Status Change [Incident]", u"SNOW: Update Data Table on Status Change [Task]", u"SNOW: Update Record on Severity Change"]
}
return reload_params
def customization_data(client=None):
"""Produce any customization definitions (types, fields, message destinations, etc)
that should be installed by `resilient-circuits customize`
"""
# This import data contains:
# Incident fields:
# sn_snow_record_id
# sn_snow_record_link
# Action fields:
# sn_assignment_group
# sn_close_code
# sn_close_notes
# sn_initial_note
# sn_record_state
# Function inputs:
# attachment_id
# incident_id
# sn_close_code
# sn_close_notes
# sn_close_work_note
# sn_init_work_note
# sn_note_text
# sn_note_type
# sn_optional_fields
# sn_query_field
# sn_query_value
# sn_record_state
# sn_res_id
# sn_resilient_status
# sn_table_name
# sn_update_fields
# task_id
# DataTables:
# sn_records_dt
# Message Destinations:
# fn_service_now
# Functions:
# fn_snow_add_attachment_to_record
# fn_snow_add_note_to_record
# fn_snow_close_record
# fn_snow_create_record
# fn_snow_helper_add_task_note
# fn_snow_helper_update_datatable
# fn_snow_lookup_sysid
# fn_snow_update_record
# Workflows:
# example_snow_add_attachment_to_record
# example_snow_add_comment_to_record
# example_snow_add_worknote_to_record
# example_snow_close_record_from_data_table
# example_snow_close_record_incident
# example_snow_close_record_task
# example_snow_create_record_incident
# example_snow_create_record_task
# example_snow_update_datatable_on_status_change_incident
# example_snow_update_datatable_on_status_change_task
# example_snow_update_record_on_severity_change
# Rules:
# SNOW: Add Attachment to Record
# SNOW: Close Record [Incident]
# SNOW: Close Record [Task]
# SNOW: Close Record from Data Table
# SNOW: Create Record [Incident]
# SNOW: Create Record [Task]
# SNOW: Send as Additional Comment
# SNOW: Send as Work Note
# SNOW: Update Data Table on Status Change [Incident]
# SNOW: Update Data Table on Status Change [Task]
# SNOW: Update Record on Severity Change
yield ImportDefinition(u"""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"""
) |
# Copyright 2021 STC-Innovation LTD (Author: Anton Mitrofanov)
import sys
import logging
import os
def setup_logger(exp_dir=None, log_fn="training.log", stream=sys.stdout, logger_level=logging.INFO, logfile_mode="w"):
logger = logging.getLogger()
logger.setLevel(logger_level)
logger.handlers.clear()
# default output
c_handler = logging.StreamHandler(stream)
c_format = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
c_handler.setFormatter(c_format)
logger.addHandler(c_handler)
# Also writes logs to the experiment directory
if exp_dir is not None:
os.makedirs(exp_dir, exist_ok=True)
log_path = os.path.join(exp_dir, log_fn)
f_handler =logging.FileHandler(log_path, mode=logfile_mode, encoding="utf-8")
f_format = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
f_handler.setFormatter(f_format)
logger.addHandler(f_handler)
|
[262144, 18, 0, 0, 0, 0.43696],
[262440, 3, 8, 1, 0, 0.626528],
[262500, 2, 1, 5, 1, 0.828288],
[263424, 8, 1, 0, 3, 0.762944],
[264600, 3, 3, 2, 2, 0.691968],
[268800, 9, 1, 2, 1, 0.71488],
[268912, 4, 0, 0, 5, 0.754944],
[270000, 4, 3, 4, 0, 0.609312],
[272160, 5, 5, 1, 1, 0.72368],
[273375, 0, 7, 3, 0, 0.7416],
[274400, 5, 0, 2, 3, 0.697472],
[275562, 1, 9, 0, 1, 0.834784],
[275625, 0, 2, 4, 2, 0.821088],
[276480, 11, 3, 1, 0, 0.60752],
[277830, 1, 4, 1, 3, 0.921216],
[279936, 7, 7, 0, 0, 0.568544],
[280000, 6, 0, 4, 1, 0.635552],
[281250, 1, 2, 6, 0, 0.920672],
[282240, 7, 2, 1, 2, 0.734048],
[283500, 2, 4, 3, 1, 0.779296],
[285768, 3, 6, 0, 2, 0.759712],
[286720, 13, 0, 1, 1, 0.63344],
[288000, 8, 2, 3, 0, 0.689024],
[288120, 3, 1, 1, 4, 0.946432],
[290304, 9, 4, 0, 1, 0.644096],
[291600, 4, 6, 2, 0, 0.671488],
[294000, 4, 1, 3, 2, 0.839776],
[294912, 15, 2, 0, 0, 0.57632],
[295245, 0, 10, 1, 0, 0.854848],
[296352, 5, 3, 0, 3, 0.764352],
[297675, 0, 5, 2, 2, 0.812928],
[300000, 5, 1, 5, 0, 0.777472],
[300125, 0, 0, 3, 4, 0.897024],
[301056, 11, 1, 0, 2, 0.723328],
[302400, 6, 3, 2, 1, 0.71104],
[302526, 1, 2, 0, 5, 1.04768],
[303750, 1, 5, 4, 0, 0.87456],
[306180, 2, 7, 1, 1, 0.891776],
[306250, 1, 0, 5, 2, 0.962688],
[307200, 12, 1, 2, 0, 0.657056],
[307328, 7, 0, 0, 4, 0.757728],
[308700, 2, 2, 2, 3, 0.961792],
[311040, 8, 5, 1, 0, 0.766368],
[312500, 2, 0, 7, 0, 0.808192],
[313600, 8, 0, 2, 2, 0.74464],
[314928, 4, 9, 0, 0, 0.696768],
[315000, 3, 2, 4, 1, 0.859072],
[317520, 4, 4, 1, 2, 0.79968],
[320000, 9, 0, 4, 0, 0.676224],
[321489, 0, 8, 0, 2, 0.827488],
[322560, 10, 2, 1, 1, 0.822176],
[324000, 5, 4, 3, 0, 0.700576],
[324135, 0, 3, 1, 4, 1.03693],
[326592, 6, 6, 0, 1, 0.780384],
[327680, 16, 0, 1, 0, 0.66928],
[328050, 1, 8, 2, 0, 0.858656],
[328125, 0, 1, 6, 1, 1.0952],
[329280, 6, 1, 1, 3, 0.98784],
[330750, 1, 3, 3, 2, 1.05946],
[331776, 12, 4, 0, 0, 0.581664],
[333396, 2, 5, 0, 3, 0.962752],
[336000, 7, 1, 3, 1, 0.929888],
[336140, 2, 0, 1, 5, 1.12787],
[337500, 2, 3, 5, 0, 0.911488],
[338688, 8, 3, 0, 2, 0.792576],
[340200, 3, 5, 2, 1, 0.895296],
[343000, 3, 0, 3, 3, 0.992064],
[344064, 14, 1, 0, 1, 0.784384],
[345600, 9, 3, 2, 0, 0.74832],
[345744, 4, 2, 0, 4, 0.944576],
[349920, 5, 7, 1, 0, 0.816544],
[350000, 4, 0, 5, 1, 0.888736],
[351232, 10, 0, 0, 3, 0.843392],
[352800, 5, 2, 2, 2, 0.875456],
[352947, 0, 1, 0, 6, 1.1753],
[354294, 1, 11, 0, 0, 0.935808],
[354375, 0, 4, 4, 1, 0.960032],
[357210, 1, 6, 1, 2, 1.15962],
[358400, 11, 0, 2, 1, 0.756704],
[360000, 6, 2, 4, 0, 0.7872],
[360150, 1, 1, 2, 4, 1.25658],
[362880, 7, 4, 1, 1, 0.867456],
[364500, 2, 6, 3, 0, 0.990304],
[367416, 3, 8, 0, 1, 0.88048],
[367500, 2, 1, 4, 2, 1.11981],
[368640, 13, 2, 1, 0, 0.791488],
[370440, 3, 3, 1, 3, 1.13638],
[373248, 9, 6, 0, 0, 0.829408],
[375000, 3, 1, 6, 0, 1.09638],
[376320, 9, 1, 1, 2, 1.06707],
[378000, 4, 3, 3, 1, 0.982528],
[381024, 5, 5, 0, 2, 0.916512],
[382725, 0, 7, 2, 1, 1.05133],
[384000, 10, 1, 3, 0, 0.948128],
[384160, 5, 0, 1, 4, 1.05648],
[385875, 0, 2, 3, 3, 1.27629],
[387072, 11, 3, 0, 1, 0.840704],
[388800, 6, 5, 2, 0, 0.838912],
[388962, 1, 4, 0, 4, 1.19744],
[390625, 0, 0, 8, 0, 1.11078],
[392000, 6, 0, 3, 2, 0.934944],
[393216, 17, 1, 0, 0, 0.817312],
[393660, 2, 9, 1, 0, 1.03222],
[393750, 1, 2, 5, 1, 1.30106],
[395136, 7, 2, 0, 3, 1.01866],
[396900, 2, 4, 2, 2, 1.05302],
[400000, 7, 0, 5, 0, 0.876352],
[401408, 13, 0, 0, 2, 0.782592],
[403200, 8, 2, 2, 1, 0.98736],
[403368, 3, 1, 0, 5, 1.32064],
[405000, 3, 4, 4, 0, 0.919168],
[408240, 4, 6, 1, 1, 1.12378],
[409600, 14, 0, 2, 0, 0.733408],
[411600, 4, 1, 2, 3, 1.20467],
[413343, 0, 10, 0, 1, 1.19501],
[414720, 10, 4, 1, 0, 0.88768],
[416745, 0, 5, 1, 3, 1.31299],
[419904, 6, 8, 0, 0, 0.782592],
[420000, 5, 1, 4, 1, 1.11338],
[420175, 0, 0, 2, 5, 1.33197],
[421875, 0, 3, 6, 0, 1.29891],
[423360, 6, 3, 1, 2, 1.06323],
[425250, 1, 5, 3, 1, 1.36528],
[428652, 2, 7, 0, 2, 1.14733],
[428750, 1, 0, 4, 3, 1.38381],
[430080, 12, 1, 1, 1, 1.11104],
[432000, 7, 3, 3, 0, 0.954976],
[432180, 2, 2, 1, 4, 1.4193],
[435456, 8, 5, 0, 1, 1.03856],
[437400, 3, 7, 2, 0, 1.01946],
[437500, 2, 0, 6, 1, 1.25754],
[439040, 8, 0, 1, 3, 1.19645],
[441000, 3, 2, 3, 2, 1.26557],
[442368, 14, 3, 0, 0, 0.791008],
[444528, 4, 4, 0, 3, 1.11907],
[448000, 9, 0, 3, 1, 1.1049],
[450000, 4, 2, 5, 0, 1.12864],
[451584, 10, 2, 0, 2, 1.07002],
[453600, 5, 4, 2, 1, 1.0176],
[453789, 0, 3, 0, 5, 1.46678],
[455625, 0, 6, 4, 0, 1.22861],
[458752, 16, 0, 0, 1, 0.905568],
[459270, 1, 8, 1, 1, 1.40307],
[459375, 0, 1, 5, 2, 1.41923],
[460800, 11, 2, 2, 0, 0.95056],
[460992, 6, 1, 0, 4, 1.27693],
[463050, 1, 3, 2, 3, 1.49744],
[466560, 7, 6, 1, 0, 1.09859],
[468750, 1, 1, 7, 0, 1.49709],
[470400, 7, 1, 2, 2, 1.18842],
[470596, 2, 0, 0, 6, 1.46054],
[472392, 3, 10, 0, 0, 1.17683],
[472500, 2, 3, 4, 1, 1.31808],
[476280, 3, 5, 1, 2, 1.36534],
[480000, 8, 1, 4, 0, 1.14605],
[480200, 3, 0, 2, 4, 1.33302],
[483840, 9, 3, 1, 1, 1.2648],
[486000, 4, 5, 3, 0, 1.18051],
[489888, 5, 7, 0, 1, 1.13453],
[490000, 4, 0, 4, 2, 1.17818],
[491520, 15, 1, 1, 0, 1.14269],
[492075, 0, 9, 2, 0, 1.22752],
[493920, 5, 2, 1, 3, 1.43798],
[496125, 0, 4, 3, 2, 1.44906],
[497664, 11, 5, 0, 0, 1.03872],
[500000, 5, 0, 6, 0, 1.21072],
[500094, 1, 6, 0, 3, 1.6256],
[501760, 11, 0, 1, 2, 1.18643],
[504000, 6, 2, 3, 1, 1.28646],
[504210, 1, 1, 1, 5, 1.93453],
[506250, 1, 4, 5, 0, 1.46701],
[508032, 7, 4, 0, 2, 1.0976],
[510300, 2, 6, 2, 1, 1.45069],
[512000, 12, 0, 3, 0, 1.11594],
[514500, 2, 1, 3, 3, 1.70774],
[516096, 13, 2, 0, 1, 1.09984],
[518400, 8, 4, 2, 0, 1.05312],
[518616, 3, 3, 0, 4, 1.4697],
[524288, 19, 0, 0, 0, 0.849568],
[524880, 4, 8, 1, 0, 1.17779],
[525000, 3, 1, 5, 1, 1.59027],
[526848, 9, 1, 0, 3, 1.50435],
[529200, 4, 3, 2, 2, 1.30362],
[531441, 0, 12, 0, 0, 1.22979],
[535815, 0, 7, 1, 2, 1.57542],
[537600, 10, 1, 2, 1, 1.37117],
[537824, 5, 0, 0, 5, 1.47171],
[540000, 5, 3, 4, 0, 1.18614],
[540225, 0, 2, 2, 4, 1.69997],
[544320, 6, 5, 1, 1, 1.39693],
[546750, 1, 7, 3, 0, 1.60931],
[546875, 0, 0, 7, 1, 1.6033],
[548800, 6, 0, 2, 3, 1.3521],
[551124, 2, 9, 0, 1, 1.50038],
[551250, 1, 2, 4, 2, 1.7487],
[552960, 12, 3, 1, 0, 1.17334],
[555660, 2, 4, 1, 3, 1.71344],
[559872, 8, 7, 0, 0, 1.13398],
[560000, 7, 0, 4, 1, 1.24144],
[562500, 2, 2, 6, 0, 1.65094],
[564480, 8, 2, 1, 2, 1.48112],
[567000, 3, 4, 3, 1, 1.47667],
[571536, 4, 6, 0, 2, 1.43834],
[573440, 14, 0, 1, 1, 1.25386],
[576000, 9, 2, 3, 0, 1.39501],
[576240, 4, 1, 1, 4, 1.81469],
[580608, 10, 4, 0, 1, 1.2417],
[583200, 5, 6, 2, 0, 1.31357],
[583443, 0, 5, 0, 4, 1.71818],
[588000, 5, 1, 3, 2, 1.64227],
[588245, 0, 0, 1, 6, 1.88752],
[589824, 16, 2, 0, 0, 1.14096],
[590490, 1, 10, 1, 0, 1.87194],
[590625, 0, 3, 5, 1, 1.80973],
[592704, 6, 3, 0, 3, 1.49181],
[595350, 1, 5, 2, 2, 1.81507],
[600000, 6, 1, 5, 0, 1.51085],
[600250, 1, 0, 3, 4, 2.01411],
[602112, 12, 1, 0, 2, 1.40406],
[604800, 7, 3, 2, 1, 1.37978],
[605052, 2, 2, 0, 5, 1.99862],
[607500, 2, 5, 4, 0, 1.53168],
[612360, 3, 7, 1, 1, 1.69891],
[612500, 2, 0, 5, 2, 1.71875],
[614400, 13, 1, 2, 0, 1.29306],
[614656, 8, 0, 0, 4, 1.52179],
[617400, 3, 2, 2, 3, 1.81446],
[622080, 9, 5, 1, 0, 1.52938],
[625000, 3, 0, 7, 0, 1.56528],
[627200, 9, 0, 2, 2, 1.47226],
[629856, 5, 9, 0, 0, 1.33754],
[630000, 4, 2, 4, 1, 1.62368],
[635040, 5, 4, 1, 2, 1.5784],
[637875, 0, 6, 3, 1, 1.9991],
[640000, 10, 0, 4, 0, 1.30442],
[642978, 1, 8, 0, 2, 1.82189],
[643125, 0, 1, 4, 3, 2.07856],
[645120, 11, 2, 1, 1, 1.632],
[648000, 6, 4, 3, 0, 1.36195],
[648270, 1, 3, 1, 4, 2.20838],
[653184, 7, 6, 0, 1, 1.52224],
[655360, 17, 0, 1, 0, 1.34589],
[656100, 2, 8, 2, 0, 1.55667],
[656250, 1, 1, 6, 1, 2.34765],
[658560, 7, 1, 1, 3, 1.96096],
[661500, 2, 3, 3, 2, 1.91754],
[663552, 13, 4, 0, 0, 1.13875],
[666792, 3, 5, 0, 3, 1.90326],
[672000, 8, 1, 3, 1, 1.8576],
[672280, 3, 0, 1, 5, 2.17146],
[675000, 3, 3, 5, 0, 1.74947],
[677376, 9, 3, 0, 2, 1.6319],
[680400, 4, 5, 2, 1, 1.70189],
[686000, 4, 0, 3, 3, 1.90419],
[688128, 15, 1, 0, 1, 1.57293],
[688905, 0, 9, 1, 1, 1.99674],
[691200, 10, 3, 2, 0, 1.45165],
[691488, 5, 2, 0, 4, 1.86874],
[694575, 0, 4, 2, 3, 2.03424],
[699840, 6, 7, 1, 0, 1.57235],
[700000, 5, 0, 5, 1, 1.74573],
[702464, 11, 0, 0, 3, 1.6536],
[703125, 0, 2, 7, 0, 2.06678],
[705600, 6, 2, 2, 2, 1.70746],
[705894, 1, 1, 0, 6, 2.56944],
[708588, 2, 11, 0, 0, 1.71248],
[708750, 1, 4, 4, 1, 2.08621],
[714420, 2, 6, 1, 2, 2.20317],
[716800, 12, 0, 2, 1, 1.48314],
[720000, 7, 2, 4, 0, 1.57434],
[720300, 2, 1, 2, 4, 2.35587],
[725760, 8, 4, 1, 1, 1.74986],
[729000, 3, 6, 3, 0, 1.91962],
[734832, 4, 8, 0, 1, 1.65162],
[735000, 3, 1, 4, 2, 2.14307],
[737280, 14, 2, 1, 0, 1.5681],
[740880, 4, 3, 1, 3, 2.16358],
[746496, 10, 6, 0, 0, 1.61075],
[750000, 4, 1, 6, 0, 2.12218],
[750141, 0, 7, 0, 3, 2.20538],
[752640, 10, 1, 1, 2, 2.11098],
[756000, 5, 3, 3, 1, 1.92429],
[756315, 0, 2, 1, 5, 2.62474],
[759375, 0, 5, 5, 0, 2.1095],
[762048, 6, 5, 0, 2, 1.78685],
[765450, 1, 7, 2, 1, 2.28662],
[765625, 0, 0, 6, 2, 2.37469],
[768000, 11, 1, 3, 0, 1.89914],
[768320, 6, 0, 1, 4, 2.06544],
[771750, 1, 2, 3, 3, 2.7328],
[774144, 12, 3, 0, 1, 1.64512],
[777600, 7, 5, 2, 0, 1.63936],
[777924, 2, 4, 0, 4, 2.23552],
[781250, 1, 0, 8, 0, 2.5056],
[784000, 7, 0, 3, 2, 1.85296],
[786432, 18, 1, 0, 0, 1.60173],
[787320, 3, 9, 1, 0, 2.04259],
[787500, 2, 2, 5, 1, 2.41411],
[790272, 8, 2, 0, 3, 2.08646],
[793800, 3, 4, 2, 2, 1.98851],
[800000, 8, 0, 5, 0, 1.78886],
[802816, 14, 0, 0, 2, 1.55379],
[806400, 9, 2, 2, 1, 2.0375],
[806736, 4, 1, 0, 5, 2.5552],
[810000, 4, 4, 4, 0, 1.72864],
[816480, 5, 6, 1, 1, 2.21658],
[819200, 15, 0, 2, 0, 1.49936],
[820125, 0, 8, 3, 0, 2.19242],
[823200, 5, 1, 2, 3, 2.37504],
[823543, 0, 0, 0, 7, 2.82941],
[826686, 1, 10, 0, 1, 2.66435],
[826875, 0, 3, 4, 2, 2.39478],
[829440, 11, 4, 1, 0, 1.73507],
[833490, 1, 5, 1, 3, 2.91322],
[839808, 7, 8, 0, 0, 1.53091],
[840000, 6, 1, 4, 1, 2.17821],
[840350, 1, 0, 2, 5, 2.90634],
[843750, 1, 3, 6, 0, 2.70032],
[846720, 7, 3, 1, 2, 2.11946],
[850500, 2, 5, 3, 1, 2.40125],
[857304, 3, 7, 0, 2, 2.19728],
[857500, 2, 0, 4, 3, 2.56835],
[860160, 13, 1, 1, 1, 2.2201],
[864000, 8, 3, 3, 0, 1.95734],
[864360, 3, 2, 1, 4, 2.75664],
[870912, 9, 5, 0, 1, 2.13037],
[874800, 4, 7, 2, 0, 1.92096],
[875000, 3, 0, 6, 1, 2.5024],
[878080, 9, 0, 1, 3, 2.47901],
[882000, 4, 2, 3, 2, 2.42525],
[884736, 15, 3, 0, 0, 1.62557],
[885735, 0, 11, 1, 0, 2.38915],
[889056, 5, 4, 0, 3, 2.19613],
[893025, 0, 6, 2, 2, 2.60739],
[896000, 10, 0, 3, 1, 2.19299],
[900000, 5, 2, 5, 0, 2.21587],
[900375, 0, 1, 3, 4, 2.98384],
[903168, 11, 2, 0, 2, 2.10429],
[907200, 6, 4, 2, 1, 1.98957],
[907578, 1, 3, 0, 5, 3.11005],
[911250, 1, 6, 4, 0, 2.63126],
[917504, 17, 0, 0, 1, 1.86394],
[918540, 2, 8, 1, 1, 2.5967],
[918750, 1, 1, 5, 2, 3.15856],
[921600, 12, 2, 2, 0, 1.86998],
[921984, 7, 1, 0, 4, 2.53075],
[926100, 2, 3, 2, 3, 2.81056],
[933120, 8, 6, 1, 0, 2.24822],
[937500, 2, 1, 7, 0, 2.80454],
[940800, 8, 1, 2, 2, 2.4407],
[941192, 3, 0, 0, 6, 2.84816],
[944784, 4, 10, 0, 0, 2.27248],
[945000, 3, 3, 4, 1, 2.53677],
[952560, 4, 5, 1, 2, 2.62928],
[960000, 9, 1, 4, 0, 2.4015],
[960400, 4, 0, 2, 4, 2.55478],
[964467, 0, 9, 0, 2, 2.63942],
[967680, 10, 3, 1, 1, 2.4969],
[972000, 5, 5, 3, 0, 2.31322],
[972405, 0, 4, 1, 4, 3.06464],
[979776, 6, 7, 0, 1, 2.20483],
[980000, 5, 0, 4, 2, 2.33376],
[983040, 16, 1, 1, 0, 2.32086],
[984150, 1, 9, 2, 0, 2.76688],
[984375, 0, 2, 6, 1, 3.25674],
[987840, 6, 2, 1, 3, 2.8319],
[992250, 1, 4, 3, 2, 3.108],
[995328, 12, 5, 0, 0, 2.28227],
[1000000, 6, 0, 6, 0, 2.3753],
[1000188, 2, 6, 0, 3, 3.08381],
[1003520, 12, 0, 1, 2, 2.3097],
[1008000, 7, 2, 3, 1, 2.55894],
[1008420, 2, 1, 1, 5, 3.74643],
[1012500, 2, 4, 5, 0, 2.63856],
[1016064, 8, 4, 0, 2, 2.24301],
[1020600, 3, 6, 2, 1, 2.79795],
[1024000, 13, 0, 3, 0, 2.18605],
[1029000, 3, 1, 3, 3, 3.38019],
[1032192, 14, 2, 0, 1, 2.19011],
[1036800, 9, 4, 2, 0, 2.17232],
[1037232, 4, 3, 0, 4, 2.81901],
[1048576, 20, 0, 0, 0, 1.79008],
[1049760, 5, 8, 1, 0, 2.32083],
[1050000, 4, 1, 5, 1, 3.07494],
[1053696, 10, 1, 0, 3, 2.97002],
[1058400, 5, 3, 2, 2, 2.58963],
[1058841, 0, 2, 0, 6, 3.5232],
[1062882, 1, 12, 0, 0, 2.73008],
[1063125, 0, 5, 4, 1, 3.04106],
[1071630, 1, 7, 1, 2, 3.4521],
[1071875, 0, 0, 5, 3, 3.41763],
[1075200, 11, 1, 2, 1, 2.70691],
[1075648, 6, 0, 0, 5, 2.90086],
[1080000, 6, 3, 4, 0, 2.31091],
[1080450, 1, 2, 2, 4, 3.68438],
[1088640, 7, 5, 1, 1, 2.7848],
[1093500, 2, 7, 3, 0, 2.9],
[1093750, 1, 0, 7, 1, 3.57494],
[1097600, 7, 0, 2, 3, 2.67558],
[1102248, 3, 9, 0, 1, 2.87779],
[1102500, 2, 2, 4, 2, 3.28579],
[1105920, 13, 3, 1, 0, 2.34211],
[1111320, 3, 4, 1, 3, 3.30896],
[1119744, 9, 7, 0, 0, 2.41754],
[1120000, 8, 0, 4, 1, 2.59043],
[1125000, 3, 2, 6, 0, 3.22214],
[1128960, 9, 2, 1, 2, 3.14624],
[1134000, 4, 4, 3, 1, 2.86045],
[1143072, 5, 6, 0, 2, 2.84602],
[1146880, 15, 0, 1, 1, 2.572],
[1148175, 0, 8, 2, 1, 3.0777],
[1152000, 10, 2, 3, 0, 2.7783],
[1152480, 5, 1, 1, 4, 3.61274],
[1157625, 0, 3, 3, 3, 3.79904],
[1161216, 11, 4, 0, 1, 2.4385],
[1166400, 6, 6, 2, 0, 2.58141],
[1166886, 1, 5, 0, 4, 3.84925],
[1171875, 0, 1, 8, 0, 3.81043],
[1176000, 6, 1, 3, 2, 3.2312],
[1176490, 1, 0, 1, 6, 4.23466],
[1179648, 17, 2, 0, 0, 2.37485],
[1180980, 2, 10, 1, 0, 3.30176],
[1181250, 1, 3, 5, 1, 3.84211],
[1185408, 7, 3, 0, 3, 2.96067],
[1190700, 2, 5, 2, 2, 3.28195],
[1200000, 7, 1, 5, 0, 3.02022],
[1200500, 2, 0, 3, 4, 3.64518],
[1204224, 13, 1, 0, 2, 2.82058],
[1209600, 8, 3, 2, 1, 2.82803],
[1210104, 3, 2, 0, 5, 3.87859],
[1215000, 3, 5, 4, 0, 3.02864],
[1224720, 4, 7, 1, 1, 3.27402],
[1225000, 3, 0, 5, 2, 3.39408],
[1228800, 14, 1, 2, 0, 2.62845],
[1229312, 9, 0, 0, 4, 3.20435],
[1234800, 4, 2, 2, 3, 3.50851],
[1240029, 0, 11, 0, 1, 3.38704],
[1244160, 10, 5, 1, 0, 3.05722],
[1250000, 4, 0, 7, 0, 3.03008],
[1250235, 0, 6, 1, 3, 4.19437],
[1254400, 10, 0, 2, 2, 2.90995],
[1259712, 6, 9, 0, 0, 2.62131],
[1260000, 5, 2, 4, 1, 3.22499],
[1260525, 0, 1, 2, 5, 4.37466],
[1265625, 0, 4, 6, 0, 3.75482],
[1270080, 6, 4, 1, 2, 3.13034],
[1275750, 1, 6, 3, 1, 4.19616],
[1280000, 11, 0, 4, 0, 2.57597],
[1285956, 2, 8, 0, 2, 3.39974],
[1286250, 1, 1, 4, 3, 4.65565],
[1290240, 12, 2, 1, 1, 3.23267],
[1296000, 7, 4, 3, 0, 2.70355],
[1296540, 2, 3, 1, 4, 4.2512],
[1306368, 8, 6, 0, 1, 3.15059],
[1310720, 18, 0, 1, 0, 2.66582],
[1312200, 3, 8, 2, 0, 2.95107],
[1312500, 2, 1, 6, 1, 4.34598],
[1317120, 8, 1, 1, 3, 4.04557],
[1323000, 3, 3, 3, 2, 3.75952],
[1327104, 14, 4, 0, 0, 2.42205],
[1333584, 4, 5, 0, 3, 3.68608],
[1344000, 9, 1, 3, 1, 3.87626],
[1344560, 4, 0, 1, 5, 4.2159],
[1350000, 4, 3, 5, 0, 3.35606],
[1354752, 10, 3, 0, 2, 3.22307],
[1360800, 5, 5, 2, 1, 3.36387],
[1361367, 0, 4, 0, 5, 4.31363],
[1366875, 0, 7, 4, 0, 3.5897],
[1372000, 5, 0, 3, 3, 3.76189],
[1376256, 16, 1, 0, 1, 3.2433],
[1377810, 1, 9, 1, 1, 4.50992],
[1378125, 0, 2, 5, 2, 4.40176],
[1382400, 11, 3, 2, 0, 2.86787],
[1382976, 6, 2, 0, 4, 3.6967],
[1389150, 1, 4, 2, 3, 4.43488],
[1399680, 7, 7, 1, 0, 3.13011],
[1400000, 6, 0, 5, 1, 3.45965],
[1404928, 12, 0, 0, 3, 3.23917],
[1406250, 1, 2, 7, 0, 4.53539],
[1411200, 7, 2, 2, 2, 3.4207],
[1411788, 2, 1, 0, 6, 4.97386],
[1417176, 3, 11, 0, 0, 3.28026],
[1417500, 2, 4, 4, 1, 3.88013],
[1428840, 3, 6, 1, 2, 4.29306],
[1433600, 13, 0, 2, 1, 2.96282],
[1440000, 8, 2, 4, 0, 3.26141],
[1440600, 3, 1, 2, 4, 4.58122],
[1451520, 9, 4, 1, 1, 3.74163],
[1458000, 4, 6, 3, 0, 3.70544],
[1469664, 5, 8, 0, 1, 3.26445],
[1470000, 4, 1, 4, 2, 4.15104],
[1474560, 15, 2, 1, 0, 3.27203],
[1476225, 0, 10, 2, 0, 4.09203],
[1481760, 5, 3, 1, 3, 4.32173],
[1488375, 0, 5, 3, 2, 4.52986],
[1492992, 11, 6, 0, 0, 3.18419],
[1500000, 5, 1, 6, 0, 4.21741],
[1500282, 1, 7, 0, 3, 4.84867],
[1500625, 0, 0, 4, 4, 4.6793],
[1505280, 11, 1, 1, 2, 4.21354],
[1512000, 6, 3, 3, 1, 3.81072],
[1512630, 1, 2, 1, 5, 5.81053],
[1518750, 1, 5, 5, 0, 4.75942],
[1524096, 7, 5, 0, 2, 3.55594],
[1530900, 2, 7, 2, 1, 4.27344],
[1531250, 1, 0, 6, 2, 5.34733],
[1536000, 12, 1, 3, 0, 3.98618],
[1536640, 7, 0, 1, 4, 4.14534],
[1543500, 2, 2, 3, 3, 5.15299],
[1548288, 13, 3, 0, 1, 3.29334],
[1555200, 8, 5, 2, 0, 3.41283],
[1555848, 3, 4, 0, 4, 4.31171],
[1562500, 2, 0, 8, 0, 4.36883],
[1568000, 8, 0, 3, 2, 3.89379],
[1572864, 19, 1, 0, 0, 3.23712],
[1574640, 4, 9, 1, 0, 3.96278],
[1575000, 3, 2, 5, 1, 4.70566],
[1580544, 9, 2, 0, 3, 4.43738],
[1587600, 4, 4, 2, 2, 3.82147],
[1594323, 0, 13, 0, 0, 3.99824],
[1600000, 9, 0, 5, 0, 3.81046],
[1605632, 15, 0, 0, 2, 3.24518],
[1607445, 0, 8, 1, 2, 4.70832],
[1612800, 10, 2, 2, 1, 4.03072],
[1613472, 5, 1, 0, 5, 5.08515],
[1620000, 5, 4, 4, 0, 3.43386],
[1620675, 0, 3, 2, 4, 5.10733],
[1632960, 6, 6, 1, 1, 4.38045],
[1638400, 16, 0, 2, 0, 3.2544],
[1640250, 1, 8, 3, 0, 4.76202],
[1640625, 0, 1, 7, 1, 5.28176],
[1646400, 6, 1, 2, 3, 4.68515],
[1647086, 1, 0, 0, 7, 6.05494],
[1653372, 2, 10, 0, 1, 4.6553],
[1653750, 1, 3, 4, 2, 5.15885],
[1658880, 12, 4, 1, 0, 3.48627],
[1666980, 2, 5, 1, 3, 5.35568],
[1679616, 8, 8, 0, 0, 3.2481],
[1680000, 7, 1, 4, 1, 4.35661],
[1680700, 2, 0, 2, 5, 5.46922],
[1687500, 2, 3, 6, 0, 4.90102],
[1693440, 8, 3, 1, 2, 4.40362],
[1701000, 3, 5, 3, 1, 4.856],
[1714608, 4, 7, 0, 2, 4.23606],
[1715000, 3, 0, 4, 3, 4.95363],
[1720320, 14, 1, 1, 1, 4.44723],
[1728000, 9, 3, 3, 0, 4.21728],
[1728720, 4, 2, 1, 4, 5.38522],
[1741824, 10, 5, 0, 1, 4.29568],
[1749600, 5, 7, 2, 0, 3.82877],
[1750000, 4, 0, 6, 1, 4.91942],
[1750329, 0, 6, 0, 4, 5.52682],
[1756160, 10, 0, 1, 3, 4.93725],
[1764000, 5, 2, 3, 2, 4.81603],
[1764735, 0, 1, 1, 6, 6.37981],
[1769472, 16, 3, 0, 0, 3.41405],
[1771470, 1, 11, 1, 0, 5.30435],
[1771875, 0, 4, 5, 1, 5.4271],
[1778112, 6, 4, 0, 3, 4.3536],
[1786050, 1, 6, 2, 2, 5.63037],
[1792000, 11, 0, 3, 1, 4.42477],
[1800000, 6, 2, 5, 0, 4.38778],
[1800750, 1, 1, 3, 4, 6.6239],
[1806336, 12, 2, 0, 2, 4.12557],
[1814400, 7, 4, 2, 1, 3.96429],
[1815156, 2, 3, 0, 5, 6.00054],
[1822500, 2, 6, 4, 0, 5.00877],
[1835008, 18, 0, 0, 1, 3.71798],
[1837080, 3, 8, 1, 1, 5.01203],
[1837500, 2, 1, 5, 2, 5.99978],
[1843200, 13, 2, 2, 0, 3.77136],
[1843968, 8, 1, 0, 4, 5.22256],
[1852200, 3, 3, 2, 3, 5.46832],
[1866240, 9, 6, 1, 0, 4.86544],
[1875000, 3, 1, 7, 0, 5.52246],
[1881600, 9, 1, 2, 2, 5.24941],
[1882384, 4, 0, 0, 6, 5.52131],
[1889568, 5, 10, 0, 0, 4.48573],
[1890000, 4, 3, 4, 1, 4.90675],
[1905120, 5, 5, 1, 2, 5.19562],
[1913625, 0, 7, 3, 1, 5.83424],
[1920000, 10, 1, 4, 0, 4.77104],
[1920800, 5, 0, 2, 4, 5.0921],
[1928934, 1, 9, 0, 2, 5.94714],
[1929375, 0, 2, 4, 3, 6.37408],
[1935360, 11, 3, 1, 1, 4.9735],
[1944000, 6, 5, 3, 0, 4.57312],
[1944810, 1, 4, 1, 4, 6.71517],
[1953125, 0, 0, 9, 0, 6.4832],
[1959552, 7, 7, 0, 1, 4.38784],
[1960000, 6, 0, 4, 2, 4.63437],
[1966080, 17, 1, 1, 0, 4.89811],
[1968300, 2, 9, 2, 0, 4.97274],
[1968750, 1, 2, 6, 1, 7.18],
[1975680, 7, 2, 1, 3, 5.6913],
[1984500, 2, 4, 3, 2, 5.7031],
[1990656, 13, 5, 0, 0, 4.43955],
[2000000, 7, 0, 6, 0, 4.77072],
[2000376, 3, 6, 0, 3, 6.03978],
[2007040, 13, 0, 1, 2, 4.64397],
[2016000, 8, 2, 3, 1, 5.28429],
[2016840, 3, 1, 1, 5, 7.37168],
[2025000, 3, 4, 5, 0, 5.13194],
[2032128, 9, 4, 0, 2, 4.83926],
[2041200, 4, 6, 2, 1, 5.41594],
[2048000, 14, 0, 3, 0, 4.74554],
[2058000, 4, 1, 3, 3, 6.59965],
[2064384, 15, 2, 0, 1, 4.58582],
[2066715, 0, 10, 1, 1, 6.77258],
[2073600, 10, 4, 2, 0, 4.3023],
[2074464, 5, 3, 0, 4, 5.62384],
[2083725, 0, 5, 2, 3, 6.53571],
[2097152, 21, 0, 0, 0, 4.22941],
[2099520, 6, 8, 1, 0, 4.56861],
[2100000, 5, 1, 5, 1, 6.13136],
[2100875, 0, 0, 3, 5, 7.21318],
[2107392, 11, 1, 0, 3, 5.8911],
[2109375, 0, 3, 7, 0, 6.23792],
[2116800, 6, 3, 2, 2, 5.12387],
[2117682, 1, 2, 0, 6, 7.77533],
[2125764, 2, 12, 0, 0, 5.10426],
[2126250, 1, 5, 4, 1, 6.79965],
[2143260, 2, 7, 1, 2, 6.55267],
[2143750, 1, 0, 5, 3, 7.61523],
[2150400, 12, 1, 2, 1, 5.40403],
[2151296, 7, 0, 0, 5, 5.82262],
[2160000, 7, 3, 4, 0, 4.66557],
[2160900, 2, 2, 2, 4, 7.04973],
[2177280, 8, 5, 1, 1, 5.82077],
[2187000, 3, 7, 3, 0, 5.66237],
[2187500, 2, 0, 7, 1, 6.43357],
[2195200, 8, 0, 2, 3, 5.63651],
[2204496, 4, 9, 0, 1, 5.56275],
[2205000, 3, 2, 4, 2, 6.32813],
[2211840, 14, 3, 1, 0, 4.67894],
[2222640, 4, 4, 1, 3, 6.43034],
[2239488, 10, 7, 0, 0, 4.78166],
[2240000, 9, 0, 4, 1, 5.6096],
[2250000, 4, 2, 6, 0, 6.28339],
[2250423, 0, 8, 0, 3, 6.63466],
[2257920, 10, 2, 1, 2, 6.27491],
[2268000, 5, 4, 3, 1, 5.67382],
[2268945, 0, 3, 1, 5, 8.09846],
[2278125, 0, 6, 5, 0, 6.95722],
[2286144, 6, 6, 0, 2, 5.64474],
[2293760, 16, 0, 1, 1, 5.31997],
[2296350, 1, 8, 2, 1, 6.79021],
[2296875, 0, 1, 6, 2, 8.1255],
[2304000, 11, 2, 3, 0, 5.59085],
[2304960, 6, 1, 1, 4, 7.19046],
[2315250, 1, 3, 3, 3, 8.15574],
[2322432, 12, 4, 0, 1, 4.93053],
[2332800, 7, 6, 2, 0, 5.1839],
[2333772, 2, 5, 0, 4, 7.04992],
[2343750, 1, 1, 8, 0, 8.27942],
[2352000, 7, 1, 3, 2, 6.50234],
[2352980, 2, 0, 1, 6, 8.24141],
[2359296, 18, 2, 0, 0, 4.75053],
[2361960, 3, 10, 1, 0, 6.69482],
[2362500, 2, 3, 5, 1, 7.1991],
[2370816, 8, 3, 0, 3, 6.15194],
[2381400, 3, 5, 2, 2, 6.60586],
[2400000, 8, 1, 5, 0, 6.25152],
[2401000, 3, 0, 3, 4, 7.30787],
[2408448, 14, 1, 0, 2, 5.66275],
[2419200, 9, 3, 2, 1, 6.18883],
[2420208, 4, 2, 0, 5, 7.56102],
[2430000, 4, 5, 4, 0, 5.88064],
[2449440, 5, 7, 1, 1, 6.53949],
[2450000, 4, 0, 5, 2, 6.62784],
[2457600, 15, 1, 2, 0, 5.48598],
[2458624, 10, 0, 0, 4, 6.40966],
[2460375, 0, 9, 3, 0, 6.92842],
[2469600, 5, 2, 2, 3, 7.02608],
[2470629, 0, 1, 0, 7, 9.13888],
[2480058, 1, 11, 0, 1, 7.47939],
[2480625, 0, 4, 4, 2, 7.15245],
[2488320, 11, 5, 1, 0, 6.23414],
[2500000, 5, 0, 7, 0, 6.04698],
[2500470, 1, 6, 1, 3, 9.01949],
[2508800, 11, 0, 2, 2, 5.79558],
[2519424, 7, 9, 0, 0, 5.26093],
[2520000, 6, 2, 4, 1, 6.40736],
[2521050, 1, 1, 2, 5, 9.80301],
[2531250, 1, 4, 6, 0, 8.20269],
[2540160, 7, 4, 1, 2, 6.23674],
[2551500, 2, 6, 3, 1, 7.86944],
[2560000, 12, 0, 4, 0, 5.15107],
[2571912, 3, 8, 0, 2, 6.52307],
[2572500, 2, 1, 4, 3, 8.8105],
[2580480, 13, 2, 1, 1, 6.51354],
[2592000, 8, 4, 3, 0, 5.68579],
[2593080, 3, 3, 1, 4, 8.37398],
[2612736, 9, 6, 0, 1, 6.84278],
[2621440, 19, 0, 1, 0, 5.42173],
[2624400, 4, 8, 2, 0, 5.67296],
[2625000, 3, 1, 6, 1, 8.68093],
[2634240, 9, 1, 1, 3, 8.62333],
[2646000, 4, 3, 3, 2, 7.32374],
[2654208, 15, 4, 0, 0, 5.19194],
[2657205, 0, 12, 1, 0, 7.18438],
[2667168, 5, 5, 0, 3, 7.33779],
[2679075, 0, 7, 2, 2, 7.82682],
[2688000, 10, 1, 3, 1, 7.76474],
[2689120, 5, 0, 1, 5, 8.44304],
[2700000, 5, 3, 5, 0, 6.6888],
[2701125, 0, 2, 3, 4, 9.35744],
[2709504, 11, 3, 0, 2, 6.40835],
[2721600, 6, 5, 2, 1, 6.68947],
[2722734, 1, 4, 0, 5, 9.4664],
[2733750, 1, 7, 4, 0, 7.9849],
[2734375, 0, 0, 8, 1, 8.95741],
[2744000, 6, 0, 3, 3, 7.48266],
[2752512, 17, 1, 0, 1, 6.84179],
[2755620, 2, 9, 1, 1, 8.27824],
[2756250, 1, 2, 5, 2, 9.69613],
[2764800, 12, 3, 2, 0, 5.71149],
[2765952, 7, 2, 0, 4, 7.4551],
[2778300, 2, 4, 2, 3, 8.40406],
[2799360, 8, 7, 1, 0, 6.60371],
[2800000, 7, 0, 5, 1, 6.98998],
[2809856, 13, 0, 0, 3, 6.51395],
[2812500, 2, 2, 7, 0, 8.47373],
[2822400, 8, 2, 2, 2, 7.1456],
[2823576, 3, 1, 0, 6, 9.80346],
[2834352, 4, 11, 0, 0, 6.31606],
[2835000, 3, 4, 4, 1, 7.52013],
[2857680, 4, 6, 1, 2, 8.35571],
[2867200, 14, 0, 2, 1, 6.06317],
[2880000, 9, 2, 4, 0, 7.13373],
[2881200, 4, 1, 2, 4, 8.93392],
[2893401, 0, 10, 0, 2, 8.85302],
[2903040, 10, 4, 1, 1, 7.44589],
[2916000, 5, 6, 3, 0, 7.41462],
[2917215, 0, 5, 1, 4, 9.81875],
[2939328, 6, 8, 0, 1, 6.44877],
[2940000, 5, 1, 4, 2, 8.28266],
[2941225, 0, 0, 2, 6, 9.91958],
[2949120, 16, 2, 1, 0, 6.7393],
[2952450, 1, 10, 2, 0, 9.25946],
[2953125, 0, 3, 6, 1, 10.2424],
[2963520, 6, 3, 1, 3, 8.61766],
[2976750, 1, 5, 3, 2, 10.1792],
[2985984, 12, 6, 0, 0, 6.36253],
[3000000, 6, 1, 6, 0, 8.3999],
[3000564, 2, 7, 0, 3, 9.23418],
[3001250, 1, 0, 4, 4, 10.3139],
[3010560, 12, 1, 1, 2, 8.33072],
[3024000, 7, 3, 3, 1, 7.66691],
[3025260, 2, 2, 1, 5, 11.2563],
[3037500, 2, 5, 5, 0, 8.42726],
[3048192, 8, 5, 0, 2, 7.50339],
[3061800, 3, 7, 2, 1, 8.2977],
[3062500, 2, 0, 6, 2, 9.4288],
[3072000, 13, 1, 3, 0, 7.90634],
[3073280, 8, 0, 1, 4, 8.69283],
[3087000, 3, 2, 3, 3, 10.1054],
[3096576, 14, 3, 0, 1, 6.58787],
[3110400, 9, 5, 2, 0, 7.41347],
[3111696, 4, 4, 0, 4, 8.35837],
[3125000, 3, 0, 8, 0, 8.78509],
[3136000, 9, 0, 3, 2, 8.41571],
[3145728, 20, 1, 0, 0, 6.67482],
[3149280, 5, 9, 1, 0, 7.89142],
[3150000, 4, 2, 5, 1, 9.17494],
[3161088, 10, 2, 0, 3, 8.84458],
[3175200, 5, 4, 2, 2, 7.66282],
[3176523, 0, 3, 0, 6, 10.8394],
[3188646, 1, 13, 0, 0, 9.12778],
[3189375, 0, 6, 4, 1, 9.77613],
[3200000, 10, 0, 5, 0, 7.66819],
[3211264, 16, 0, 0, 2, 7.23805],
[3214890, 1, 8, 1, 2, 10.4008],
[3215625, 0, 1, 5, 3, 11.2719],
[3225600, 11, 2, 2, 1, 8.03517],
[3226944, 6, 1, 0, 5, 10.1594],
[3240000, 6, 4, 4, 0, 6.84442],
[3241350, 1, 3, 2, 4, 11.0223],
[3265920, 7, 6, 1, 1, 8.80682],
[3276800, 17, 0, 2, 0, 6.9712],
[3280500, 2, 8, 3, 0, 8.67613],
[3281250, 1, 1, 7, 1, 11.8061],
[3292800, 7, 1, 2, 3, 9.45267],
[3294172, 2, 0, 0, 7, 11.6646],
[3306744, 3, 10, 0, 1, 9.42256],
[3307500, 2, 3, 4, 2, 9.8847],
[3317760, 13, 4, 1, 0, 7.02765],
[3333960, 3, 5, 1, 3, 10.9256],
[3359232, 9, 8, 0, 0, 7.20221],
[3360000, 8, 1, 4, 1, 9.14906],
[3361400, 3, 0, 2, 5, 10.6898],
[3375000, 3, 3, 6, 0, 9.70285],
[3386880, 9, 3, 1, 2, 9.61677],
[3402000, 4, 5, 3, 1, 9.56717],
[3429216, 5, 7, 0, 2, 8.47267],
[3430000, 4, 0, 4, 3, 9.66822],
[3440640, 15, 1, 1, 1, 9.26349],
[3444525, 0, 9, 2, 1, 10.0415],
[3456000, 10, 3, 3, 0, 8.49674],
[3457440, 5, 2, 1, 4, 10.7735],
[3472875, 0, 4, 3, 3, 11.6306],
[3483648, 11, 5, 0, 1, 8.73779],
[3499200, 6, 7, 2, 0, 7.62029],
[3500000, 5, 0, 6, 1, 9.87718],
[3500658, 1, 6, 0, 4, 12.0088],
[3512320, 11, 0, 1, 3, 9.84621],
[3515625, 0, 2, 8, 0, 11.4732],
[3528000, 6, 2, 3, 2, 9.59725],
[3529470, 1, 1, 1, 6, 14.2873],
[3538944, 17, 3, 0, 0, 7.33242],
[3542940, 2, 11, 1, 0, 10.0806],
[3543750, 1, 4, 5, 1, 11.7079],
[3556224, 7, 4, 0, 3, 8.76067],
[3572100, 2, 6, 2, 2, 10.8874],
[3584000, 12, 0, 3, 1, 9.30179],
[3600000, 7, 2, 5, 0, 8.85488],
[3601500, 2, 1, 3, 4, 12.7681],
[3612672, 13, 2, 0, 2, 8.3703],
[3628800, 8, 4, 2, 1, 8.37018],
[3630312, 3, 3, 0, 5, 11.8204],
[3645000, 3, 6, 4, 0, 9.79264],
[3670016, 19, 0, 0, 1, 7.48768],
[3674160, 4, 8, 1, 1, 9.70912],
[3675000, 3, 1, 5, 2, 11.8965],
[3686400, 14, 2, 2, 0, 7.74323],
[3687936, 9, 1, 0, 4, 11.3761],
[3704400, 4, 3, 2, 3, 10.666],
[3720087, 0, 12, 0, 1, 10.1923],
[3732480, 10, 6, 1, 0, 9.69795],
[3750000, 4, 1, 7, 0, 10.7772],
[3750705, 0, 7, 1, 3, 12.6305],
[3763200, 10, 1, 2, 2, 10.4671],
[3764768, 5, 0, 0, 6, 11.1028],
[3779136, 6, 10, 0, 0, 8.93568],
[3780000, 5, 3, 4, 1, 9.83162],
[3781575, 0, 2, 2, 5, 13.5384],
[3796875, 0, 5, 6, 0, 12.4566],
[3810240, 6, 5, 1, 2, 10.4146],
[3827250, 1, 7, 3, 1, 12.8223],
[3828125, 0, 0, 7, 2, 12.1517],
[3840000, 11, 1, 4, 0, 9.5017],
[3841600, 6, 0, 2, 4, 10.1239],
[3857868, 2, 9, 0, 2, 10.8386],
[3858750, 1, 2, 4, 3, 13.8735],
[3870720, 12, 3, 1, 1, 9.8944],
[3888000, 7, 5, 3, 0, 9.19619],
[3889620, 2, 4, 1, 4, 12.7981],
[3906250, 1, 0, 9, 0, 14.0904],
[3919104, 8, 7, 0, 1, 9.27645],
[3920000, 7, 0, 4, 2, 9.3936],
[3932160, 18, 1, 1, 0, 9.82138],
[3936600, 3, 9, 2, 0, 10.0124],
[3937500, 2, 2, 6, 1, 13.269],
[3951360, 8, 2, 1, 3, 11.8835],
[3969000, 3, 4, 3, 2, 11.1973],
[3981312, 14, 5, 0, 0, 10.2103],
[4000000, 8, 0, 6, 0, 10.0693],
[4000752, 4, 6, 0, 3, 11.7675],
[4014080, 14, 0, 1, 2, 9.31926],
[4032000, 9, 2, 3, 1, 11.5656],
[4033680, 4, 1, 1, 5, 14.489],
[4050000, 4, 4, 5, 0, 10.0116],
[4064256, 10, 4, 0, 2, 9.65315],
[4082400, 5, 6, 2, 1, 10.8732],
[4084101, 0, 5, 0, 5, 13.9488],
[4096000, 15, 0, 3, 0, 10.1078],
[4100625, 0, 8, 4, 0, 10.8649],
[4116000, 5, 1, 3, 3, 13.2118],
[4117715, 0, 0, 1, 7, 15.1331],
[4128768, 16, 2, 0, 1, 9.54186],
[4133430, 1, 10, 1, 1, 14.8727],
[4134375, 0, 3, 5, 2, 13.4328],
[4147200, 11, 4, 2, 0, 8.54774],
[4148928, 6, 3, 0, 4, 11.1575],
[4167450, 1, 5, 2, 3, 14.5723],
[4194304, 22, 0, 0, 0, 8.43072],
[4199040, 7, 8, 1, 0, 9.25379],
[4200000, 6, 1, 5, 1, 12.2246],
[4201750, 1, 0, 3, 5, 15.9984],
[4214784, 12, 1, 0, 3, 11.669],
[4218750, 1, 3, 7, 0, 13.5852],
[4233600, 7, 3, 2, 2, 10.3137],
[4235364, 2, 2, 0, 6, 15.0643],
[4251528, 3, 12, 0, 0, 9.79616],
[4252500, 2, 5, 4, 1, 12.3989],
[4286520, 3, 7, 1, 2, 12.8274],
[4287500, 2, 0, 5, 3, 13.8622],
[4300800, 13, 1, 2, 1, 10.8526],
[4302592, 8, 0, 0, 5, 12.0937],
[4320000, 8, 3, 4, 0, 9.8057],
[4321800, 3, 2, 2, 4, 13.654],
[4354560, 9, 5, 1, 1, 12.5879],
[4374000, 4, 7, 3, 0, 11.0382],
[4375000, 3, 0, 7, 1, 12.8429],
[4390400, 9, 0, 2, 3, 12.3015],
[4408992, 5, 9, 0, 1, 11.1066],
[4410000, 4, 2, 4, 2, 12.3468],
[4423680, 15, 3, 1, 0, 9.87725],
[4428675, 0, 11, 2, 0, 11.9789],
[4445280, 5, 4, 1, 3, 12.868],
[4465125, 0, 6, 3, 2, 14.9455],
[4478976, 11, 7, 0, 0, 9.52774],
[4480000, 10, 0, 4, 1, 11.1675],
[4500000, 5, 2, 6, 0, 12.5529],
[4500846, 1, 8, 0, 3, 14.6271],
[4501875, 0, 1, 4, 4, 15.6611],
[4515840, 11, 2, 1, 2, 12.5315],
[4536000, 6, 4, 3, 1, 11.382],
[4537890, 1, 3, 1, 5, 17.4118],
[4556250, 1, 6, 5, 0, 14.8622],
[4572288, 7, 6, 0, 2, 11.4498],
[4587520, 17, 0, 1, 1, 11.5088],
[4592700, 2, 8, 2, 1, 12.8173],
[4593750, 1, 1, 6, 2, 17.5838],
[4608000, 12, 2, 3, 0, 11.8153],
[4609920, 7, 1, 1, 4, 14.4584],
[4630500, 2, 3, 3, 3, 15.4374],
[4644864, 13, 4, 0, 1, 9.92214],
[4665600, 8, 6, 2, 0, 10.9424],
[4667544, 3, 5, 0, 4, 14.2431],
[4687500, 2, 1, 8, 0, 15.3932],
[4704000, 8, 1, 3, 2, 13.6419],
[4705960, 3, 0, 1, 6, 16.2928],
[4718592, 19, 2, 0, 0, 9.60227],
[4723920, 4, 10, 1, 0, 13.267],
[4725000, 3, 3, 5, 1, 14.2549],
[4741632, 9, 3, 0, 3, 13.5424],
[4762800, 4, 5, 2, 2, 12.9223],
[4782969, 0, 14, 0, 0, 13.614],
[4800000, 9, 1, 5, 0, 13.6645],
[4802000, 4, 0, 3, 4, 14.3677],
[4816896, 15, 1, 0, 2, 11.8919],
[4822335, 0, 9, 1, 2, 15.2343],
[4838400, 10, 3, 2, 1, 12.3385],
[4840416, 5, 2, 0, 5, 15.1756],
[4860000, 5, 5, 4, 0, 11.7367],
[4862025, 0, 4, 2, 4, 15.4091],
[4898880, 6, 7, 1, 1, 13.056],
[4900000, 5, 0, 5, 2, 13.2711],
[4915200, 16, 1, 2, 0, 11.9193],
[4917248, 11, 0, 0, 4, 12.7807],
[4920750, 1, 9, 3, 0, 15.7717],
[4921875, 0, 2, 7, 1, 16.5828],
[4939200, 6, 2, 2, 3, 14.0008],
[4941258, 1, 1, 0, 7, 20.2522],
[4960116, 2, 11, 0, 1, 14.1604],
[4961250, 1, 4, 4, 2, 15.75],
[4976640, 12, 5, 1, 0, 13.5955],
[5000000, 6, 0, 7, 0, 12.1487],
[5000940, 2, 6, 1, 3, 17.564],
[5017600, 12, 0, 2, 2, 11.4431],
[5038848, 8, 9, 0, 0, 11.2083],
[5040000, 7, 2, 4, 1, 12.9168],
[5042100, 2, 1, 2, 5, 18.7992],
[5062500, 2, 4, 6, 0, 14.7178],
[5080320, 8, 4, 1, 2, 13.1268],
[5103000, 3, 6, 3, 1, 15.6048],
[5120000, 13, 0, 4, 0, 10.3779],
[5143824, 4, 8, 0, 2, 12.6346],
[5145000, 3, 1, 4, 3, 17.2575],
[5160960, 14, 2, 1, 1, 13.1136],
[5184000, 9, 4, 3, 0, 12.6236],
[5186160, 4, 3, 1, 4, 16.3791],
[5225472, 10, 6, 0, 1, 13.6665],
[5242880, 20, 0, 1, 0, 11.2489],
[5248800, 5, 8, 2, 0, 11.3941],
[5250000, 4, 1, 6, 1, 17.1832],
[5250987, 0, 7, 0, 4, 16.858],
[5268480, 10, 1, 1, 3, 17.2651],
[5292000, 5, 3, 3, 2, 14.6905],
[5294205, 0, 2, 1, 6, 19.7144],
[5308416, 16, 4, 0, 0, 11.9914],
[5314410, 1, 12, 1, 0, 16.0386],
[5315625, 0, 5, 5, 1, 17.2345],
[5334336, 6, 5, 0, 3, 14.6284],
[5358150, 1, 7, 2, 2, 17.2949],
[5359375, 0, 0, 6, 3, 19.1641],
[5376000, 11, 1, 3, 1, 15.7433],
[5378240, 6, 0, 1, 5, 16.8123],
[5400000, 6, 3, 5, 0, 13.3395],
[5402250, 1, 2, 3, 4, 20.5593],
[5419008, 12, 3, 0, 2, 12.6565],
[5443200, 7, 5, 2, 1, 13.498],
[5445468, 2, 4, 0, 5, 18.0796],
[5467500, 2, 7, 4, 0, 15.0881],
[5468750, 1, 0, 8, 1, 20.0786],
[5488000, 7, 0, 3, 3, 15.234],
[5505024, 18, 1, 0, 1, 13.7527],
[5511240, 3, 9, 1, 1, 16.6214],
[5512500, 2, 2, 5, 2, 18.287],
[5529600, 13, 3, 2, 0, 11.5075],
[5531904, 8, 2, 0, 4, 15.6155],
[5556600, 3, 4, 2, 3, 16.4059],
[5598720, 9, 7, 1, 0, 14.5964],
[5600000, 8, 0, 5, 1, 14.7295],
[5619712, 14, 0, 0, 3, 13.2019],
[5625000, 3, 2, 7, 0, 16.5908],
[5644800, 9, 2, 2, 2, 15.6638],
[5647152, 4, 1, 0, 6, 19.2406],
[5668704, 5, 11, 0, 0, 12.6697],
[5670000, 4, 4, 4, 1, 14.6397],
[5715360, 5, 6, 1, 2, 16.8212],
[5734400, 15, 0, 2, 1, 12.8713],
[5740875, 0, 8, 3, 1, 17.9847],
[5760000, 10, 2, 4, 0, 14.2405],
[5762400, 5, 1, 2, 4, 17.9624],
[5764801, 0, 0, 0, 8, 21.3506],
[5786802, 1, 10, 0, 2, 19.8319],
[5788125, 0, 3, 4, 3, 19.2912],
[5806080, 11, 4, 1, 1, 14.8176],
[5832000, 6, 6, 3, 0, 14.8451],
[5834430, 1, 5, 1, 4, 21.9547],
[5859375, 0, 1, 9, 0, 21.1541],
[5878656, 7, 8, 0, 1, 13.0769],
[5880000, 6, 1, 4, 2, 16.532],
[5882450, 1, 0, 2, 6, 21.7553],
[5898240, 17, 2, 1, 0, 14.5382],
[5904900, 2, 10, 2, 0, 16.4274],
[5906250, 1, 3, 6, 1, 21.5726],
[5927040, 7, 3, 1, 3, 17.5119],
[5953500, 2, 5, 3, 2, 18.2114],
[5971968, 13, 6, 0, 0, 12.971],
[6000000, 7, 1, 6, 0, 16.8718],
[6001128, 3, 7, 0, 3, 18.1043],
[6002500, 2, 0, 4, 4, 19.5111],
[6021120, 13, 1, 1, 2, 16.7469],
[6048000, 8, 3, 3, 1, 16.1748],
[6050520, 3, 2, 1, 5, 22.1156],
[6075000, 3, 5, 5, 0, 17.0911],
[6096384, 9, 5, 0, 2, 16.3736],
[6123600, 4, 7, 2, 1, 16.1739],
[6125000, 3, 0, 6, 2, 18.9867],
[6144000, 14, 1, 3, 0, 17.1476],
[6146560, 9, 0, 1, 4, 18.9854],
[6174000, 4, 2, 3, 3, 19.79],
[6193152, 15, 3, 0, 1, 14.0185],
[6200145, 0, 11, 1, 1, 19.5937],
[6220800, 10, 5, 2, 0, 15.1014],
[6223392, 5, 4, 0, 4, 16.742],
[6250000, 4, 0, 8, 0, 17.3484],
[6251175, 0, 6, 2, 3, 21.0156],
[6272000, 10, 0, 3, 2, 16.9272],
[6291456, 21, 1, 0, 0, 15.7291],
[6298560, 6, 9, 1, 0, 15.7422],
[6300000, 5, 2, 5, 1, 18.3778],
[6302625, 0, 1, 3, 5, 23.8994],
[6322176, 11, 2, 0, 3, 17.6407],
[6328125, 0, 4, 7, 0, 19.3691],
[6350400, 6, 4, 2, 2, 15.2941],
[6353046, 1, 3, 0, 6, 23.3314],
[6377292, 2, 13, 0, 0, 16.5339],
[6378750, 1, 6, 4, 1, 21.2589],
[6400000, 11, 0, 5, 0, 15.5825],
[6422528, 17, 0, 0, 2, 15.5618],
[6429780, 2, 8, 1, 2, 19.8161],
[6431250, 1, 1, 5, 3, 25.1026],
[6451200, 12, 2, 2, 1, 16.0292],
[6453888, 7, 1, 0, 5, 20.5149],
[6480000, 7, 4, 4, 0, 13.8726],
[6482700, 2, 3, 2, 4, 21.3675],
[6531840, 8, 6, 1, 1, 18.4664],
[6553600, 18, 0, 2, 0, 13.9588],
[6561000, 3, 8, 3, 0, 16.9924],
[6562500, 2, 1, 7, 1, 22.614],
[6585600, 8, 1, 2, 3, 19.819],
[6588344, 3, 0, 0, 7, 23.023],
[6613488, 4, 10, 0, 1, 18.6663],
[6615000, 3, 3, 4, 2, 19.3855],
[6635520, 14, 4, 1, 0, 14.9667],
[6667920, 4, 5, 1, 3, 21.5419],
[6718464, 10, 8, 0, 0, 14.4053],
[6720000, 9, 1, 4, 1, 19.9709],
[6722800, 4, 0, 2, 5, 20.9469],
[6750000, 4, 3, 6, 0, 19.1538],
[6751269, 0, 9, 0, 3, 21.6657],
[6773760, 10, 3, 1, 2, 19.2277],
[6804000, 5, 5, 3, 1, 19.0909],
[6806835, 0, 4, 1, 5, 24.6768],
[6834375, 0, 7, 5, 0, 20.79],
[6858432, 6, 7, 0, 2, 16.9715],
[6860000, 5, 0, 4, 3, 19.3809],
[6881280, 16, 1, 1, 1, 19.1423],
[6889050, 1, 9, 2, 1, 22.5203],
[6890625, 0, 2, 6, 2, 24.561],
[6912000, 11, 3, 3, 0, 17.3241],
[6914880, 6, 2, 1, 4, 21.503],
[6945750, 1, 4, 3, 3, 25.0084],
[6967296, 12, 5, 0, 1, 19.1726],
[6998400, 7, 7, 2, 0, 15.4125],
[7000000, 6, 0, 6, 1, 19.6882],
[7001316, 2, 6, 0, 4, 23.3009],
[7024640, 12, 0, 1, 3, 19.4782],
[7031250, 1, 2, 8, 0, 25.6055],
[7056000, 7, 2, 3, 2, 19.3792],
[7058940, 2, 1, 1, 6, 28.1096],
[7077888, 18, 3, 0, 0, 14.7314],
[7085880, 3, 11, 1, 0, 19.6427],
[7087500, 2, 4, 5, 1, 21.6441],
[7112448, 8, 4, 0, 3, 18.5072],
[7144200, 3, 6, 2, 2, 21.3672],
[7168000, 13, 0, 3, 1, 18.5396],
[7200000, 8, 2, 5, 0, 18.5713],
[7203000, 3, 1, 3, 4, 25.421],
[7225344, 14, 2, 0, 2, 16.8964],
[7257600, 9, 4, 2, 1, 18.6249],
[7260624, 4, 3, 0, 5, 23.0966],
[7290000, 4, 6, 4, 0, 19.0828],
[7340032, 20, 0, 0, 1, 15.6188],
[7348320, 5, 8, 1, 1, 19.5004],
[7350000, 4, 1, 5, 2, 23.3534],
[7372800, 15, 2, 2, 0, 16.2988],
[7375872, 10, 1, 0, 4, 22.7221],
[7381125, 0, 10, 3, 0, 24.3076],
[7408800, 5, 3, 2, 3, 21.4507],
[7411887, 0, 2, 0, 7, 28.0701],
[7440174, 1, 12, 0, 1, 22.5729],
[7441875, 0, 5, 4, 2, 23.3703],
[7464960, 11, 6, 1, 0, 19.3943],
[7500000, 5, 1, 7, 0, 21.634],
[7501410, 1, 7, 1, 3, 27.6552],
[7503125, 0, 0, 5, 4, 26.0661],
[7526400, 11, 1, 2, 2, 20.8854],
[7529536, 6, 0, 0, 6, 22.153],
[7558272, 7, 10, 0, 0, 18.0857],
[7560000, 6, 3, 4, 1, 19.6511],
[7563150, 1, 2, 2, 5, 29.4575],
[7593750, 1, 5, 6, 0, 27.0084],
[7620480, 7, 5, 1, 2, 21.0763],
[7654500, 2, 7, 3, 1, 23.7918],
[7656250, 1, 0, 7, 2, 27.1514],
[7680000, 12, 1, 4, 0, 19.069],
[7683200, 7, 0, 2, 4, 20.5499],
[7715736, 3, 9, 0, 2, 21.902],
[7717500, 2, 2, 4, 3, 26.6196],
[7741440, 13, 3, 1, 1, 20.0735],
[7776000, 8, 5, 3, 0, 19.6432],
[7779240, 3, 4, 1, 4, 25.0938],
[7812500, 2, 0, 9, 0, 24.5237],
[7838208, 9, 7, 0, 1, 20.5854],
[7840000, 8, 0, 4, 2, 19.8058],
[7864320, 19, 1, 1, 0, 19.7581],
[7873200, 4, 9, 2, 0, 19.583],
[7875000, 3, 2, 6, 1, 26.233],
[7902720, 9, 2, 1, 3, 25.8356],
[7938000, 4, 4, 3, 2, 22.0025],
[7962624, 15, 5, 0, 0, 21.8659],
[7971615, 0, 13, 1, 0, 23.4199],
[8000000, 9, 0, 6, 0, 22.0011],
[8001504, 5, 6, 0, 3, 23.6534],
[8028160, 15, 0, 1, 2, 19.6705],
[8037225, 0, 8, 2, 2, 23.76],
[8064000, 10, 2, 3, 1, 23.279],
[8067360, 5, 1, 1, 5, 29.0941],
[8100000, 5, 4, 5, 0, 20.0103],
[8103375, 0, 3, 3, 4, 28.7766],
[8128512, 11, 4, 0, 2, 19.242],
[8164800, 6, 6, 2, 1, 21.6946],
[8168202, 1, 5, 0, 5, 30.9186],
[8192000, 16, 0, 3, 0, 23.9381],
[8201250, 1, 8, 4, 0, 24.183],
[8203125, 0, 1, 8, 1, 30.6303],
[8232000, 6, 1, 3, 3, 26.3667],
[8235430, 1, 0, 1, 7, 33.6397],
[8257536, 17, 2, 0, 1, 20.4696],
[8266860, 2, 10, 1, 1, 26.8346],
[8268750, 1, 3, 5, 2, 29.0819],
[8294400, 12, 4, 2, 0, 17.4199],
[8297856, 7, 3, 0, 4, 22.61],
[8334900, 2, 5, 2, 3, 27.113],
[8388608, 23, 0, 0, 0, 16.8528],
[8398080, 8, 8, 1, 0, 19.6904],
[8400000, 7, 1, 5, 1, 24.6334],
[8403500, 2, 0, 3, 5, 29.5985],
[8429568, 13, 1, 0, 3, 23.5547],
[8437500, 2, 3, 7, 0, 25.5434],
[8467200, 8, 3, 2, 2, 21.734],
[8470728, 3, 2, 0, 6, 29.4173],
[8503056, 4, 12, 0, 0, 18.8457],
[8505000, 3, 5, 4, 1, 25.1658],
[8573040, 4, 7, 1, 2, 25.0764],
[8575000, 3, 0, 5, 3, 27.7504],
[8601600, 14, 1, 2, 1, 22.2381],
[8605184, 9, 0, 0, 5, 26.5756],
[8640000, 9, 3, 4, 0, 21.8341],
[8643600, 4, 2, 2, 4, 26.7111],
[8680203, 0, 11, 0, 2, 26.0915],
[8709120, 10, 5, 1, 1, 25.5533],
[8748000, 5, 7, 3, 0, 22.4791],
[8750000, 4, 0, 7, 1, 25.2778],
[8751645, 0, 6, 1, 4, 31.6318],
[8780800, 10, 0, 2, 3, 24.5712],
[8817984, 6, 9, 0, 1, 22.2453],
[8820000, 5, 2, 4, 2, 24.7991],
[8823675, 0, 1, 2, 6, 33.2565],
[8847360, 16, 3, 1, 0, 20.9543],
[8857350, 1, 11, 2, 0, 26.6772],
[8859375, 0, 4, 6, 1, 30.5567],
[8890560, 6, 4, 1, 3, 25.7703],
[8930250, 1, 6, 3, 2, 31.8759],
[8957952, 12, 7, 0, 0, 19.4119],
[8960000, 11, 0, 4, 1, 22.307],
[9000000, 6, 2, 6, 0, 25.394],
[9001692, 2, 8, 0, 3, 27.9377],
[9003750, 1, 1, 4, 4, 35.1365],
[9031680, 12, 2, 1, 2, 24.83],
[9072000, 7, 4, 3, 1, 22.9636],
[9075780, 2, 3, 1, 5, 34.1216],
[9112500, 2, 6, 5, 0, 28.0062],
[9144576, 8, 6, 0, 2, 24.1841],
[9175040, 18, 0, 1, 1, 23.2175],
[9185400, 3, 8, 2, 1, 25.0048],
[9187500, 2, 1, 6, 2, 32.9428],
[9216000, 13, 2, 3, 0, 23.9052],
[9219840, 8, 1, 1, 4, 30.2537],
[9261000, 3, 3, 3, 3, 30.6697],
[9289728, 14, 4, 0, 1, 21.2122],
[9331200, 9, 6, 2, 0, 24.2426],
[9335088, 4, 5, 0, 4, 28.0774],
[9375000, 3, 1, 8, 0, 30.8311],
[9408000, 9, 1, 3, 2, 29.6678],
[9411920, 4, 0, 1, 6, 31.9982],
[9437184, 20, 2, 0, 0, 20.1543],
[9447840, 5, 10, 1, 0, 26.6009],
[9450000, 4, 3, 5, 1, 27.9534],
[9483264, 10, 3, 0, 3, 27.078],
[9525600, 5, 5, 2, 2, 25.9155],
[9529569, 0, 4, 0, 6, 33.013],
[9565938, 1, 14, 0, 0, 30.8028],
[9568125, 0, 7, 4, 1, 29.7648],
[9600000, 10, 1, 5, 0, 27.4797],
[9604000, 5, 0, 3, 4, 28.7858],
[9633792, 16, 1, 0, 2, 26.3533],
[9644670, 1, 9, 1, 2, 34.2707],
[9646875, 0, 2, 5, 3, 35.3857],
[9676800, 11, 3, 2, 1, 24.6522],
[9680832, 6, 2, 0, 5, 30.3152],
[9720000, 6, 5, 4, 0, 23.5056],
[9724050, 1, 4, 2, 4, 33.7934],
[9765625, 0, 0, 10, 0, 32.1253],
[9797760, 7, 7, 1, 1, 26.3584],
[9800000, 6, 0, 5, 2, 26.6116],
[9830400, 17, 1, 2, 0, 25.5513],
[9834496, 12, 0, 0, 4, 25.0081],
[9841500, 2, 9, 3, 0, 28.4763],
[9843750, 1, 2, 7, 1, 36.5723],
[9878400, 7, 2, 2, 3, 28.2355],
[9882516, 2, 1, 0, 7, 39.693],
[9920232, 3, 11, 0, 1, 27.6579],
[9922500, 2, 4, 4, 2, 29.9309],
[9953280, 13, 5, 1, 0, 26.7729],
[10000000, 7, 0, 7, 0, 24.5461],
[10001880, 3, 6, 1, 3, 34.7747],
[10035200, 13, 0, 2, 2, 23.0579],
[10077696, 9, 9, 0, 0, 24.7336],
[10080000, 8, 2, 4, 1, 27.303],
[10084200, 3, 1, 2, 5, 36.9996],
[10125000, 3, 4, 6, 0, 29.7806],
[10160640, 9, 4, 1, 2, 28.9428],
[10206000, 4, 6, 3, 1, 30.7749],
[10240000, 14, 0, 4, 0, 21.7403],
[10287648, 5, 8, 0, 2, 25.4201],
[10290000, 4, 1, 4, 3, 33.8313],
[10321920, 15, 2, 1, 1, 27.6406],
[10333575, 0, 10, 2, 1, 33.5788],
[10368000, 10, 4, 3, 0, 26.2262],
[10372320, 5, 3, 1, 4, 32.9228],
[10418625, 0, 5, 3, 3, 36.8096],
[10450944, 11, 6, 0, 1, 27.3702],
[10485760, 21, 0, 1, 0, 26.3614],
[10497600, 6, 8, 2, 0, 22.714],
[10500000, 5, 1, 6, 1, 34.423],
[10501974, 1, 7, 0, 4, 36.9656],
[10504375, 0, 0, 4, 5, 37.8089],
[10536960, 11, 1, 1, 3, 34.6491],
[10546875, 0, 3, 8, 0, 36.5675],
[10584000, 6, 3, 3, 2, 29.3069],
[10588410, 1, 2, 1, 6, 43.6987],
[10616832, 17, 4, 0, 0, 26.1758],
[10628820, 2, 12, 1, 0, 30.6068],
[10631250, 1, 5, 5, 1, 38.4748],
[10668672, 7, 5, 0, 3, 29.6803],
[10716300, 2, 7, 2, 2, 32.9304],
[10718750, 1, 0, 6, 3, 42.7113],
[10752000, 12, 1, 3, 1, 33.0148],
[10756480, 7, 0, 1, 5, 34.0952],
[10800000, 7, 3, 5, 0, 27.0182],
[10804500, 2, 2, 3, 4, 39.2061],
[10838016, 13, 3, 0, 2, 25.6464],
[10886400, 8, 5, 2, 1, 28.7726],
[10890936, 3, 4, 0, 5, 35.517],
[10935000, 3, 7, 4, 0, 29.529],
[10937500, 2, 0, 8, 1, 35.832],
[10976000, 8, 0, 3, 3, 32.125],
[11010048, 19, 1, 0, 1, 27.7882],
[11022480, 4, 9, 1, 1, 32.7676],
[11025000, 3, 2, 5, 2, 35.9125],
[11059200, 14, 3, 2, 0, 23.7142],
[11063808, 9, 2, 0, 4, 34.1226],
[11113200, 4, 4, 2, 3, 32.0187],
[11160261, 0, 13, 0, 1, 33.6227],
[11197440, 10, 7, 1, 0, 29.2316],
[11200000, 9, 0, 5, 1, 32.1101],
[11239424, 15, 0, 0, 3, 27.7552],
[11250000, 4, 2, 7, 0, 32.4472],
[11252115, 0, 8, 1, 3, 38.5751],
[11289600, 10, 2, 2, 2, 31.3556],
[11294304, 5, 1, 0, 6, 38.7265],
[11337408, 6, 11, 0, 0, 25.4379],
[11340000, 5, 4, 4, 1, 29.4072],
[11344725, 0, 3, 2, 5, 41.2055],
[11390625, 0, 6, 6, 0, 39.994],
[11430720, 6, 6, 1, 2, 33.6996],
[11468800, 16, 0, 2, 1, 27.945],
[11481750, 1, 8, 3, 1, 38.8558],
[11484375, 0, 1, 7, 2, 40.4568],
[11520000, 11, 2, 4, 0, 28.4212],
[11524800, 6, 1, 2, 4, 35.9288],
[11529602, 1, 0, 0, 8, 45.7928],
[11573604, 2, 10, 0, 2, 35.6782],
[11576250, 1, 3, 4, 3, 41.5794],
[11612160, 12, 4, 1, 1, 30.0748],
[11664000, 7, 6, 3, 0, 31.2275],
[11668860, 2, 5, 1, 4, 40.7852],
[11718750, 1, 1, 9, 0, 47.4092],
[11757312, 8, 8, 0, 1, 27.8622],
[11760000, 7, 1, 4, 2, 33.4364],
[11764900, 2, 0, 2, 6, 41.988],
[11796480, 18, 2, 1, 0, 29.3189],
[11809800, 3, 10, 2, 0, 33.3884],
[11812500, 2, 3, 6, 1, 40.0374],
[11854080, 8, 3, 1, 3, 36.4377],
[11907000, 3, 5, 3, 2, 37.1471],
[11943936, 14, 6, 0, 0, 26.1235],
[12000000, 8, 1, 6, 0, 37.3515],
[12002256, 4, 7, 0, 3, 35.2991],
[12005000, 3, 0, 4, 4, 37.987],
[12042240, 14, 1, 1, 2, 33.9196],
[12096000, 9, 3, 3, 1, 35.3401],
[12101040, 4, 2, 1, 5, 43.5083],
[12150000, 4, 5, 5, 0, 33.8386],
[12192768, 10, 5, 0, 2, 33.3677],
[12247200, 5, 7, 2, 1, 32.5341],
[12250000, 4, 0, 6, 2, 37.6786],
[12252303, 0, 6, 0, 5, 44.7461],
[12288000, 15, 1, 3, 0, 36.669],
[12293120, 10, 0, 1, 4, 38.0195],
[12301875, 0, 9, 4, 0, 35.9696],
[12348000, 5, 2, 3, 3, 39.6043],
[12353145, 0, 1, 1, 7, 50.8982],
[12386304, 16, 3, 0, 1, 29.6818],
[12400290, 1, 11, 1, 1, 43.2799],
[12403125, 0, 4, 5, 2, 41.7068],
[12441600, 11, 5, 2, 0, 30.9736],
[12446784, 6, 4, 0, 4, 33.4346],
[12500000, 5, 0, 8, 0, 35.0207],
[12502350, 1, 6, 2, 3, 45.4234],
[12544000, 11, 0, 3, 2, 34.3673],
[12582912, 22, 1, 0, 0, 31.4955],
[12597120, 7, 9, 1, 0, 31.9349],
[12600000, 6, 2, 5, 1, 36.7906],
[12605250, 1, 1, 3, 5, 52.6532],
[12644352, 12, 2, 0, 3, 34.9828],
[12656250, 1, 4, 7, 0, 41.8454],
[12700800, 7, 4, 2, 2, 30.929],
[12706092, 2, 3, 0, 6, 45.6148],
[12754584, 3, 13, 0, 0, 33.2774],
[12757500, 2, 6, 4, 1, 41.1994],
[12800000, 12, 0, 5, 0, 33.1204],
[12845056, 18, 0, 0, 2, 31.1639],
[12859560, 3, 8, 1, 2, 38.802],
[12862500, 2, 1, 5, 3, 48.2636],
[12902400, 13, 2, 2, 1, 32.5118],
[12907776, 8, 1, 0, 5, 42.5046],
[12960000, 8, 4, 4, 0, 29.5243],
[12965400, 3, 3, 2, 4, 41.8672],
[13063680, 9, 6, 1, 1, 40.387],
[13107200, 19, 0, 2, 0, 28.1598],
[13122000, 4, 8, 3, 0, 35.9404],
[13125000, 3, 1, 7, 1, 45.006],
[13171200, 9, 1, 2, 3, 43.1652],
[13176688, 4, 0, 0, 7, 45.0879],
[13226976, 5, 10, 0, 1, 37.4985],
[13230000, 4, 3, 4, 2, 37.8501],
[13271040, 15, 4, 1, 0, 31.8918],
[13286025, 0, 12, 2, 0, 36.5085],
[13335840, 5, 5, 1, 3, 43.3129],
[13395375, 0, 7, 3, 2, 44.8695],
[13436928, 11, 8, 0, 0, 28.6302],
[13440000, 10, 1, 4, 1, 39.9452],
[13445600, 5, 0, 2, 5, 42.1771],
[13500000, 5, 3, 6, 0, 41.2349],
[13502538, 1, 9, 0, 3, 48.24],
[13505625, 0, 2, 4, 4, 48.5494],
[13547520, 11, 3, 1, 2, 38.5567],
[13608000, 6, 5, 3, 1, 38.4649],
[13613670, 1, 4, 1, 5, 53.7857],
[13668750, 1, 7, 5, 0, 45.8089],
[13671875, 0, 0, 9, 1, 52.3273],
[13716864, 7, 7, 0, 2, 34.3601],
[13720000, 6, 0, 4, 3, 38.837],
[13762560, 17, 1, 1, 1, 41.1668],
[13778100, 2, 9, 2, 1, 41.3417],
[13781250, 1, 2, 6, 2, 54.387],
[13824000, 12, 3, 3, 0, 38.0841],
[13829760, 7, 2, 1, 4, 43.4268],
[13891500, 2, 4, 3, 3, 46.6643],
[13934592, 13, 5, 0, 1, 37.8399],
[13996800, 8, 7, 2, 0, 32.8037],
[14000000, 7, 0, 6, 1, 39.8076],
[14002632, 3, 6, 0, 4, 46.1146],
[14049280, 13, 0, 1, 3, 39.4512],
[14062500, 2, 2, 8, 0, 47.4005],
[14112000, 8, 2, 3, 2, 40.6818],
[14117880, 3, 1, 1, 6, 55.7327],
[14155776, 19, 3, 0, 0, 29.8104],
[14171760, 4, 11, 1, 0, 38.2717],
[14175000, 3, 4, 5, 1, 42.7769],
[14224896, 9, 4, 0, 3, 40.865],
[14288400, 4, 6, 2, 2, 41.8106],
[14336000, 14, 0, 3, 1, 40.0674],
[14348907, 0, 15, 0, 0, 47.4364],
[14400000, 9, 2, 5, 0, 41.0235],
[14406000, 4, 1, 3, 4, 50.0652],
[14450688, 15, 2, 0, 2, 35.814],
[14467005, 0, 10, 1, 2, 51.881],
[14515200, 10, 4, 2, 1, 37.1627],
[14521248, 5, 3, 0, 5, 46.3896],
[14580000, 5, 6, 4, 0, 38.4502],
[14586075, 0, 5, 2, 4, 50.2062],
[14680064, 21, 0, 0, 1, 36.9548],
[14696640, 6, 8, 1, 1, 39.1838],
[14700000, 5, 1, 5, 2, 46.9222],
[14706125, 0, 0, 3, 6, 55.2063],
[14745600, 16, 2, 2, 0, 35.8823],
[14751744, 11, 1, 0, 4, 45.415],
[14762250, 1, 10, 3, 0, 56.9116],
[14765625, 0, 3, 7, 1, 50.9762],
[14817600, 6, 3, 2, 3, 42.8541],
[14823774, 1, 2, 0, 7, 61.7128],
[14880348, 2, 12, 0, 1, 42.9241],
[14883750, 1, 5, 4, 2, 52.046],
[14929920, 12, 6, 1, 0, 38.8437],
[15000000, 6, 1, 7, 0, 43.3151],
[15002820, 2, 7, 1, 3, 53.3598],
[15006250, 1, 0, 5, 4, 57.8303],
[15052800, 12, 1, 2, 2, 41.6566],
[15059072, 7, 0, 0, 6, 44.6117],
[15116544, 8, 10, 0, 0, 40.283],
[15120000, 7, 3, 4, 1, 39.672],
[15126300, 2, 2, 2, 5, 56.9337],
[15187500, 2, 5, 6, 0, 52.1969],
[15240960, 8, 5, 1, 2, 44.5694],
[15309000, 3, 7, 3, 1, 47.2527],
[15312500, 2, 0, 7, 2, 49.6102],
[15360000, 13, 1, 4, 0, 38.4902],
[15366400, 8, 0, 2, 4, 43.4233],
[15431472, 4, 9, 0, 2, 43.0862],
[15435000, 3, 2, 4, 3, 52.0223],
[15482880, 14, 3, 1, 1, 40.4335],
[15552000, 9, 5, 3, 0, 48.4129],
[15558480, 4, 4, 1, 4, 49.192],
[15625000, 3, 0, 9, 0, 55.1807],
[15676416, 10, 7, 0, 1, 41.1844],
[15680000, 9, 0, 4, 2, 43.5841],
[15728640, 20, 1, 1, 0, 41.122],
[15746400, 5, 9, 2, 0, 39.2364],
[15750000, 4, 2, 6, 1, 51.9864],
[15752961, 0, 8, 0, 4, 51.3956],
[15805440, 10, 2, 1, 3, 51.7659],
[15876000, 5, 4, 3, 2, 44.0922],
[15882615, 0, 3, 1, 6, 61.435],
[15925248, 16, 5, 0, 0, 53.8472],
[15943230, 1, 13, 1, 0, 53.3767],
[15946875, 0, 6, 5, 1, 56.5961],
[16000000, 10, 0, 6, 0, 50.7255],
[16003008, 6, 6, 0, 3, 47.3242],
[16056320, 16, 0, 1, 2, 43.7539],
[16074450, 1, 8, 2, 2, 52.4642],
[16078125, 0, 1, 6, 3, 64.9358],
[16128000, 11, 2, 3, 1, 47.392],
[16134720, 6, 1, 1, 5, 58.3303],
[16200000, 6, 4, 5, 0, 40.3433],
[16206750, 1, 3, 3, 4, 62.1358],
[16257024, 12, 4, 0, 2, 38.8061],
[16329600, 7, 6, 2, 1, 43.8952],
[16336404, 2, 5, 0, 5, 57.53],
[16384000, 17, 0, 3, 0, 51.8662],
[16402500, 2, 8, 4, 0, 45.9319],
[16406250, 1, 1, 8, 1, 66.1195],
[16464000, 7, 1, 3, 3, 53.3594],
[16470860, 2, 0, 1, 7, 66.0801],
[16515072, 18, 2, 0, 1, 41.2908],
[16533720, 3, 10, 1, 1, 54.8488],
[16537500, 2, 3, 5, 2, 55.4022],
[16588800, 13, 4, 2, 0, 35.2243],
[16595712, 8, 3, 0, 4, 47.6506],
[16669800, 3, 5, 2, 3, 55.0397],
|
""" This module is intended to allow deploying of arbitrary Azure Resource
Manager (ARM) templates and describe the provided DC/OS cluster. For more
information on how to configure and interpret these templates, see:
https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-group-authoring-templates
"""
import contextlib
import copy
import logging
import re
import requests
import retrying
from azure.common.credentials import ServicePrincipalCredentials
from azure.common.exceptions import CloudError
from azure.mgmt.network import NetworkManagementClient
from azure.mgmt.resource.resources.v2016_02_01 import ResourceManagementClient
from azure.mgmt.resource.resources.v2016_02_01.models import (DeploymentMode,
DeploymentProperties,
ResourceGroup)
from azure.monitor import MonitorClient
from ...dcos_launch.util import DeploymentError
from ...dcos_test_utils.helpers import Host
log = logging.getLogger(__name__)
# This interface is designed to only use a single deployment.
# Being as the azure interface is based around resource groups, deriving
# deployment name from group names makes it easier to attach to creating deploys
DEPLOYMENT_NAME = '{}-Deployment'
def validate_hostname_prefix(prefix):
"""Hostname prefixes in azure templates are used to link a variety of resources
Not all of these resources will have their constraints checked at when ARM
valiation occurs. This check in particular was aggravating as no docs surfaced
this issue, so logs needed to be scanned just to discover this error
"""
assert re.match('^[a-z][a-z0-9-]{1,61}[a-z0-9]$', prefix), 'Invalid DNS prefix: {}'.format(prefix)
def check_json_object(obj):
""" Simple check to fill in the map for automatic parameter casting
JSON objects must be represented as dict at this level
"""
assert isinstance(obj, dict), 'Invalid JSON object: {}'.format(obj)
return obj
def check_array(arr):
""" Simple check to fill in the map for automatic parameter casting
JSON arrays must be represented as lists at this level
"""
assert isinstance(arr, list), 'Invalid array: {}'.format(arr)
return arr
def nic_to_host(nic, public_ip=None):
assert len(nic.ip_configurations) == 1
ip_config = nic.ip_configurations[0]
if ip_config.public_ip_address is None and public_ip is None:
return Host(ip_config.private_ip_address, None)
if public_ip is None:
return Host(ip_config.private_ip_address, ip_config.public_ip_address.ip_address)
return Host(ip_config.private_ip_address, public_ip)
class AzureWrapper:
def __init__(self, location: str, subscription_id: str, client_id: str, client_secret: str, tenant_id: str):
self.credentials = ServicePrincipalCredentials(
client_id=client_id,
secret=client_secret,
tenant=tenant_id)
self.rmc = ResourceManagementClient(self.credentials, subscription_id)
self.nmc = NetworkManagementClient(self.credentials, subscription_id)
self.mc = MonitorClient(self.credentials, subscription_id)
# location is included to keep a similar model as dcos_launch.platforms.aws.BotoWrapper
self.location = location
def deploy_template_to_new_resource_group(
self, template_url, group_name, parameters, tags=None, template=None):
if tags is None:
tags = dict()
log.info('Checking deployment parameters vs template before starting...')
deployment_properties = self.create_deployment_properties(
template_url, parameters, template=template)
deployment_name = DEPLOYMENT_NAME.format(group_name)
# Resource group must be created before validation can occur
if self.rmc.resource_groups.check_existence(group_name):
raise Exception("Group name already exists / taken: {}".format(group_name))
log.info('Starting resource group_creation')
def get_all_details(error):
formatted_message = '{}: {}\n\n'.format(error.code, error.message)
if error.details is None:
return formatted_message
for d in error.details:
formatted_message += get_all_details(d)
return formatted_message
with contextlib.ExitStack() as stack:
self.rmc.resource_groups.create_or_update(
group_name,
ResourceGroup(location=self.location, tags=tags))
# Ensure the resource group will be deleted if the following steps fail
stack.callback(self.rmc.resource_groups.delete, group_name)
log.info('Resource group created: {}'.format(group_name))
log.info('Checking with Azure to validate template deployment')
result = self.rmc.deployments.validate(
group_name, deployment_name, properties=deployment_properties)
if result.error:
raise Exception("Template verification failed!\n{}".format(get_all_details(result.error)))
log.info('Template successfully validated')
log.info('Starting template deployment')
self.rmc.deployments.create_or_update(
group_name, deployment_name, deployment_properties, raw=True)
stack.pop_all()
log.info('Successfully started template deployment')
def create_deployment_properties(self, template_url, parameters, template: dict=None):
""" Pulls the targeted template, checks parameter specs and casts
user provided parameters to the appropriate type. Assertion is raised
if there are unused parameters or invalid casting
"""
user_parameters = copy.deepcopy(parameters)
type_cast_map = {
'string': str,
'securestring': str,
'int': int,
'bool': bool,
'object': check_json_object,
'secureObject': check_json_object,
'array': check_array}
log.debug('Pulling Azure template for parameter validation...')
if template is None:
r = requests.get(template_url)
r.raise_for_status()
template = r.json()
if 'parameters' not in template:
assert user_parameters is None, 'This template does not support parameters, ' \
'yet parameters were supplied: {}'.format(user_parameters)
log.debug('Constructing DeploymentProperties from user parameters: {}'.format(parameters))
template_parameters = {}
for k, v in template['parameters'].items():
if k in user_parameters:
# All templates parameters are required to have a type field.
# Azure requires that parameters be provided as {key: {'value': value}}.
template_parameters[k] = {
'value': type_cast_map[v['type']](user_parameters.pop(k))}
log.debug('Final template parameters: {}'.format(template_parameters))
if len(user_parameters) > 0:
raise Exception('Unrecognized template parameters were supplied: {}'.format(user_parameters))
return DeploymentProperties(
template=template,
mode=DeploymentMode.incremental,
parameters=template_parameters)
class DcosAzureResourceGroup:
""" An abstraction for cleanly handling the life cycle of a DC/OS template
deployment. Operations include: create, wait, describe host IPs, and delete
"""
def __init__(self, group_name, azure_wrapper):
self.group_name = group_name
self.azure_wrapper = azure_wrapper
@classmethod
def deploy_acs_template(
cls, azure_wrapper: AzureWrapper, template_url: str, group_name: str,
public_key, master_prefix, agent_prefix, admin_name, oauth_enabled,
vm_size, agent_count, name_suffix, vm_diagnostics_enabled):
""" Creates a new resource group and deploys a ACS DC/OS template to it
using a subset of parameters for a simple deployment. To see a full
listing of parameters, including description and formatting, go to:
gen/azure/templates/acs.json in this repository.
Args:
azure_wrapper: see above
template_url: Azure-accessible location for the desired ACS template
group_name: name used for the new resource group that will be created
for this template deployment
Args that wrap template parameters:
public_key -> sshRSAPublicKey
master_prefix -> masterEndpointDNSNamePrefix
agent_prefix -> agentEndpointDNSNamePrefix
admin_name -> linuxAdminUsername
vm_size -> agentVMSize
agent_count -> agentCount
name_suffix -> nameSuffix
oauth_enabled -> oauthEnabled
vm_diagnostics_enabled -> enableVMDiagnostics
"""
assert master_prefix != agent_prefix, 'Master and agents must have unique prefixs'
validate_hostname_prefix(master_prefix)
validate_hostname_prefix(agent_prefix)
parameters = {
'sshRSAPublicKey': public_key,
'masterEndpointDNSNamePrefix': master_prefix,
'agentEndpointDNSNamePrefix': agent_prefix,
'linuxAdminUsername': admin_name,
'agentVMSize': vm_size,
'agentCount': agent_count,
'nameSuffix': name_suffix,
'oauthEnabled': oauth_enabled,
'enableVMDiagnostics': vm_diagnostics_enabled}
azure_wrapper.deploy_template_to_new_resource_group(template_url, group_name, parameters)
return cls(group_name, azure_wrapper)
def get_deployment_state(self):
return self.azure_wrapper.rmc.deployments.get(
self.group_name, DEPLOYMENT_NAME.format(self.group_name)).properties.provisioning_state
def wait_for_deployment(self, timeout=60 * 60):
"""
Azure will not register a template instantly after deployment, so
CloudError must be expected as retried. Once the ops are retrieved, this
loops through all operations in the group's only deployment
if any operations are still in progress, then this function will sleep
once all operations are complete, if there any failures, those will be
printed to the log stream
"""
log.info('Waiting for deployment to finish')
def azure_failure_report():
deploy_ops = self.azure_wrapper.rmc.deployment_operations.list(
self.group_name, DEPLOYMENT_NAME.format(self.group_name))
failures = [(op.properties.status_code, op.properties.status_message) for op
in deploy_ops if op.properties.provisioning_state == 'Failed']
for failure in failures:
log.error('Deployment operation failed! {}: {}'.format(*failure))
@retrying.retry(
wait_fixed=60 * 1000, stop_max_delay=timeout * 1000,
retry_on_result=lambda res: res is False,
retry_on_exception=lambda ex: isinstance(ex, CloudError))
def check_deployment_operations():
deploy_state = self.get_deployment_state()
if deploy_state == 'Succeeded':
return True
elif deploy_state == 'Failed':
log.info('Deployment failed. Checking deployment operations.')
azure_failure_report()
raise DeploymentError('Azure Deployment Failed!')
else:
log.info('Waiting for deployment. Current state: {}. It should either be Succeeded/Failed.'.format(
deploy_state))
return False
try:
check_deployment_operations()
except retrying.RetryError:
log.info('Deployment failed. Checking deployment operations.')
azure_failure_report()
raise DeploymentError("Azure Deployment Failed!")
def list_resources(self, filter_string):
yield from self.azure_wrapper.rmc.resource_groups.list_resources(
self.group_name, filter=(filter_string))
def get_scale_set_nics(self, name_substring=None):
for resource in self.list_resources("resourceType eq 'Microsoft.Compute/virtualMachineScaleSets'"):
if name_substring and name_substring not in resource.name:
continue
yield from self.azure_wrapper.nmc.network_interfaces.list_virtual_machine_scale_set_network_interfaces(
self.group_name, resource.name)
def get_public_ip_address(self, name_substring=None):
for resource in self.list_resources("resourceType eq 'Microsoft.Network/publicIPAddresses'"):
if name_substring and name_substring not in resource.name:
continue
return self.azure_wrapper.nmc.public_ip_addresses.get(self.group_name, resource.name)
@property
def public_agent_lb_fqdn(self):
return self.get_public_ip_address('agent-ip').dns_settings.fqdn
@property
def public_master_lb_fqdn(self):
return self.get_public_ip_address('master-ip').dns_settings.fqdn
@property
def master_nics(self):
""" The only instances of networkInterface Resources are for masters
"""
for resource in self.list_resources("resourceType eq 'Microsoft.Network/networkInterfaces'"):
assert 'master' in resource.name, 'Expected to only find master NICs, not: {}'.format(resource.name)
yield self.azure_wrapper.nmc.network_interfaces.get(self.group_name, resource.name)
def get_master_ips(self):
""" Traffic from abroad is routed to a master wth the public master
loadbalancer FQDN and the VM index plus 2200 (so the first master will be at 2200)
"""
public_lb_ip = self.public_master_lb_fqdn
return [Host(nic_to_host(nic).private_ip, '{}:{}'.format(public_lb_ip, 2200 + int(nic.name[-1])))
for nic in self.master_nics]
def get_private_agent_ips(self):
return [nic_to_host(nic) for nic in self.get_scale_set_nics('private')]
def get_public_agent_ips(self):
""" public traffic is routed to public agents via a specific load balancer """
public_lb_ip = self.public_agent_lb_fqdn
return [Host(nic_to_host(nic).private_ip, public_lb_ip)
for nic in self.get_scale_set_nics('public')]
def update_tags(self, new_tags: dict):
rg = self.azure_wrapper.rmc.resource_groups.get(self.group_name)
if rg.tags is None:
rg.tags = dict()
rg.tags.update(new_tags)
self.azure_wrapper.rmc.resource_groups.patch(rg.name, {
'tags': rg.tags,
'location': rg.location}, raw=True)
def delete(self):
log.info('Triggering delete')
self.azure_wrapper.rmc.resource_groups.delete(self.group_name, raw=True)
def __enter__(self):
return self
def __exit__(self, exc_type, exc, exc_tb):
self.delete()
class HybridDcosAzureResourceGroup(DcosAzureResourceGroup):
@property
def master_nics(self):
master_nics = []
for resource in self.list_resources("resourceType eq 'Microsoft.Network/networkInterfaces'"):
if 'master' in resource.name:
master_nics.append(resource.name)
assert len(master_nics) > 0, 'Cannot find any master NICs into resource group {}'.format(self.group_name)
for name in master_nics:
yield self.azure_wrapper.nmc.network_interfaces.get(self.group_name, name)
def get_master_ips(self):
public_lb_ip = self.public_master_lb_fqdn
return [nic_to_host(nic, public_lb_ip) for nic in self.master_nics]
def get_linux_private_agent_ips(self):
return [nic_to_host(nic) for nic in self.get_scale_set_nics('linpri')]
def get_linux_public_agent_ips(self):
return [nic_to_host(nic, self.linux_public_agent_lb_fqdn)
for nic in self.get_scale_set_nics('linpub')]
def get_windows_public_agent_ips(self):
# this VMSS name is derived from this being the 0-th element in the VMSS list
return [nic_to_host(nic, self.windows_public_agent_lb_fqdn)
for nic in self.get_scale_set_nics('900-vmss')]
def get_windows_private_agent_ips(self):
# this VMSS name is derived from this being the 1-th element in the VMSS list
return [nic_to_host(nic) for nic in self.get_scale_set_nics('901-vmss')]
@property
def linux_public_agent_lb_fqdn(self):
return self.get_public_ip_address('agent-ip-linpub').dns_settings.fqdn
@property
def windows_public_agent_lb_fqdn(self):
return self.get_public_ip_address('agent-ip-wpub').dns_settings.fqdn
|
import logging
import requests
from ...models import Configuration
# pylint: disable=too-few-public-methods
class PushNotificationSender:
logger = logging.getLogger(__name__)
fcm_url = "https://fcm.googleapis.com/fcm/send"
"""
Sends push notifications via FCM legacy http api.
Returns boolean indicating success or failure
"""
# pylint: disable=too-many-arguments
def send(self, region_slug, channel, title, message, lan_code):
fcm_auth_config_key = "fcm_auth_key"
auth_key = Configuration.objects.filter(key=fcm_auth_config_key)
if auth_key.exists():
self.logger.info("Got fcm_auth_key from database")
else:
self.logger.info(
"Could not get %s from configuration database.", fcm_auth_config_key
)
return False
payload = {
"to": f"/topics/{region_slug}-{lan_code}-{channel}",
"notification": {"title": title, "body": message},
"data": {"lanCode": lan_code, "city": region_slug},
}
headers = {"Authorization": f"key={auth_key.first().value}"}
res = requests.post(self.fcm_url, json=payload, headers=headers)
if res.status_code == 200:
self.logger.info("Message sent, id: %s", res.json()["message_id"])
return True
self.logger.info(
"Received invalid response from FCM for push notification: %s, response body: %s",
res.status_code,
res.text,
)
return False
|
# Copyright (c) 2011, Found IT A/S and Piped Project Contributors.
# See LICENSE for details.
import socket
import mock
from twisted.trial import unittest
from twisted.internet import defer, reactor
from twisted.application import service
from twisted.python import reflect, log
from twisted.spread import pb, flavors
from twisted.cred import credentials, error
from piped import processing, dependencies, util, exceptions
from piped.providers import spread_provider, pipeline_provider
class FakeProcessor(object):
def __init__(self):
self.batons = defer.DeferredQueue()
self.i = 0
def __call__(self, baton):
self.batons.put(baton)
self.i += 1
return [self.i]
class PBTestBase(unittest.TestCase):
timeout = 2
def setUp(self):
self.runtime_environment = processing.RuntimeEnvironment()
self.application = self.runtime_environment.application = service.MultiService()
def replace_twisted_log_err(self, err=lambda failure=None: None):
original = log.err
log.err = err
def restore():
log.err = original
self.addCleanup(restore)
def get_free_port(self):
sock = socket.socket()
sock.bind(('', 0))
free_port = sock.getsockname()[1]
sock.close()
return free_port
def create_pb_server(self, **kwargs):
self.port = self.get_free_port()
listen = 'tcp:%i:interface=localhost'%self.port
kwargs['listen'] = listen
kwargs.setdefault('processor', 'pipeline.test_pipeline')
kwargs.setdefault('wait_for_processor', False)
self.server = spread_provider.PipedPBService(**kwargs)
self.server.setServiceParent(self.application)
self.server.configure(self.runtime_environment)
class PBServerTest(PBTestBase):
def setUp(self):
super(PBServerTest, self).setUp()
self.processor = FakeProcessor()
self.processor_dependency = dependencies.InstanceDependency(self.processor)
self.processor_dependency.is_ready = True
# replace twisted.python.log.err in these tests since pb uses log.err to
# print failure messages on the server side if the exception does not subclass
# pb.Error.
self.replace_twisted_log_err()
self.runtime_environment.configure()
@defer.inlineCallbacks
def test_simple_server(self):
self.create_pb_server()
self.application.startService()
self.addCleanup(self.application.stopService)
self.server.processor_dependency = self.processor_dependency
# connect to the server
client = pb.PBClientFactory()
reactor.connectTCP('localhost', self.port, client)
root = yield client.getRootObject()
self.addCleanup(root.broker.transport.loseConnection)
# call a remote function
adding = root.callRemote('add', 42, b=93)
# assert that the baton is on the expected form
baton = yield self.processor.batons.get()
self.assertEquals(baton['message'], 'add')
self.assertEquals(baton['args'], (42,))
self.assertEquals(baton['kwargs'], dict(b=93))
# callback the deferred in the baton
baton['deferred'].callback(42+93)
# the above callbacking should result in the client getting its response
result = yield adding
self.assertEquals(result, 42+93)
@defer.inlineCallbacks
def test_waiting_for(self):
processor_dependency = dependencies.ResourceDependency(provider='pipeline.any')
self.create_pb_server()
self.application.startService()
self.addCleanup(self.application.stopService)
self.server.processor_dependency = processor_dependency
# connect to the server
client = pb.PBClientFactory()
reactor.connectTCP('localhost', self.port, client)
root = yield client.getRootObject()
self.addCleanup(root.broker.transport.loseConnection)
# call a remote function without waiting for the processor:
try:
yield root.callRemote('add', 42, b=93)
except spread_provider.RemoteError as e:
self.assertEquals(e.remoteType, reflect.fullyQualifiedName(exceptions.UnprovidedResourceError))
else:
self.fail('UnprovidedResourceError not raised.')
# call a method when waiting for the processor
self.server.wait_for_processor = True
adding = root.callRemote('add', 42, b=93)
processor_dependency.on_resource_ready(self.processor)
processor_dependency.fire_on_ready()
baton = yield self.processor.batons.get()
# the call must be completed before we complete the test:
baton['deferred'].callback(42+93)
yield adding
@defer.inlineCallbacks
def test_default_callbacks(self):
self.create_pb_server()
self.application.startService()
self.addCleanup(self.application.stopService)
self.server.processor_dependency = self.processor_dependency
# connect to the server
client = pb.PBClientFactory()
reactor.connectTCP('localhost', self.port, client)
root = yield client.getRootObject()
self.addCleanup(root.broker.transport.loseConnection)
# call a remote function
adding = root.callRemote('add', 42, b=93)
# assert that the baton is on the expected form
baton = yield self.processor.batons.get()
self.assertEquals(baton['message'], 'add')
self.assertEquals(baton['args'], (42,))
self.assertEquals(baton['kwargs'], dict(b=93))
# remove our reference to the baton
del baton
# since the server no longer has any reference to the deferred, it will be garbage
# collected and the client should receive an exception:
try:
yield adding
except spread_provider.RemoteError as e:
self.assertEquals(e.remoteType, reflect.fullyQualifiedName(exceptions.MissingCallback))
else:
self.fail('MissingCallback not raised.')
# set a default callback and call a remote function
self.server.default_callback = 'a default callback'
adding = root.callRemote('add', 42, b=93)
# we avoid keeping a reference to this baton in order to trigger the default
yield self.processor.batons.get()
# wait for the result to come in, which should be our default callback
result = yield adding
self.assertEquals(result, self.server.default_callback)
@defer.inlineCallbacks
def test_default_callbacks_after_failure(self):
self.create_pb_server()
self.application.startService()
self.addCleanup(self.application.stopService)
self.server.processor_dependency = self.processor_dependency
# connect to the server
client = pb.PBClientFactory()
reactor.connectTCP('localhost', self.port, client)
root = yield client.getRootObject()
self.addCleanup(root.broker.transport.loseConnection)
# call a remote function
adding = root.callRemote('add', 42, b=93)
# we raise an exception and collect it in a failure because it causes
# f_locals to be reachable
# make sure the baton is reachable from the failure frames:
baton = yield self.processor.batons.get()
try:
raise Exception()
except Exception as e:
from twisted.python import failure
f = failure.Failure()
# remove our reference to the baton and failure
del baton
del f
# since we're in an inlineCallbacks, update our locals so the above del statements can take effect
# this is explained in more detail in PipedPBService.handle_baton
locals()
# since the server no longer has any reference to the deferred, it will be garbage
# collected and the client should receive an exception:
try:
yield adding
except spread_provider.RemoteError as e:
self.assertEquals(e.remoteType, reflect.fullyQualifiedName(exceptions.MissingCallback))
else:
self.fail('MissingCallback not raised.')
@defer.inlineCallbacks
def test_require_login(self):
self.runtime_environment.configure()
self.create_pb_server(checker=dict(
name = 'twisted.cred.checkers.InMemoryUsernamePasswordDatabaseDontUse',
arguments = dict(test_username='test_password')
))
self.application.startService()
self.addCleanup(self.application.stopService)
self.server.processor_dependency = self.processor_dependency
# connect to the server
client = pb.PBClientFactory()
reactor.connectTCP('localhost', self.port, client)
root = yield client.getRootObject()
self.addCleanup(root.broker.transport.loseConnection)
# calling a remote function should result in no such method being found:
try:
yield root.callRemote('add', 42, b=93)
except spread_provider.RemoteError as e:
self.assertEquals(e.remoteType, reflect.fullyQualifiedName(flavors.NoSuchMethod))
else:
self.fail('NoSuchMethod not raised.')
# attempt to login with different bad credentials
bad_credentials = list()
bad_credentials.append(credentials.UsernamePassword('wrong', 'wrong'))
bad_credentials.append(credentials.UsernamePassword('test_username', 'wrong'))
bad_credentials.append(credentials.UsernamePassword('wrong', 'test_password'))
for bad_credential in bad_credentials:
try:
yield client.login(bad_credential)
except spread_provider.RemoteError as e:
self.assertEquals(e.remoteType, reflect.fullyQualifiedName(error.UnauthorizedLogin))
else:
self.fail('NoSuchMethod not raised.')
perspective = yield client.login(credentials.UsernamePassword('test_username', 'test_password'))
adding = perspective.callRemote('add', 42, b=93)
# assert that the baton is on the expected form
baton = yield self.processor.batons.get()
self.assertEquals(baton['message'], 'add')
self.assertEquals(baton['args'], (42,))
self.assertEquals(baton['kwargs'], dict(b=93))
# callback the deferred in the baton
baton['deferred'].callback(42+93)
# the above callbacking should result in the client getting its response
result = yield adding
self.assertEquals(result, 42+93)
class PBClientTest(PBTestBase):
timeout = 2
@defer.inlineCallbacks
def test_reconnecting(self):
self.runtime_environment.configure()
cm = self.runtime_environment.configuration_manager
dm = self.runtime_environment.dependency_manager
self.create_pb_server()
cm.set('pb.clients.test_client.endpoint', 'tcp:host=localhost:port=%i'%self.port)
cm.set('pipelines.test_pipeline', [{'eval-lambda': {'lambda': 'baton: baton["deferred"].callback("foo")'}}])
pp = pipeline_provider.PipelineProvider()
pp.configure(self.runtime_environment)
self.application.startService()
self.addCleanup(self.application.stopService)
client_provider = spread_provider.PBClientProvider()
client_provider.configure(self.runtime_environment)
client_factory_dependency = dm.add_dependency(self, dict(provider='pb.client.test_client'))
client_root_dependency = dm.add_dependency(self, dict(provider='pb.client.test_client.root_object'))
dm.resolve_initial_states()
factory = yield client_factory_dependency.wait_for_resource()
self.assertIsInstance(factory, spread_provider.PipedPBClientFactory)
# we set the max_delay in order to make the unit test run quicker
factory.max_delay = 0
root = yield client_root_dependency.wait_for_resource()
self.assertIsInstance(root, pb.RemoteReference)
yield self.server.stopService()
# trying to use the root object now should result in an exception
try:
yield root.callRemote('omg')
except pb.PBConnectionLost as e:
pass
else:
self.fail('pb.PBConnectionLost was not raised.')
# the disconnect event will propagate in _this_ reactor iteration, so wait one
yield util.wait(0)
# both dependencies should now be unavailable
self.assertFalse(client_factory_dependency.is_ready)
self.assertFalse(client_root_dependency.is_ready)
# start the server again
yield self.server.startService()
# wait for the dependencies to become available again
new_factory = yield client_factory_dependency.wait_for_resource()
new_root = yield client_root_dependency.wait_for_resource()
# the same factory object should be used
self.assertEquals(new_factory, factory)
# but the root objects differ
self.assertNotEquals(new_root, root)
result = yield new_root.callRemote('anything')
self.assertEquals(result, 'foo')
@defer.inlineCallbacks
def test_valid_login(self):
self.runtime_environment.configure()
cm = self.runtime_environment.configuration_manager
dm = self.runtime_environment.dependency_manager
self.create_pb_server(checker=dict(
name = 'twisted.cred.checkers.InMemoryUsernamePasswordDatabaseDontUse',
arguments = dict(test_username='test_password')
))
cm.set('pb.clients.test_client', dict(
endpoint = 'tcp:host=localhost:port=%i'%self.port,
username = 'test_username',
password = 'test_password'
))
cm.set('pipelines.test_pipeline', [{'eval-lambda': {'lambda': 'baton: baton["deferred"].callback("logged in as %s"%baton["avatar_id"])'}}])
pp = pipeline_provider.PipelineProvider()
pp.configure(self.runtime_environment)
self.application.startService()
self.addCleanup(self.application.stopService)
client_provider = spread_provider.PBClientProvider()
client_provider.configure(self.runtime_environment)
client_root_dependency = dm.add_dependency(self, dict(provider='pb.client.test_client.root_object'))
dm.resolve_initial_states()
root = yield client_root_dependency.wait_for_resource()
result = yield root.callRemote('any')
self.assertEquals(result, 'logged in as test_username')
@defer.inlineCallbacks
def test_invalid_login(self):
self.runtime_environment.configure()
cm = self.runtime_environment.configuration_manager
dm = self.runtime_environment.dependency_manager
self.create_pb_server(checker=dict(
name = 'twisted.cred.checkers.InMemoryUsernamePasswordDatabaseDontUse',
arguments = dict(test_username='test_password')
))
cm.set('pb.clients.test_wrong_password_client', dict(
endpoint = 'tcp:host=localhost:port=%i'%self.port,
username = 'test_username',
password = 'wrong_password'
))
cm.set('pipelines.test_pipeline', ['passthrough'])
pp = pipeline_provider.PipelineProvider()
pp.configure(self.runtime_environment)
self.application.startService()
self.addCleanup(self.application.stopService)
client_provider = spread_provider.PBClientProvider()
client_provider.configure(self.runtime_environment)
self.replace_twisted_log_err()
with mock.patch.object(spread_provider, 'logger') as mocked_logger:
client_wrong_password_factory_dependency = dm.add_dependency(self, dict(provider='pb.client.test_wrong_password_client'))
dm.resolve_initial_states()
# trying to log in with an unauthorized login should result in an "unauthorized login"
wrong_pw_factory = yield client_wrong_password_factory_dependency.wait_for_resource()
(args, kwargs) = yield wrong_pw_factory.on_failed_getting_root_object.wait_until_fired()
reason = args[0]
self.assertEquals(reason.type, 'twisted.cred.error.UnauthorizedLogin')
yield util.wait(0) # wait a reactor iteration so the event finishes processing
@defer.inlineCallbacks
def test_manual_login(self):
self.runtime_environment.configure()
cm = self.runtime_environment.configuration_manager
dm = self.runtime_environment.dependency_manager
self.create_pb_server(checker=dict(
name = 'twisted.cred.checkers.InMemoryUsernamePasswordDatabaseDontUse',
arguments = dict(test_username='test_password')
))
cm.set('pb.clients.test_no_login', dict(
endpoint = 'tcp:host=localhost:port=%i'%self.port,
))
cm.set('pipelines.test_pipeline', [{'eval-lambda': {'lambda': 'baton: baton["deferred"].callback("logged in as %s"%baton["avatar_id"])'}}])
pp = pipeline_provider.PipelineProvider()
pp.configure(self.runtime_environment)
self.application.startService()
self.addCleanup(self.application.stopService)
client_provider = spread_provider.PBClientProvider()
client_provider.configure(self.runtime_environment)
client_no_login_root_dependency = dm.add_dependency(self, dict(provider='pb.client.test_no_login.root_object'))
dm.resolve_initial_states()
# if the client does not login, it will get a RemoteReference to a PortalWrapper
# which can be used to perform the login "manually"
no_login_root = yield client_no_login_root_dependency.wait_for_resource()
challenge, challenger = yield no_login_root.callRemote('login', 'test_username')
perspective = yield challenger.callRemote('respond', pb.respond(challenge, 'test_password'), mind=None)
result = yield perspective.callRemote('any')
self.assertEquals(result, 'logged in as test_username')
class PBServerProviderTest(unittest.TestCase):
def setUp(self):
self.runtime_environment = processing.RuntimeEnvironment()
self.application = self.runtime_environment.application = service.MultiService()
self.runtime_environment.configure()
def test_server_is_provided(self):
cm = self.runtime_environment.configuration_manager
cm.set('pb.servers.test_server', dict(
processor = 'pipeline.test_pipeline',
listen = 'tcp:0'
))
provider = spread_provider.PBServerProvider()
provider.configure(self.runtime_environment)
dep = dependencies.ResourceDependency(provider='pb.server.test_server')
provider.add_consumer(dep)
server = dep.get_resource()
# the server instance should depend on the processor resource
self.assertEquals(server.processor_dependency.provider, 'pipeline.test_pipeline') |
import logging
import os
from distutils.util import strtobool
from typing import Any, Callable, MutableMapping, Optional
from aiohttp.web import Application, run_app, static
from aiohttp_jinja2 import setup as setup_aiohttp_jinja2
from aioredis import create_redis_pool
from jinja2 import FileSystemLoader
from .cache import MemoryCache, RedisCache
from .fetcher import try_fetcher
from .fetcher.danbooru import fetch_danbooru_post
from .fetcher.http import fetch_http
from .fetcher.pixiv import fetch_pixiv_url
from .web import routes
async def setup_aioredis(redis_url: str, app: Application) -> None:
redis = await create_redis_pool(redis_url)
app['redis'] = redis
app['cache'] = RedisCache(redis)
async def teardown_aioredis(app: Application) -> None:
redis = app['redis']
redis.close()
await redis.wait_closed()
del app['cache']
del app['redis']
def maybe_set(
settings: MutableMapping[str, Any],
name: str,
envvar: str,
coercer: Optional[Callable[[str], Any]] = None,
default: Any = None,
) -> None:
if envvar in os.environ:
value = os.environ[envvar]
if coercer is not None:
value = coercer(value)
settings.setdefault(name, value)
elif default is not None:
settings.setdefault(name, default)
def main(debug: bool = True) -> None:
if debug:
logging.basicConfig(level=logging.DEBUG)
app = Application()
setup_aiohttp_jinja2(
app,
loader=FileSystemLoader(os.path.dirname(__file__)),
)
maybe_set(app, 'debug', 'DEBUG', strtobool, debug)
maybe_set(app, 'redis_url', 'REDIS_URL', default='')
maybe_set(app, 'port', 'PORT', int, 8080)
maybe_set(app, 'danbooru_api_key', 'DANBOORU_API_KEY', default='')
maybe_set(app, 'danbooru_username', 'DANBOORU_USERNAME', default='')
static_path = os.path.join(os.path.dirname(__file__), 'static')
app.router.add_routes(routes)
app.add_routes([static('/static', static_path)])
redis_url = app['redis_url']
port = int(os.environ.get('PORT', '8080'))
if redis_url:
app.on_startup.append(lambda app: setup_aioredis(redis_url, app))
app.on_cleanup.append(teardown_aioredis)
else:
app['cache'] = MemoryCache()
app['fetcher'] = try_fetcher([
fetch_danbooru_post(
api_key=app['danbooru_api_key'],
username=app['danbooru_username'],
),
fetch_pixiv_url,
fetch_http,
])
run_app(app, port=port)
|
#!/usr/bin/env python3
import configparser
import requests
import argparse
import json
import re
import yaml
import os
import subprocess
import shutil
from glob import glob
# Get config from user dir
config_file = os.path.expanduser("~/.puzzlecad")
config = configparser.ConfigParser()
config.read(config_file)
client_id = config['puzzlecad']['ClientId']
client_secret = config['puzzlecad']['ClientSecret']
openscad_bin = config['puzzlecad']['OpenscadBin']
access_token = config['puzzlecad']['AccessToken']
thingiverse_timeout = 60
libs_dir = '../src/main/scad'
output_dir = '../out'
os.environ['OPENSCADPATH'] = libs_dir
parser = argparse.ArgumentParser()
parser.add_argument('command')
parser.add_argument('cmdargs', nargs='*')
args = parser.parse_args()
def process_command(args):
if args.command == 'get-token':
get_access_token()
elif args.command == 'build':
build_stls(args.cmdargs[0])
elif args.command == "bundle-puzzlecad":
bundle_puzzlecad(args.cmdargs[0])
elif args.command == 'print-thing-description':
print_thing_description(args.cmdargs[0])
elif args.command == 'update-thing':
if access_token == '':
raise Exception("You must specify an access token. Use the get-token command to obtain one.")
update_thing(access_token, args.cmdargs[0], '' if (len(args.cmdargs) < 2) else args.cmdargs[1])
elif args.command == 'delete-thing':
if access_token == '':
raise Exception("You must specify an access token. Use the get-token command to obtain one.")
delete_thing(access_token, args.cmdargs[0])
elif args.command == 'test':
run_test(access_token)
else:
raise Exception(f'Unknown command: {args.command}')
def get_access_token():
print('Go to this URL and get an auth code:')
print(f'https://www.thingiverse.com/login/oauth/authorize?client_id={client_id}')
code = input('Enter auth code: ')
token_response = requests.post(
'https://www.thingiverse.com/login/oauth/access_token',
data = {'client_id': client_id, 'client_secret': client_secret, 'code': code},
timeout = thingiverse_timeout
)
params = dict(x.split('=') for x in token_response.text.split('&'))
access_token = params['access_token']
print('Put this line in ~/.puzzlecad:')
print(f'AccessToken = {access_token}')
def print_thing_description(thing_name):
yaml_path = resolve_thing(thing_name)
contents = load_yaml_file(yaml_path)
description = substitute_globals(contents['description'], thing_name)
print(description)
def delete_thing(access_token, thing_id):
thingiverse_delete(f'things/{thing_id}', access_token)
def update_thing(access_token, thing_name, targets_str):
targets = targets_str.split(',')
yaml_path = resolve_thing(thing_name)
contents = load_yaml_file(yaml_path)
name = contents['name']
thing_id = contents['thing-id']
description = substitute_globals(contents['description'], thing_name)
print(f'Updating thing "{name}" from file {yaml_path} ...')
if 'files' in targets:
# Build the STLs first before uploading anything
build_stls(thing_name)
split_name = name.split(" - ")
description_title = f'## {name}' if len(split_name) <= 1 else f'## {split_name[0]}\n\n### {split_name[1]}'
print(f'Updating thing attributes ...')
attributes = {
'name': name,
'license': 'cc-nc-nd',
'category': 'Puzzles',
'description': f"## {description_title}\n\n{description}",
'tags': contents['tags']
}
thingiverse_patch(f'things/{thing_id}', access_token, attributes)
dir = os.path.dirname(yaml_path)
if 'images' in targets:
# thingiverse_clean(thing_id, 'images')
for image_file in contents['images']:
thingiverse_post_file(thing_id, os.path.join(dir, image_file))
if 'files' in targets:
thingiverse_clean(thing_id, 'files')
root = os.path.splitext(yaml_path)[0]
scad_path = root + ".scad"
abs_scad_path = os.path.abspath(scad_path)
scad_file = os.path.basename(scad_path)
scad_root = os.path.splitext(scad_file)[0]
thingiverse_post_file(thing_id, scad_path)
configurations = contents['configurations'] if 'configurations' in contents else [{'name': '', 'code': '', 'targets': ''}]
for configuration in configurations:
configuration_targets = contents['targets'] if configuration['targets'] == '' else configuration['targets']
for stl_target in configuration_targets:
stl_target_dashes = stl_target.replace("_", "-")
configuration_name = '' if configuration['name'] == '' else '-' + configuration['name']
modularized_name = f'{scad_root}{configuration_name}' if stl_target == "--" else f'{scad_root}.{stl_target_dashes}{configuration_name}'
stl_target_path = f'{output_dir}/{modularized_name}.stl'
thingiverse_post_file(thing_id, stl_target_path)
def resolve_thing(thing_name):
print(f'../src/main/scad/**/{thing_name}.yaml')
yaml_path = glob(f'../src/main/scad/**/{thing_name}.yaml', recursive = True)
if len(yaml_path) == 0:
raise Exception(f'Thing not found: {thing_name}')
return yaml_path[0];
def load_yaml_file(yaml_file):
file = open(yaml_file, mode = 'r')
contents = file.read()
file.close()
return yaml.load(contents, Loader = yaml.FullLoader)
def build_stls(thing_name):
yaml_path = resolve_thing(thing_name)
contents = load_yaml_file(yaml_path)
root = os.path.splitext(yaml_path)[0]
scad_path = root + ".scad"
print(f'Building STLs from source {scad_path} ...')
configurations = contents['configurations'] if 'configurations' in contents else [{'name': '', 'code': '', 'targets': ''}]
for configuration in configurations:
configuration_targets = contents['targets'] if configuration['targets'] == '' else configuration['targets']
for stl_target in configuration_targets:
build_stl(scad_path, stl_target, configuration)
def build_stl(scad_path, stl_target, configuration):
os.makedirs(output_dir, exist_ok = True)
abs_scad_path = os.path.abspath(scad_path)
scad_file = os.path.basename(scad_path)
scad_root = os.path.splitext(scad_file)[0]
stl_target_dashes = stl_target.replace("_", "-")
configuration_name = '' if configuration['name'] == '' else '-' + configuration['name']
configuration_code = configuration['code']
modularized_name = f'{scad_root}{configuration_name}' if stl_target == "--" else f'{scad_root}.{stl_target_dashes}{configuration_name}'
stl_target_path = f'{output_dir}/{modularized_name}.stl'
temp_scad_path = f'{output_dir}/{modularized_name}.scad'
if os.path.exists(stl_target_path) and os.path.getmtime(stl_target_path) >= os.path.getmtime(abs_scad_path):
print(f' Target {modularized_name} is up to date.')
else:
print(f' Building target {modularized_name} ...')
target_func = "" if stl_target == "--" else f'{stl_target}();';
script = f'include <{abs_scad_path}>\n\n{configuration_code}\n{target_func}\n'
with open(temp_scad_path, 'w') as file:
file.write(script)
exit_status = os.system(f'{openscad_bin} -o {stl_target_path} {temp_scad_path}')
if exit_status != 0:
raise Exception(f'Failed on target {modularized_name}.')
def substitute_globals(description, thing_name):
# This is somewhat inefficient but should be fine at small scale.
mentioned_globals = re.findall('\$\{(.*?)\}', description)
for key in mentioned_globals:
if key == 'name':
replacement = thing_name
elif key.startswith('link:'):
link_name = key[5:]
link_yaml_path = resolve_thing(link_name)
link_contents = load_yaml_file(link_yaml_path)
link_thing_id = link_contents['thing-id']
link_title = link_contents['name']
link_split_title = link_title.split(" - ")
replacement = f'[{link_split_title[0]}](https://www.thingiverse.com/thing:{link_thing_id})'
elif key in globals:
replacement = globals[key]
else:
raise Exception('Unknown global: ${' + key + '}')
description = description.replace('${' + key + '}', replacement)
return description
def bundle_puzzlecad(version):
# Rudimentary poor-excuse-for-a-build-script,
# but I'm trying to keep things super simple right now
exit_status = run_puzzlecad_tests()
if (exit_status != 0):
return
print(f'Bundling puzzlecad version {version} ...')
os.makedirs('../out/dist', exist_ok = True)
print('Building java components ...')
os.makedirs('../out/java', exist_ok = True)
result = subprocess.run(
['javac', 'org/puzzlecad/XmpuzzleToScad.java', '-d', '../../../out/java', '-source', '1.6', '-target', '1.6'],
cwd = '../src/main/java'
)
if result.returncode != 0:
print('Failed!')
return
print('Building jar ...')
result = subprocess.run(
['jar', 'cfm', '../dist/bt2scad.jar', '../../src/main/java/manifest', '.'],
cwd = '../out/java'
)
if result.returncode != 0:
print('Failed!')
return
print('Copying to distribution dir ...')
shutil.copy('../src/main/scad/puzzlecad.scad', '../out/dist')
shutil.copy('../src/main/scad/puzzlecad-examples.scad', '../out/dist')
shutil.copy('../src/main/scad/dist/half-hour-example.scad', '../out/dist')
print('Creating archive ...')
dist_files = [ os.path.relpath(file, '../out/dist') for file in glob('../out/dist/*') ]
subprocess.run(
['zip', f'../puzzlecad-{version}.zip'] + dist_files,
cwd = '../out/dist'
)
if result.returncode != 0:
print('Failed!')
return
print('Done!')
def run_puzzlecad_tests():
print('Running puzzlecad tests ...')
exit_status = os.system(f'{openscad_bin} -o ../out/puzzlecad-tests.stl ../src/main/scad/puzzlecad-tests.scad')
if exit_status == 0:
print('Tests succeeded.')
else:
print('Tests failed!')
return exit_status
def thingiverse_get(endpoint, access_token):
url = f'https://api.thingiverse.com/{endpoint}'
response = requests.get(
url,
params = { 'access_token': access_token },
timeout = thingiverse_timeout
)
if response.status_code != 200:
raise Exception(f"Call to {url} returned {response.status_code}: {response.text}")
return response.json()
def thingiverse_post(endpoint, access_token, data):
url = f'https://api.thingiverse.com/{endpoint}'
response = requests.post(
url,
params = { 'access_token': access_token },
json = data,
timeout = thingiverse_timeout
)
if response.status_code != 200:
raise Exception(f"Call to {url} returned {response.status_code}: {response.text}")
return response.json()
def thingiverse_patch(endpoint, access_token, data):
url = f'https://api.thingiverse.com/{endpoint}'
response = requests.patch(
url,
params = { 'access_token': access_token },
json = data,
timeout = thingiverse_timeout
)
if response.status_code != 200:
raise Exception(f"Call to {url} returned {response.status_code}: {response.text}")
return response.json()
def thingiverse_delete(endpoint, access_token):
url = f'https://api.thingiverse.com/{endpoint}'
response = requests.delete(
url,
params = { 'access_token': access_token },
timeout = thingiverse_timeout
)
if response.status_code != 200:
raise Exception(f"Call to {url} returned {response.status_code}: {response.text}")
return response.json()
def thingiverse_get_image_ids(thing_id):
json_images = thingiverse_get(f'things/{thing_id}/images', access_token)
return [json_image['id'] for json_image in json_images]
def thingiverse_post_file(thing_id, file_path):
dir = os.path.dirname(file_path)
file_name = os.path.basename(file_path)
print(f'Uploading {file_name} ...')
response = thingiverse_post(
f'things/{thing_id}/files',
access_token,
{ 'filename': file_name }
)
with open(file_path, 'rb') as obj:
files = { 'file': (file_path, obj) }
s3_response = requests.post(
response['action'],
data = response['fields'],
files = files,
allow_redirects = False,
timeout = thingiverse_timeout
)
finalize_response = requests.post(
response['fields']['success_action_redirect'],
params = { 'access_token': access_token },
timeout = thingiverse_timeout
)
print(finalize_response.text)
def thingiverse_clean(thing_id, artifact_type):
for artifact in thingiverse_get(f'things/{thing_id}/{artifact_type}', access_token):
artifact_id = artifact['id']
artifact_name = artifact['name']
print(f'Deleting {artifact_name} ...')
thingiverse_delete(f'things/{thing_id}/{artifact_type}/{artifact_id}', access_token)
def run_test(access_token):
thingiverse_delete(f'things/3198014/files/7668891', access_token)
globals = load_yaml_file('../src/main/scad/globals.yaml')
process_command(args)
|
import pytest
import dataset
import pymemdb
@pytest.fixture(scope="function")
def simple_dataset_db():
db = dataset.connect("sqlite:///:memory:", row_type=dict)
simple_table = db.create_table("my_table")
simple_table.insert_many([dict(a=i, b=1) for i in range(10)])
return db
def test_simple_table(simple_dataset_db):
simple_table = simple_dataset_db["my_table"]
pytable = pymemdb.Table.from_dataset(simple_table)
assert pytable.name == "my_table"
assert list(pytable.all()) == list(simple_table.all())
def test_simple_table_non_default_pk():
# simple_table = simple_dataset_db["my_table"]
db = dataset.connect("sqlite:///:memory:", row_type=dict)
simple_table = db.create_table("my_table", primary_id="a")
simple_table.insert_many([dict(a=i, b=1) for i in range(10)])
pytable = pymemdb.Table.from_dataset(simple_table)
testrow = dict(a=21, b=2)
simple_table.insert(testrow)
pytable.insert(testrow)
assert list(pytable.all()) == list(simple_table.all())
def test_to_dataset_with_drop(simple_dataset_db):
rows = [{"b": i, "c": 3} for i in range(1, 6)]
t = pymemdb.Table("my_table", primary_id="id")
for r in rows:
t.insert(r)
t.to_dataset(simple_dataset_db, drop=True)
assert list(simple_dataset_db["my_table"].all()) == list(t.all())
@pytest.mark.xfail
def test_to_dataset_with_drop_change_pk(simple_dataset_db):
"""known strange behavior addressd in
https://github.com/pudo/dataset/issues/329
"""
rows = [{"b": i, "c": 3} for i in range(1, 6)]
t = pymemdb.Table("my_table", primary_id="b")
for r in rows:
t.insert(r)
t.to_dataset(simple_dataset_db, drop=True)
assert list(simple_dataset_db["my_table"].all()) == list(t.all())
def test_to_dataset_no_drop(simple_dataset_db):
rows = [{"b": i, "c": 3} for i in range(1, 6)]
t = pymemdb.Table("my_table2", primary_id="b")
for r in rows:
t.insert(r)
t.to_dataset(simple_dataset_db, drop=False)
assert list(simple_dataset_db["my_table2"].all()) == list(t.all())
|
"""Tools for defining and modeling problem geometry
This module implements several kinds of collision detection, as well
as tools for converting between different representations of problem
geometry. The supported geometry types are referred to as
:math:`\\mathbf{R}^2` (where the robot is a point navigating in a
polygonal world), :math:`\\text{SE}(2)` (where the robot is a polygon
navigating in a polygonal world), and many shape (where the robot is a
polygon and the world contains other dynamic polygonal objects, which
can be pushed or pulled).
In addition to standard tools like ``numpy``, it relies on three
libraries:
- shapely_: a (mostly) pure python library for constructive and
set-theoretic geometry. It lets you define objects *constructively*::
walls = shapely.geometry.box(0, 0, 2, 2).difference(
shapely.geometry.box(.1, .1, 1.9, 1.9))
which defines a rectangular room by subtracting a square with side
length 1.8 from a square of side length 2. It also lets you reason
about things like boundaries and intersections of regions, and then
recover the edges, vertices, etc of the shapes you create. Compared
to Box2D it is slow, easy to use, and reliable.
- Box2D_: a ``python`` wrapper based on ``SWIG`` around a ``c++``
library for 2D physics simulation. It is extremely fast compared to
shapely, but also buggy, hard to use, and not overly feature-rich. As
soon as it's feasible I will remove Box2D from this package, but
irritating as it is, it gets the job done. Many of the functions in
this module are for translating Box2D objects to shapely geometry and
vice versa.
- triangle_: a ``cython`` wrapper around a very fast, very stable ``c``
library for triangulation. I use it for breaking non-convex shapes
into convex pieces, since Box2D can only handle convex geometry. It is
used exclusively in the ``triangulate`` method.
To make it easier to tell which objects are shapely objects and which
are Box2D objects, I try to follow a consistent naming convention:
- ``point`` is always a tuple or tuple-like containing coordinates (x, y)
on the 2D plane
- ``pose`` is always a tuple or tuple-like containing a pose in SE(2),
represented as (x, y, theta), with (x, y) a position in meters and
theta an angle in radians
- ``world`` is always a Box2D world, which contains a collection of ``bodies``
defining the objects (both static and dynamic) in the world
- ``body`` is always a Box2D body, which models an object and contains
both a pose (a position and orientation) as well as collection of
fixtures which define the geometry of the object.
- ``fixture`` is always a Box2D fixture, which contains a convex polygon
and is a component of the geometry of a ``body``
- ``geometry`` is a shapely geometry object; this may be a point, line,
polygon, or collection of polygons, but will always define a region of
the 2D plane.
.. _shapely: http://toblerity.org/shapely/manual.html
.. _Box2D: https://github.com/pybox2d/pybox2d/wiki/manual
.. _triangle: http://dzhelil.info/triangle/
"""
import math
import numpy
import scipy.spatial
import triangle
import Box2D.b2 as b2
import shapely.geometry
import shapely.ops
# pylint: disable=no-member
from metis.iterators import circular_pairs
def sparsify_point_set(points, count):
"""Downsample a list of points
Reduce a list of points to length count, attempting to minimize the
maximum distance from a point in the original set to a point in the
new set. This is done using an O(M^2 N) algorithm, where M=count
and N=len(points); this could be easily improved to O(M (log M + log
N) + N log N) using a more complex algorithm.
Args:
points (numpy.ndarray): array of points. Each row of the array
is treated as a point, so the width of the array is the
dimensionality of the sample space.
count (int): number of points to keep
Returns:
numpy.ndarray: downsampled array of points
Examples:
>>> sparsify_point_set([(0, 0), (1, 1), (2, 2)], 2)
array([[0, 0],
[2, 2]])
"""
points = numpy.array(points)
if points.shape[0] < count:
return points
else:
mask = [0]
while len(mask) < count:
dist = scipy.spatial.distance.cdist(points, points[mask, ...])
mask.append(numpy.argmax(numpy.amin(dist, 1)))
return points[mask, ...]
def triangulate(geometry, max_area=None):
"""Use the triangle library to triangulate a polygon
Args:
polygon (shapely.*): shapely geometry representing the area to
triangulate
max_area (float): If provided, the triangulation will be refined
until all triangles have area less than this maximum.
Returns:
list: list of triangular polygons
"""
if not geometry.is_valid:
raise ValueError("Tried to triangulate invalid geometry", geometry)
if hasattr(geometry, "geoms"): # polygon is a MultiPolygon
polygons = list(geometry.geoms)
else:
polygons = [geometry]
vertices = []
segments = []
for polygon in polygons:
offset = len(vertices)
vertices.extend(polygon.exterior.coords[0:-1])
segments.extend(circular_pairs(
range(offset, offset+len(polygon.exterior.coords)-1)))
for ring in polygon.interiors:
offset = len(vertices)
vertices.extend(ring.coords[0:-1])
segments.extend(circular_pairs(
range(offset, offset+len(ring.coords)-1)))
shape = {'vertices': numpy.array(vertices),
'segments': numpy.array(segments, dtype=numpy.int32)}
# Find the holes in the geometry
buffer_by = numpy.sqrt(geometry.envelope.area)
complement = geometry.envelope.buffer(
buffer_by, cap_style=2, join_style=2).difference(geometry)
if complement.geom_type == "MultiPolygon":
shape['holes'] = numpy.array([interior.representative_point().coords[0]
for interior in complement.geoms])
elif complement.geom_type == "Polygon":
shape['holes'] = numpy.array(complement.representative_point().coords[0])
if max_area is None:
opts = "p"
else:
opts = "pa{}".format(max_area)
triangulation = triangle.triangulate(shape, opts)
return [shapely.geometry.Polygon([triangulation['vertices'][i]
for i in triplet])
for triplet in triangulation['triangles']]
def box2d_shapes_from_shapely(geometry):
"""Create Box2D shapes from shapely geometry"""
return [b2.polygonShape(vertices=list(poly.exterior.coords))
for poly in getattr(geometry, "geoms", [geometry])]
def convex_box2d_shape_from_shapely(geometry):
"""Create a Box2D shape from the convex hull of shapely geometry"""
return b2.polygonShape(
vertices=list(geometry.convex_hull.exterior.coords))
def box2d_triangles_from_shapely(geometry):
"""Create Box2D shapes by triangulating shapely geometry"""
for face in triangulate(geometry):
yield b2.polygonShape(vertices=list(face.exterior.coords))
def shapely_from_box2d_shape(shape):
"""Create shapely geometry from a Box2D shape"""
return shapely.geometry.polygon.orient(shapely.geometry.Polygon(
shape.vertices))
def shapely_from_box2d_fixtures(fixtures, pose=None):
"""Create shapely geometry from a list of Box2D fixtures"""
transform = b2.transform()
transform.position = pose[0:2] if pose is not None else (0, 0)
transform.angle = pose[2] if pose is not None else 0
# TODO: ensure polys are oriented
return shapely.ops.cascaded_union([
shapely.geometry.Polygon([
transform * p for p in fixture.shape.vertices])
for fixture in fixtures])
def shapely_from_box2d_body(body, pose=None):
"""Create shapely geometry from a Box2D body"""
if pose is None:
return shapely.geometry.polygon.orient(shapely.ops.cascaded_union([
shapely.geometry.Polygon([
body.GetWorldPoint(p) for p in fixture.shape.vertices])
for fixture in body.fixtures]))
else:
transform = b2.transform()
transform.position = pose[0:2]
transform.angle = pose[2]
return shapely.geometry.polygon.orient(shapely.ops.cascaded_union([
shapely.geometry.Polygon([
transform * p for p in fixture.shape.vertices])
for fixture in body.fixtures]))
def shapely_from_box2d_world(world):
"""Create shapely geometry from a Box2D shape"""
return shapely.geometry.polygon.orient(shapely.ops.cascaded_union([
shapely.geometry.Polygon([
body.GetWorldPoint(p) for p in fixture.shape.vertices])
for body in world.bodies
for fixture in body.fixtures]))
def bounding_box(fixtures, pose):
"""Get the axis aligned bounding box of the fixtures
Args:
fixtures (iterable): an iterable containing the fixtures to bound
pose (tuple): an (x, y, theta) tuple. All fixtures will be
transformed by this pose before the bounding box is
computed.
Returns:
b2.aabb: the smallest axis-aligned bounding box which completely
encloses all fixtures after being transformed by pose. If no
fixtures are supplied, the value None (rather than an empty
bounding box) is returned.
"""
transform = b2.transform()
transform.position = pose[0:2]
transform.angle = pose[2]
aabb = None
for fixture in fixtures:
# 0 is the 'child index', which is not described in the pybox2d
# documentation so I'm not really sure what it is.
if aabb is None:
aabb = fixture.shape.getAABB(transform, 0)
else:
aabb.Combine(fixture.shape.getAABB(transform, 0))
return aabb
def world_bounding_box(world, ignore_fixtures=None):
"""Get the smallest bounds tuple which encloses all fixtures
Args:
world (b2.world): box2d geometry to query
ignore_fixtures (iterable): if provided, the fixtures to ignore
when computing the bounding box
Returns:
tuple: the smallest (xmin, xmax, ymin, ymax) which completely
encloses all fixtures except those in ignore_fixtures. If
there are no fixtures in the world, raise an error
"""
aabb = shapely.geometry.Point()
for body in world.bodies:
for fixture in body.fixtures:
if ignore_fixtures is not None and fixture in ignore_fixtures:
continue
else:
shape = shapely.geometry.Polygon(
[body.GetWorldPoint(p) for p in fixture.shape.vertices])
aabb = aabb.union(shape).envelope
return None if aabb.is_empty else aabb.bounds
class PointFreeCallback(b2.queryCallback):
"""Callback class for Box2D shape collision detection
Used to determine if a point is in free space.
The existence of this class is an artifact of pybox2d's poor
design; it uses callback classes rather than callbacks, which
make sense in ``c++`` but are silly in python.
Attributes:
collision_free (bool): the return value of the callback. After
being queried, this will be True if the path is collision
free.
point (tuple): point to test
"""
# pylint: disable=too-few-public-methods
def __init__(self, point):
b2.queryCallback.__init__(self)
self.collision_free = True
self.point = point
def ReportFixture(self, fixture):
"""Check if the query point is inside this fixture"""
# pylint: disable=invalid-name
if fixture.TestPoint(self.point):
self.collision_free = False
return self.collision_free
class RayCastCallback(b2.rayCastCallback):
"""Callback class for Box2D point collision detection
Used to determine if the straight-line path between two points
is collision free in a Box2D world.
The existence of this class is an artifact of pybox2d's poor
design; it uses callback classes rather than callbacks, which
make sense in ``c++`` but are silly in python.
Attributes:
collision_free (bool): the return value of the callback.
After being queried, this will be True if the path is
collision free.
"""
# pylint: disable=too-few-public-methods
def __init__(self):
b2.rayCastCallback.__init__(self)
self.collision_free = True
def ReportFixture(self, fixture, point, normal, fraction):
"""If the function is called, there is at least one collision"""
# pylint: disable=invalid-name,unused-argument
self.collision_free = False
return 0
class ShapeFreeCallback(b2.queryCallback):
"""Callback class for Box2D shape collision detection
Used to determine if the straight-line path between two poses of a
shape is collision free in a Box2D world. Angles are interpolated
linearly, so for large rotations this will be inaccurate.
The test is done by casting each of the test_fixtures (one at at
time) at each fixture in the queried AABB that is not in the whitelist.
The existence of this class is an artifact of pybox2d's poor design;
it uses callback classes rather than callbacks, which make sense in
``c++`` but are silly in python.
Attributes:
test_fixtures (list): list of fixtures to check for collision
whitelist (list): list of fixtures to skip in collision
detection
pose_a (tuple): start pose of the path as an (x, y, theta) tuple
pose_b (tuple): end pose of the path as an (x, y, theta) tuple
collision_free (bool): the return value of the callback. After
being queried, this will be True if the path is collision
free.
"""
# pylint: disable=too-few-public-methods
def __init__(self, test_fixtures, pose_a, pose_b=None, whitelist=None):
b2.queryCallback.__init__(self)
self.test_fixtures = test_fixtures
self.whitelist = whitelist if whitelist is not None else []
self.pose_a = pose_a
self.pose_b = pose_b if pose_b is not None else pose_a
self.collision_free = True
def ReportFixture(self, other_fixture):
"""Check for collisions
This function is called by Box2D during an AABB query for each
fixture in the AABB.
"""
# pylint: disable=invalid-name
if other_fixture in self.whitelist:
return True
if other_fixture in self.test_fixtures:
# This ignores self-collisions (which seems a silly thing to
# have to check for...)
# TODO: there should be a way to avoid this check
return True
sweep = b2.sweep(a0=self.pose_a[2], a=self.pose_b[2],
c0=self.pose_a[0:2], c=self.pose_b[0:2])
still = b2.sweep(a=other_fixture.body.angle,
a0=other_fixture.body.angle,
c=other_fixture.body.position,
c0=other_fixture.body.position)
for test_fixture in self.test_fixtures:
(collision, impact_time) = b2.timeOfImpact(
shapeA=test_fixture.shape, shapeB=other_fixture.shape,
sweepA=sweep, sweepB=still, tMax=1.)
self.collision_free &= (
(impact_time == 1.) and
(collision == b2.TOIOutput.e_separated or
collision == b2.TOIOutput.e_touching))
if not self.collision_free:
break
return self.collision_free
def point_free(world, point):
"""Check if a point intersects any object in a Box2D world
Args:
world (b2.world): a Box2D world containing the geometry to query.
point (tuple): an (x, y) tuple defining the query point.
Returns:
bool: True if there are no objects in world within .1mm of
point; False otherwise.
"""
query = PointFreeCallback(point)
aabb = b2.AABB()
aabb.lowerBound = (point[0]-1e-4, point[1]-1e-4)
aabb.upperBound = (point[0]+1e-4, point[1]+1e-4)
world.QueryAABB(query, aabb)
return query.collision_free
def segment_free(world, point_a, point_b):
"""Check if a line segment intersects any object in a Box2D world
Args:
world (b2.world): a Box2D world containing the geometry to query.
point_a (tuple): an (x, y) tuple defining the start of the
segment
point_b (tuple): an (x, y) tuple defining the end of the segment
Returns:
bool: True if the line segment does not intersect any object in
the world
"""
if not point_free(world, point_a):
return False
else:
callback = RayCastCallback()
world.RayCast(callback, point_a, point_b)
return callback.collision_free
def pose_free(world, fixtures, pose_a, pose_b=None, whitelist=None):
"""Deterimine if a Box2D world is collision free
Used to determine if the straight-line path between two poses of a
shape is collision free in a Box2D world. Angles are interpolated
linearly, so for large rotations this will be inaccurate.
Attributes:
world (b2.world): Box2D object describing world geometry
fixtures (sequence): an iterable sequence of Box2D fixtures
to ignore in collision detection. Typically this is a
triangulation of the moveable object being queried.
pose_a (tuple): an (x, y, theta) tuple defining the pose for
which to perform collision detection
pose_b (tuple): if provided, check for collision along a linear
sweep from pose_a to pose_b, much like segment_free.
whitelist (sequence): an iterable sequence of Box2D fixtures to
*ignore* when performing collision detection. Useful for
preventing Box2D from reporting a collision between objects
in contact (say, if the robot is grasping an object)
Returns:
bool: True if the fixtures are not in collision when transformed
by pose_a, or never in collision during a linear sweep from
pose_a to pose_b
"""
# assert fixtures is not None and pose_a is not None
aabb = bounding_box(fixtures, pose_a)
if pose_b is not None:
aabb.Combine(bounding_box(fixtures, pose_b))
query = ShapeFreeCallback(fixtures, pose_a, pose_b, whitelist=whitelist)
world.QueryAABB(query, aabb)
return query.collision_free
class Geometry(object):
"""Encapsulates collision detection
This is a base class or prototype for concrete instantiations of
geometry objects. There are three key things such objects should be
capable of doing:
- check whether configurations are collision free
- check whether there exists a simple collision-free path
between configurations
- provide sufficient information to sample random configurations
Strictly speaking, a base class like this is unnecessary in
``python``, but I think it's helpful for readability to lay out the
interface in one place.
"""
def __init__(self, seed=0):
super(Geometry, self).__init__()
self.random = numpy.random.RandomState(seed)
def configuration_is_free(self, configuration):
"""Check if the supplied configuration is free"""
pass
def path_is_free(self, parent, child):
"""Check if there is a trivial path between configurations"""
pass
def sample_configuration(self):
"""Sample a configuration uniformly from the space"""
pass
class R2Geometry(Geometry):
"""Two dimensional point geometry
The configuration space is a subset of the 2D Cartesian plane in a
world that may contain obstacles.
Attributes:
world (Box2D.b2world): Underlying Box2D world object
bounds (tuple): a tuple (xmin, ymin, xmax, ymax) defining the
bounds of the problem geometry. Used primarily for sampling.
sample_count (int): number of samples generated so far. Used to
compute the measure of the set of free configurations
rejection_count (int): number of samples rejected so far. Used
to compute the measure of the set of free configurations.
"""
def __init__(self, world, bounds=None, **kwargs):
super(R2Geometry, self).__init__(**kwargs)
self.world = world
if bounds is None:
self.bounds = world_bounding_box(world)
else:
self.bounds = bounds
self.sample_count = 0
self.rejection_count = 0
self.scale = numpy.array([1, 1])
@property
def mu_free(self):
"""The Lebesgue measure of the space of free poses"""
xmin, ymin, xmax, ymax = self.bounds
total_area = (xmax - xmin) * (ymax - ymin)
assert self.rejection_count <= self.sample_count
if self.sample_count > 0:
free_count = self.sample_count - self.rejection_count
fraction_free = float(free_count) / float(self.sample_count)
return total_area * fraction_free
else:
return total_area
def configuration_is_free(self, point):
"""Check if a point is in the space of free configurations
Args:
point (tuple): a point in R2 represented as a tuple (x, y)
Returns:
bool: True if ``point`` lies in the free space
"""
return point_free(self.world, point)
def path_is_free(self, parent, child):
"""Check if the line segment between two points is in free space
Args:
parent (tuple): a point in R2, represented as a tuple
child (tuple): a point in R2, represented as a tuple
Returns:
bool: True if the line segment connecting parent and child
is in free space
"""
return segment_free(self.world, parent, child)
def sample_configuration(self):
"""Sample a configuration uniformly from the free space"""
xmin, ymin, xmax, ymax = self.bounds
iteration = 0
max_iterations = 100
while iteration < max_iterations:
point = self.random.uniform(0, 1, size=2)
point[0] *= xmax - xmin
point[0] += xmin
point[1] *= ymax - ymin
point[1] += ymin
self.sample_count += 1
if self.configuration_is_free(point):
return point
else:
self.rejection_count += 1
iteration += 1
raise RuntimeError(
"Failed to return a sample after {} iterations."
"Problem might be infeasible.".format(iteration))
class SE2Geometry(Geometry):
"""Two dimensional shape geometry
The configuration space is the space of poses of a 2D shape in a
world that may contain obstacles.
Attributes:
world (Box2D.b2world): Underlying c world object
fixtures (list): List of fixture objects constituting the
moving object. A fixture is a shape defined relative to the
moving object origin.
bounds (tuple): a tuple (xmin, ymin, xmax, ymax) defining the
bounds of the problem geometry. Used primarily for sampling.
sample_count (int): number of samples generated. Used to compute
the measure of the set of free configurations
rejection_count (int): number of samples rejected. Used to
compute the measure of the set of free configurations.
scale (numpy.array): vector used to scale configurations for
distance computations. In SE(2), the relative scale of the
position and rotation components is arbitrary; changing
units of distance from meters to kilometers, or of rotation
from radians to degrees, would cause large differences in a
nearest-neighbors search. The scale property provides a
suggestion for how to scale the distances between
configurations, which can be used in random graph
construction.
"""
def __init__(self, world, fixtures, bounds=None, **kwargs):
super(SE2Geometry, self).__init__(**kwargs)
self.world = world
self.fixtures = fixtures
if bounds is None:
self.bounds = world_bounding_box(world)
else:
self.bounds = bounds
self.sample_count = 0
self.rejection_count = 0
# Angle differences will be scaled by this in computing the
# distance between points in SE(2)
rotation_scale = 1
self.scale = numpy.array([1, 1, rotation_scale])
@property
def mu_free(self):
"""The Lebesgue measure of the space of free poses"""
xmin, ymin, xmax, ymax = self.bounds
total_area = (xmax - xmin) * (ymax - ymin)
mu_sample = total_area * 2 * math.pi * numpy.prod(self.scale)
assert self.rejection_count <= self.sample_count
if self.sample_count > 0:
free_count = self.sample_count - self.rejection_count
fraction_free = float(free_count) / float(self.sample_count)
return mu_sample * fraction_free
else:
return mu_sample
def configuration_is_free(self, pose):
"""Check if a pose is in collision
Args:
pose (tuple): a pose in SE(2), represented as a tuple (x, y,
theta), with theta in radians
Returns:
bool: True if ``shape`` would lie entirely in free space if
transformed by ``pose``.
"""
return pose_free(self.world, self.fixtures, pose)
def path_is_free(self, parent, child):
"""Check if the path between configurations is collision-free
Args:
parent (tuple): a pose in SE(2), represented as a tuple (x, y,
theta), with theta in radians
child (tuple): a pose in SE(2), represented as a tuple (x, y,
theta), with theta in radians
Returns:
bool: True if ``shape`` would lie entirely in free space if
swept along the linear path from an initial transform
``parent`` to a final transform ``child``
"""
return pose_free(self.world, self.fixtures, parent, child)
def sample_configuration(self):
"""Sample a configuration uniformly from the free space
Sampling is done (as per usual) using rejection sampling.
Returns:
tuple: a collision-free pose (x, y, theta)
Raises:
RuntimeError if rejection sampling fails to find a
collision-free sample within a fixed number of
iterations. Typically this indicates that the Lebesgue
measure of free space is zero or nearly zero, and thus
that the problem is infeasible
"""
xmin, ymin, xmax, ymax = self.bounds
iteration = 0
max_iterations = 100
while iteration < max_iterations:
pose = self.random.uniform(0, 1, size=3)
pose[0] *= xmax - xmin
pose[0] += xmin
pose[1] *= ymax - ymin
pose[1] += ymin
pose[2] *= 2 * math.pi
pose[2] -= math.pi
self.sample_count += 1
if self.configuration_is_free(pose):
return pose
else:
self.rejection_count += 1
iteration += 1
raise RuntimeError(
"Failed to return a sample after {} iterations."
"Problem might be infeasible.".format(iteration))
def fixtures_in_region(self, transform, region):
"""Check if the fixtures lie within the given region"""
return region.contains(
shapely_from_box2d_fixtures(self.fixtures, transform))
class ManyShapeGeometry(Geometry):
"""Use Box2D to model 2D geometry
The configuration space is the space of poses of several 2D shape in a
world that may contain obstacles; it is represented internally as a
dictionary mapping object names to object poses.
Attributes:
world (Box2D.b2world): Underlying Box2D world object
empty_world (Box2D.b2world): A copy of the underlying world
object with all dynamic objects removed.
bodies (dict): a map from object names to Box2D bodies
describing object geometry
bounds (tuple): a tuple (xmin, ymin, xmax, ymax) defining the
bounds of the problem geometry. Used primarily for sampling.
sample_count (int): number of samples generated. Used to compute
the measure of the set of free configurations
rejection_count (int): number of samples rejected. Used to
compute the measure of the set of free configurations.
scale (numpy.array): vector used to scale configurations for
distance computations. In SE(2), the relative scale of the
position and rotation components is arbitrary; changing
units of distance from meters to kilometers, or of rotation
from radians to degrees, would cause large differences in a
nearest-neighbors search. The scale property provides a
suggestion for how to scale the distances between
configurations, which can be used in random graph
construction.
"""
def __init__(self, world, bodies, bounds=None, **kwargs):
super(ManyShapeGeometry, self).__init__(**kwargs)
self.world = world
self.empty_world = b2.world()
self.bodies = bodies
obstacles = self.empty_world.CreateStaticBody()
moveable_fixtures = {fixture for body in bodies.itervalues()
for fixture in body.fixtures}
for body in world.bodies:
for fixture in body.fixtures:
if fixture not in moveable_fixtures:
obstacles.CreateFixture(shape=fixture.shape)
if bounds is None:
self.bounds = world_bounding_box(world)
else:
self.bounds = bounds
self.sample_count = 0
self.rejection_count = 0
# Angle differences will be scaled by this in computing the
# distance between points in SE(2)
rotation_scale = 1
self.scale = numpy.array([1, 1, rotation_scale])
@property
def mu_free(self):
"""The Lebesgue measure of the space of free poses
Note: this is not the theoretically correct mu_free, because it
would be insane to sample in the full high-dimensional space.
Instead this is the average free space across all objects. I
don't yet have any rigorous theory for what mu_free should be
for factored graphs, but this is a reasonable guess.
"""
xmin, ymin, xmax, ymax = self.bounds
total_area = (xmax - xmin) * (ymax - ymin)
mu_sample = total_area * 2 * math.pi * numpy.prod(self.scale)
assert self.rejection_count <= self.sample_count
if self.sample_count > 0:
free_count = self.sample_count - self.rejection_count
fraction_free = float(free_count) / float(self.sample_count)
return mu_sample * fraction_free
else:
return mu_sample
def configuration_is_free(self, configuration, skip_static=False):
"""Check if a configuration is collision-free
Performs collision-checking both against the static geometry and
against the other movable objects in a reasonably efficient way.
Args:
configuration (dict): configuration of the objects,
represented as a map from the name of each object to its
pose represented as an (x, y, theta) tuple. It is an
error if the pose of any object is not specified.
skip_static (bool): if True, skip checking if the
configuration is in collision with static geometry and
only check dynamic geometry. Useful to speed things up
during planning.
Returns:
bool: True if no two objects overlap
Raises:
ValueError if configuration does not specify the pose of one
of the objects
"""
# First check for collisions between each object and the static
# world geometry
for (name, body) in self.bodies.iteritems():
pose = configuration[name]
if not (skip_static or
pose_free(self.empty_world, body.fixtures, pose)):
return False
body.position = pose[0:2]
body.angle = pose[2]
# Next, force collision detection between dynamic bodies
self.world.Step(0, 0, 0)
for contact in self.world.contacts:
_, _, distance, _ = b2.distance(
shapeA=contact.fixtureA.shape,
shapeB=contact.fixtureB.shape,
transformA=contact.fixtureA.body.transform,
transformB=contact.fixtureB.body.transform, useRadii=False)
if distance <= 1e-4:
return False
return True
def path_is_free(self, parent, child, skip_configuration=False):
"""Check if the path between configurations is free
The path between configurations is assumed to be a linear sweep.
This class does not do any detection of dynamic constraints;
multiple object are free to move at once. This is to maintain
separation of concerns; the problem of determining if there is
an action which would lead to the configuration change is
beyond the scope of geometry.
Because the usual use-case is after dynamics and collisions
between moving objects have already been considered, this method
does *not* consider the possibility of collisions between
objects whose pose changes between parent and child. That check
can be performed using the objects_collide method.
Args:
parent (dict): initial configuration of the objects,
represented as a map from the name of each object to its
pose represented as an (x, y, theta) tuple. It is an
error if any object's pose is not specified.
child (dict): final configuration of the objects,
represented as a map from the name of each object to its
pose represented as an (x, y, theta) tuple. If an object
is missing from the dict, its pose is assumed to be the
same as in the parent configuration.
skip_configuration (bool): if True, assume the parent
configuration is collision free without checking. Note
oddities in Box2D can make this miss collisions if the
parent configuration *is* in collision.
Returns:
bool: True if the trivial path (a linear sweep) between
poses is collision-free
"""
if not (skip_configuration or self.configuration_is_free(parent)):
return False
else:
dynamic_fixtures = sum(
(self.bodies[name].fixtures for name in child), [])
for name in child:
if not pose_free(self.world, self.bodies[name].fixtures,
parent[name], child[name],
whitelist=dynamic_fixtures):
return False
return True
def objects_collide(self, parent, child):
"""Check if objects will collide with each other
Unlike path_is_free, this method does *not* require a pose for
all objects, and does *not* consider collisions with objects not
mentioned in the partial configuration or with static obstacles.
Instead, it checks if any object in the partial configuration
collides with any other object as it moves along a linear sweep
from its initial pose to its final pose.
Collision checking against specific static objects can be
coerced by including their pose in ``parent``; if an object does
not appear in ``child``, its pose is assumed to be the same as in
``parent``.
Args:
parent (dict): initial configuration of the objects,
represented as a map from the name of each object to its
pose represented as an (x, y, theta) tuple. Any object
not included in the map is ignored, including static
obstacles.
child (dict): final configuration of the objects,
represented as a map from the name of each object to its
pose represented as an (x, y, theta) tuple. If an object
is missing from ``child`` but is included in ``parent``, its
pose is assumed to be the same as in ``parent``
Returns:
bool: True if the trivial path (a linear sweep) between
poses is collision-free
"""
# I don't need this yet so I won't bother implementing it, but
# the plan is to create an AABB for each sweep, compare AABBs
# pairwise (which is quadratic complexity but fast, probably
# faster than using any n log n structure), then do ToI
# detection for any pair of objects whose AABBs collide.
raise NotImplementedError
def sample_configuration(self):
"""Sample a random configuration for all objects
Returns:
dict: a collision-free configuration of all objects,
represented a as a map from object names to poses,
themselves represented as (x, y, theta) tuples
Raises:
RuntimeError if rejection sampling fails to return a sample
"""
iteration = 0
max_iterations = 100
while iteration < max_iterations:
configuration = {name: self.sample_object_configuration(name)
for name in self.bodies}
if self.configuration_is_free(configuration):
return configuration
else:
iteration += 1
raise RuntimeError(
"Failed to return a sample after {} iterations."
"Problem might be infeasible.".format(iteration))
def sample_object_configuration(self, name):
"""Sample a random pose for one object
Args:
name (str): the name of the object to sample
Returns:
tuple: a collision-free pose of the specified object,
represented as an (x, y, theta) tuple
Raises:
KeyError if name is not the identifier of a body
RuntimeError if rejection sampling fails to return a sample
"""
xmin, ymin, xmax, ymax = self.bounds
iteration = 0
max_iterations = 100
while iteration < max_iterations:
pose = self.random.uniform(0, 1, size=3)
pose[0] *= xmax - xmin
pose[0] += xmin
pose[1] *= ymax - ymin
pose[1] += ymin
pose[2] *= 2 * math.pi
pose[2] -= math.pi
self.sample_count += 1
if pose_free(self.empty_world, self.bodies[name].fixtures, pose):
return pose
else:
self.rejection_count += 1
iteration += 1
raise RuntimeError(
"Failed to return a sample after {} iterations."
"Problem might be infeasible.".format(iteration))
|
# Copyright 2021 The Pigweed Authors
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
# https://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.
"""Install and check status of CRLSet and download chromium CRLSet."""
import os
import pathlib
import subprocess
from typing import Sequence
import pw_package.git_repo
import pw_package.package_manager
def crlset_tools_repo_path(path: pathlib.Path) -> pathlib.Path:
return path / 'crlset-tools'
def crlset_exec_path(path: pathlib.Path) -> pathlib.Path:
return path / 'crlset_exec'
def crlset_file_path(path: pathlib.Path) -> pathlib.Path:
return path / 'crlset'
class CRLSet(pw_package.package_manager.Package):
"""Install and check status of CRLSet and downloaded CLRSet file."""
def __init__(self, *args, **kwargs):
super().__init__(*args, name='crlset', **kwargs)
self._crlset_tools = pw_package.git_repo.GitRepo(
name='crlset-tools',
url='https://github.com/agl/crlset-tools.git',
commit='1a1019bb500f93bc2b847a57cdbaede847649b99',
)
def status(self, path: pathlib.Path) -> bool:
if not self._crlset_tools.status(crlset_tools_repo_path(path)):
return False
# The executable should have been built and exist.
if not os.path.exists(crlset_exec_path(path)):
return False
# A crlset has been downloaded
if not os.path.exists(crlset_file_path(path)):
return False
return True
def install(self, path: pathlib.Path) -> None:
self._crlset_tools.install(crlset_tools_repo_path(path))
# Build the go tool
subprocess.run(
['go', 'build', '-o',
crlset_exec_path(path), 'crlset.go'],
check=True,
cwd=crlset_tools_repo_path(path))
crlset_tools_exec = crlset_exec_path(path)
if not os.path.exists(crlset_tools_exec):
raise FileNotFoundError('Fail to find crlset executable')
# Download the latest CRLSet with the go tool
with open(crlset_file_path(path), 'wb') as crlset_file:
fetched = subprocess.run([crlset_exec_path(path), 'fetch'],
capture_output=True,
check=True).stdout
crlset_file.write(fetched)
def info(self, path: pathlib.Path) -> Sequence[str]:
return (
f'{self.name} installed in: {path}',
"Enable by running 'gn args out' and adding this line:",
f' pw_tls_client_CRLSET_PATH = "{crlset_file_path(path)}"',
)
pw_package.package_manager.register(CRLSet)
|
from event_testing.resolver import DoubleSimResolver
from event_testing.results import TestResult
from event_testing.test_events import cached_test
from interactions import ParticipantTypeSingle
from interactions.constraint_variants import TunableGeometricConstraintVariant
from interactions.constraints import Anywhere
from sims4.tuning.tunable import HasTunableSingletonFactory, AutoFactoryInit, TunableList, TunableEnumEntry, Tunable
import assertions
import event_testing.test_base
import interactions.constraints
import services
import sims4.log
import sims4.tuning
logger = sims4.log.Logger('ConstraintTests', default_owner='rmccord')
class SimsInConstraintTests(HasTunableSingletonFactory, AutoFactoryInit, event_testing.test_base.BaseTest):
test_events = ()
@staticmethod
def _verify_tunable_callback(instance_class, tunable_name, source, value):
value._validate_recursion(value.test_set, source, tunable_name)
FACTORY_TUNABLES = {'verify_tunable_callback': _verify_tunable_callback, 'constraints': TunableList(description='\n A list of constraints that, when intersected, will be used to find\n all Sims we care about.\n ', tunable=TunableGeometricConstraintVariant(description='\n A constraint that will determine what Sims to test.\n '), minlength=1), 'must_be_line_of_sight': Tunable(description="\n If enabled, sims that succeed in the LOS test won't fail other tests when determining\n the test results.\n ", tunable_type=bool, default=False), 'constraints_target': TunableEnumEntry(description='\n The target used to generate constraints relative to.\n ', tunable_type=ParticipantTypeSingle, default=ParticipantTypeSingle.Object), 'test_actor': TunableEnumEntry(description='\n The actor used to test Sims in the constraint relative to.\n ', tunable_type=ParticipantTypeSingle, default=ParticipantTypeSingle.Object), 'test_set': sims4.tuning.tunable.TunableReference(description='\n A test set instance that will be run on all Sims in the tuned\n constraint. If any Sims fail the test set instance, this test will\n fail.\n \n Note: A DoubleSimResolver will be used to run these tests. So the\n Test Actor will be the Actor participant, and Target will be a Sim\n in the constraint.\n ', manager=services.get_instance_manager(sims4.resources.Types.SNIPPET), class_restrictions=('TestSetInstance',))}
@classmethod
@assertions.not_recursive
def _validate_recursion(cls, test_set_instance, source, tunable_name):
for test_group in test_set_instance.test:
for test in test_group:
if isinstance(test, cls):
try:
cls._validate_recursion(test.test_set, source, tunable_name)
except AssertionError:
logger.error('{} is a test set instance in {}: {} but that creates a circular dependency', test.test_set, source, tunable_name, owner='rmccord')
def get_expected_args(self):
return {'constraint_targets': self.constraints_target, 'test_actors': self.test_actor}
@cached_test
def __call__(self, constraint_targets=(), test_actors=()):
test_actor = test_actors[0] if test_actors else None
sim_info_manager = services.sim_info_manager()
instanced_sims = list(sim_info_manager.instanced_sims_gen())
for target in constraint_targets:
if target.is_sim:
target = target.get_sim_instance()
if target is None:
continue
else:
total_constraint = Anywhere()
for tuned_constraint in self.constraints:
total_constraint = total_constraint.intersect(tuned_constraint.create_constraint(None, target))
if not total_constraint.valid:
return TestResult(False, 'Constraint {} relative to {} is invalid.', tuned_constraint, target, tooltip=self.tooltip)
object_constraint = interactions.constraints.Position(target._get_locations_for_posture_internal_forward_wall_padding(), routing_surface=target.routing_surface)
for sim in instanced_sims:
if not (total_constraint.geometry.test_transform(sim.transform) and (total_constraint.is_routing_surface_valid(sim.routing_surface) and (total_constraint.is_location_water_depth_valid(sim.location) and (total_constraint.is_location_terrain_tags_valid(sim.location) and not self.test_set(DoubleSimResolver(test_actor, sim.sim_info))))) and not (self.must_be_line_of_sight and sim.sim_info is test_actor)):
if not object_constraint.intersect(sim.lineofsight_component.constraint).valid:
continue
return TestResult(False, 'Sims In Constraint Test Failed.', tooltip=self.tooltip)
return TestResult.TRUE
|
from dataclasses import dataclass
from records import RecordBase
from tests.benchmarking.util import Benchmark
bm = Benchmark('construction')
class REC_Point(RecordBase):
x: float
y: float
z: int = 0
w: str = ""
@bm.measure(source=(REC_Point, ...), highlight=True)
def new_record():
REC_Point(x=12, y=3, w="hi")
@dataclass
class PYD_Point:
x: float
y: float
z: int = 0
w: str = ""
@bm.measure(source=(PYD_Point, ...))
def new_dataclass():
PYD_Point(x=12, y=3, w="hi")
if __name__ == '__main__':
print(bm.summary())
|
from website.addons.dropbox import model, routes, views
MODELS = [model.DropboxUserSettings, model.DropboxNodeSettings, model.DropboxFile]
USER_SETTINGS_MODEL = model.DropboxUserSettings
NODE_SETTINGS_MODEL = model.DropboxNodeSettings
ROUTES = [routes.auth_routes, routes.api_routes]
SHORT_NAME = 'dropbox'
FULL_NAME = 'Dropbox'
OWNERS = ['user', 'node']
ADDED_DEFAULT = []
ADDED_MANDATORY = []
VIEWS = []
CONFIGS = ['user', 'node']
CATEGORIES = ['storage']
# TODO: Deprecate in favor of webpack/CommonJS bundles
INCLUDE_JS = {
'widget': [],
'page': [],
'files': []
}
INCLUDE_CSS = {
'widget': [],
'page': [],
}
HAS_HGRID_FILES = True
GET_HGRID_DATA = views.hgrid.dropbox_addon_folder
# MAX_FILE_SIZE = 5 # MB
|
print ("hello world")
print ("123")
x =12
print (x)
|
#!/usr/bin/env python
"""Wrapper around curl to add HMAC signatures."""
import os
import subprocess
import sys
from lcp_mac import generate_authorization_header_value
def get_http_method(argv):
if '-X' not in argv:
return 'GET'
i = argv.index('-X')
return argv[i+1]
def get_url(argv):
for arg in argv:
if arg.startswith('http'):
return arg
def get_body(argv):
if '-d' not in argv:
return None
i = argv.index('-d')
return argv[i+1]
def get_creds(argv):
i = argv.index('-u')
return argv[i+1].split(':')
if __name__ == '__main__':
if '-u' not in sys.argv:
exit("Usage: %s -u <macKeyIdentifier>:<macKey> [curl options...] <url>" % os.path.basename(__file__))
method = get_http_method(sys.argv)
if method in ['POST', 'PUT', 'PATCH']:
content_type = "application/json"
else:
content_type = ''
key_id, shared_secret = get_creds(sys.argv)
url = get_url(sys.argv)
auth_hdr_value = generate_authorization_header_value(
method,
url,
key_id,
shared_secret,
content_type,
get_body(sys.argv))
cmdline = ["curl"]
cmdline += ["-H", "Authorization: %s" % auth_hdr_value]
if content_type:
cmdline += ["-H", "Content-Type: %s" % content_type]
cmdline += sys.argv[1:]
print "Executing: ", ' '.join(cmdline)
subprocess.call(cmdline)
|
# TimeConver.pt
# Using the Python language, have the function TimeConvert(num) take the num parameter being passed and return the number of hours and minutes the parameter converts to (ie. if num = 63 then the output should be 1:3). Separate the number of hours and minutes with a colon.
def TimeConvert(num):
int_num = int(num)
hour = int_num / 60
minuts = int_num % 60
# code goes here
return str(hour) + ":" + str(minuts)
# keep this function call here
print TimeConvert(raw_input())
|
import matplotlib.pyplot as plt
import numpy as np
def kernel(x, t):
return np.exp(-x**2/(4*t))
xx = np.linspace(0, 2, 100)
t = 0.5
plt.plot(xx, kernel(xx, t))
for x in np.linspace(0, 2, 11):
if x:
"""if x<0.3:
plt.plot([x, x], [0, kernel(x, t)], 'r--')"""
plt.plot([x, x], [0, kernel(x, t)], 'b--')
plt.show()
|
"""
Funções - def em Python (Parte 2)
"""
def divisao(n1, n2):
if n2 > 0:
resultado = n1 / n2
return resultado
divide = divisao(8, 1)
if divide:
print(divide)
else:
print('Conta não válida')
def funcao(var):
print(var)
variavel = funcao
variavel('Teste')
|
JSON_API_HEADERS = {
'Content-Type': 'application/vnd.api+json',
'Accept': 'application/vnd.api+json'
} |
# Copyright 2017 Cloudbase Solutions Srl
# 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.
"""
Unit tests for Windows Hyper-V QoS Driver.
"""
import mock
from neutron.services.qos import qos_consts
from networking_hyperv.neutron.qos import qos_driver
from networking_hyperv.tests import base
class TestQosHyperVAgentDriver(base.BaseTestCase):
@mock.patch.object(qos_driver.QosHyperVAgentDriver, '__init__',
lambda *args, **kwargs: None)
def setUp(self):
super(TestQosHyperVAgentDriver, self).setUp()
self.driver = qos_driver.QosHyperVAgentDriver()
self.driver._utils = mock.Mock()
@mock.patch.object(qos_driver, 'networkutils')
def test_initialize(self, mock_networkutils):
self.driver.initialize()
mock_networkutils.NetworkUtils.assert_called_once_with()
@mock.patch.object(qos_driver.QosHyperVAgentDriver, '_get_policy_values')
def test_create(self, mock_get_policy_values):
self.driver.create({'port_id': mock.sentinel.port_id},
mock.sentinel.qos_policy)
mock_get_policy_values.assert_called_once_with(
mock.sentinel.qos_policy)
self.driver._utils.set_port_qos_rule.assert_called_once_with(
mock.sentinel.port_id, mock_get_policy_values.return_value)
@mock.patch.object(qos_driver.QosHyperVAgentDriver, '_get_policy_values')
def test_update(self, mock_get_policy_values):
self.driver.update({'port_id': mock.sentinel.port_id},
mock.sentinel.qos_policy)
mock_get_policy_values.assert_called_once_with(
mock.sentinel.qos_policy)
self.driver._utils.set_port_qos_rule.assert_called_once_with(
mock.sentinel.port_id, mock_get_policy_values.return_value)
def test_delete(self):
self.driver.delete({'port_id': mock.sentinel.port_id})
self.driver._utils.remove_port_qos_rule.assert_called_once_with(
mock.sentinel.port_id)
def test_get_policy_values(self):
qos_rule_0 = mock.Mock(spec=['min_kbps', 'rule_type'])
qos_rule_0.rule_type = qos_consts.RULE_TYPE_MINIMUM_BANDWIDTH
qos_rule_1 = mock.Mock(spec=['max_kbps', 'max_burst_kbps',
'rule_type'])
qos_rule_1.rule_type = qos_consts.RULE_TYPE_BANDWIDTH_LIMIT
qos_policy = mock.Mock(rules=[qos_rule_0, qos_rule_1])
expected_val = dict(min_kbps=qos_rule_0.min_kbps,
max_kbps=qos_rule_1.max_kbps,
max_burst_kbps=qos_rule_1.max_burst_kbps)
policy_val = self.driver._get_policy_values(qos_policy)
self.assertEqual(expected_val, policy_val)
|
"""General utilities"""
import json
import datetime
import os
import re
import sys
from .exceptions import CloudPassageValidation
from .exceptions import CloudPassageAuthentication
from .exceptions import CloudPassageAuthorization
from .exceptions import CloudPassageResourceExistence
from .exceptions import CloudPassageGeneral
from .exceptions import CloudPassageRateLimit
from distutils.version import LooseVersion
from .sanity import is_it_a_string
class Utility(object):
@classmethod
def determine_policy_metadata(cls, policy):
"""Return dict of policy type, name, and target platform.
If string, attempts to convert to dict to parse.
Possible return values for policy_type:
CSM -- Configuration Security Monitoring
FIM -- File Integrity Monitoring
LIDS -- Log Intrusion Detection System
Firewall -- Firewall Policy
None -- Unable to determine poolicy type
Possible return values for target_platform:
Windows
Linux
None
Example:
determine_policy_type(string_from_file)
{"policy_type": "CSM",
"policy_name": "Test policy",
"target_platform": "Windows"}
Args:
policy (str or dict): Policy in string or dict form.
Returns:
dict
"""
working_pol = None
return_body = {"policy_type": None,
"policy_name": None,
"target_platform": None}
if is_it_a_string(policy):
working_pol = json.loads(policy)
elif isinstance(policy, dict):
working_pol = policy.copy()
else:
print("Policy type must be str or dict, not %s!" % type(policy))
try:
derived_type = list(working_pol.items())[0][0]
if derived_type == "fim_policy":
return_body["policy_type"] = "FIM"
if derived_type == "policy":
return_body["policy_type"] = "CSM"
if derived_type == "lids_policy":
return_body["policy_type"] = "LIDS"
if derived_type == "firewall_policy":
return_body["policy_type"] = "Firewall"
except AttributeError:
pass
try:
return_body["policy_name"] = list(working_pol.items())[0][1]["name"] # NOQA
except AttributeError:
pass
try:
derived_platform = list(working_pol.items())[0][1]["platform"]
if derived_platform == 'linux':
return_body["target_platform"] = 'Linux'
elif derived_platform == 'windows':
return_body["target_platform"] = 'Windows'
except AttributeError:
pass
return return_body
@classmethod
def assemble_search_criteria(cls, supported_search_fields, arguments):
"""Verifies request params and returns a dict of validated arguments"""
request_params_raw = {}
for param in supported_search_fields:
if param in arguments:
request_params_raw[param] = arguments[param]
request_params = cls.sanitize_url_params(request_params_raw)
return request_params
@classmethod
def sanitize_url_params(cls, params):
"""Sanitize URL arguments for the Halo API
In most cases, the Halo API will only honor the last value
in URL arguments when multiple arguments have the same key.
For instance: Requests builds URL arguments from a list a little
strangely:
{key:[val1, val2]}
becomes key=val1&key=val2
and not key=val1,val2. If we let a
list type object slide through, only val2 will be evaluated, and
val1 is ignored by the Halo API.
Args:
params (dict): Parameters to be sanitized.
Returns:
dict
"""
params_working = params.copy()
for key, value in params_working.items():
if isinstance(value, list):
value_corrected = ",".join(value)
params[key] = value_corrected
elif isinstance(value, datetime.datetime):
value_corrected = cls.datetime_to_8601(value)
params[key] = value_corrected
elif value is True:
params[key] = "true"
elif value is False:
params[key] = "false"
return params
@classmethod
def policy_to_dict(cls, policy):
"""Ensure that policy is a dictionary object"""
if isinstance(policy, dict):
return policy
else:
return json.loads(policy)
@classmethod
def merge_dicts(cls, first, second):
"""Merges dictionaries"""
final = first.copy()
final.update(second)
return final
@classmethod
def verify_pages(cls, max_pages):
"""Verify the user isn't trying to pull too many pages in one query"""
valid = True
fail_msg = None
if not isinstance(max_pages, int):
fail_msg = "Type wrong for max_pages. Should be int."
return(False, fail_msg)
if max_pages > 300:
fail_msg = "You're asking for too many pages. 300 max."
return(False, fail_msg)
return(valid, fail_msg)
@classmethod
def parse_status(cls, url, resp_code, resp_text):
"""Parse status from HTTP response"""
success = True
exc = None
if resp_code not in [200, 201, 202, 204]:
success = False
bad_statuses = {400: CloudPassageValidation(resp_text, code=400),
401: CloudPassageAuthentication(resp_text,
code=401),
404: CloudPassageResourceExistence(resp_text,
code=404,
url=url),
403: CloudPassageAuthorization(resp_text,
code=403),
422: CloudPassageValidation(resp_text, code=422),
429: CloudPassageRateLimit(resp_text, code=429)}
if resp_code in bad_statuses:
return(success, bad_statuses[resp_code])
else:
return(success, CloudPassageGeneral(resp_text, code=resp_code))
return success, exc
@classmethod
def time_string_now(cls):
"""Returns an ISO 8601 formatted string for now, in UTC
Returns:
str: ISO 8601 formatted string
"""
now = datetime.datetime.utcnow()
return cls.datetime_to_8601(now)
@classmethod
def datetime_to_8601(cls, original_time):
"""Converts a datetime object to ISO 8601 formatted string.
Args:
dt (datetime.datetime): Datetime-type object
Returns:
str: ISO 8601 formatted string
"""
time_split = (original_time.year, original_time.month,
original_time.day, original_time.hour,
original_time.minute, original_time.second,
original_time.microsecond)
return "%04d-%02d-%02dT%02d:%02d:%02d.%06dZ" % time_split
@classmethod
def verify_python_version(cls, act_version, target_version):
"""Verifies that the installed version of Python meets requirements
Args:
str: Actual version, represented as a dotted string "2.4.9"
dict: Target minimum versions, Keys are major versions.
Values are represented as a dotted string "2.7.10"
Returns:
bool: True if it meets or exceeds the target minimum version.
"""
maj_ver = act_version[0]
try:
if (LooseVersion(act_version) <
LooseVersion(target_version[maj_ver])):
return False
else:
return True
except KeyError:
return False
@classmethod
def get_installed_python_version(cls):
"""Returns the current version of Python as a dotted string"""
major, minor, micro = (sys.version_info.major, sys.version_info.minor,
sys.version_info.micro)
installed_python_version = "{maj}.{min}.{mic}".format(maj=major,
min=minor,
mic=micro)
return installed_python_version
@classmethod
def get_sdk_version(cls):
""" Gets the version of the SDK """
thisdir = os.path.dirname(__file__)
initfile = os.path.join(thisdir, "__init__.py")
with open(initfile, 'r') as i_file:
raw_init_file = i_file.read()
rx_compiled = re.compile(r"\s*__version__\s*=\s*\"(\S+)\"")
ver = rx_compiled.search(raw_init_file).group(1)
return ver
|
import tensorflow as tf
import numpy as np
from PIL import Image
from tensorflow.keras import layers
import os
import matplotlib.pyplot as plt
from tensorflow.keras.applications import VGG16,MobileNet
from tensorflow.keras.applications import imagenet_utils
from tensorflow.keras.preprocessing.image import load_img
from tensorflow.keras.preprocessing.image import img_to_array
inputShape=(224,224)
preprocess=imagenet_utils.preprocess_input
model=VGG16(weights="imagenet")
model.summary()
|
import functools
from app.master.cluster_master import ClusterMaster
from app.subcommands.service_subcommand import ServiceSubcommand
from app.util import analytics, log
from app.util.conf.configuration import Configuration
from app.web_framework.cluster_master_application import ClusterMasterApplication
class MasterSubcommand(ServiceSubcommand):
_THREAD_NAME = 'MasterTornadoThread'
def async_run(self, port, log_level, eventlog_file):
"""
Run a ClusterRunner master service.
:param port: the port on which to run the slave service
:type port: int | None
:param log_level: the log level at which to do application logging (or None for default log level)
:type log_level: str | None
:param eventlog_file: an optional alternate file in which to write event logs
:type eventlog_file: str | None
"""
port = port or Configuration['port']
log_level = log_level or Configuration['log_level']
eventlog_file = eventlog_file or Configuration['eventlog_file']
log.configure_logging(log_level=log_level, log_file=Configuration['log_file'])
analytics.initialize(eventlog_file)
analytics.record_event(analytics.SERVICE_STARTED, service='master')
cluster_master = ClusterMaster()
application = ClusterMasterApplication(cluster_master)
ioloop = self._start_application(application, port)
self._write_pid_file(Configuration['master_pid_file'])
# log startup message once ioloop is running
hostname = Configuration['hostname']
log_startup = functools.partial(self._logger.info, 'Master service is running on {}:{}.'.format(hostname, port))
ioloop.add_callback(log_startup)
# start heartbeat tracker once ioloop starts
start_master_heartbeat_tracker = functools.partial(cluster_master.start_heartbeat_tracker_thread)
ioloop.add_callback(start_master_heartbeat_tracker)
ioloop.start() # this call blocks until the server is stopped
ioloop.close(all_fds=True) # all_fds=True is necessary here to make sure connections don't hang
self._logger.notice('Master server was stopped.')
|
# 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 oslo_serialization import jsonutils
from cinder.tests.functional.api_sample_tests import test_volumes
class VolumeTransferSampleJsonTest(test_volumes.VolumesSampleBase):
sample_dir = "volume_transfer"
def setUp(self):
super(VolumeTransferSampleJsonTest, self).setUp()
res = self._create_volume()
res = jsonutils.loads(res.content)['volume']
self._poll_volume_while(res['id'], ['creating'])
self.subs = {
"volume_id": res['id']
}
self.response = self._create_transfer(self.subs)
def _create_transfer(self, subs=None):
response = self._do_post('os-volume-transfer',
'volume-transfer-create-request',
subs)
return response
def test_transfer_create(self):
self._verify_response('volume-transfer-create-response',
{}, self.response, 202)
def test_transfer_accept(self):
res = jsonutils.loads(self.response.content)['transfer']
subs = {
"auth_key": res['auth_key']
}
response = self._do_post(
'os-volume-transfer/%s/accept' % res['id'],
'volume-transfer-accept-request',
subs)
self._verify_response('volume-transfer-accept-response',
{}, response, 202)
def test_transfers_list(self):
response = self._do_get('os-volume-transfer')
self._verify_response('volume-transfers-list-response',
{}, response, 200)
def test_transfer_list_detail(self):
res = jsonutils.loads(self.response.content)['transfer']
response = self._do_get('os-volume-transfer/%s' % res['id'])
self._verify_response('volume-transfer-show-response',
{}, response, 200)
def test_transfers_list_detail(self):
response = self._do_get('os-volume-transfer/detail')
self._verify_response('volume-transfers-list-detailed-response',
{}, response, 200)
|
"""
2021/02/20 writen by Runze Dong
Multiple Eavesdroppers Scenario
"""
from fun_multiEve import *
from tensorflow.python.keras.layers import *
# import os
# os.environ['CUDA_VISIBLE_DEVICES'] = '2,3'
P_a = np.expand_dims(10**(np.linspace(-10, 10, 11)/10)/(beta_0*d_b**(-1*eta_b))*delta_[1, :], 0)
R_s1 = np.zeros([1, P_a.shape[1]])
path = './data/1/'
H_bta, H_eta, H_bka, H_eka = load_mat(path)
H_eta2 = io.loadmat('./data/multiEve/H_et2.mat')['H_et']
H_eka2 = io.loadmat('./data/multiEve/H_ek2.mat')['H_ek']
H_eta3 = io.loadmat('./data/multiEve/H_et3.mat')['H_et']
H_eka3 = io.loadmat('./data/multiEve/H_ek3.mat')['H_ek']
for i in range(0, P_a.shape[1]):
# for i in range(0, 1):
P_a0 = P_a[0, i]
H_bt, H_et, H_bk, H_ek = H_bta[0:N, :, :], H_eta[0:N, :, :], H_bka[0:N, :, :], H_eka[0:N, :, :]
H_et2, H_ek2, H_et3, H_ek3 = H_eta2[0:N, :, :], H_eka2[0:N, :, :], H_eta3[0:N, :, :], H_eka3[0:N, :, :]
H_b = np.concatenate([np.real(H_bk), np.imag(H_bk)], 1)
H_e = np.concatenate([np.real(H_ek), np.imag(H_ek)], 1)
H_e2 = np.concatenate([np.real(H_ek2), np.imag(H_ek2)], 1)
H_e3 = np.concatenate([np.real(H_ek3), np.imag(H_ek3)], 1)
H_input = np.concatenate([H_b, H_e, H_e2, H_e3], 1) # for input to the network
# define the input shape of the network
H_e_input = Input(name='H_e_input', shape=H_input.shape[1:3], dtype=tf.float32) # shape without batch_size
H_bt_input = Input(name='H_bt_input', shape=H_bt.shape[1:3], dtype=tf.complex64)
H_et_input = Input(name='H_et_input', shape=H_et.shape[1:3], dtype=tf.complex64)
H_et_input2 = Input(name='H_et2_input', shape=H_et.shape[1:3], dtype=tf.complex64)
H_et_input3 = Input(name='H_et3_input', shape=H_et.shape[1:3], dtype=tf.complex64)
snrb = Input(name='snr1', shape=(1,), dtype=tf.complex64)
snre = Input(name='snr2', shape=(1,), dtype=tf.complex64)
snre2 = Input(name='snr3', shape=(1,), dtype=tf.complex64)
snre3 = Input(name='snr4', shape=(1,), dtype=tf.complex64)
P_a1 = Input(name='P_a1', shape=(1,), dtype=tf.float32)
# t0 = Input(name='t0', shape=(1,), dtype=tf.complex64)
delta = Input(name='delta', shape=(1,), dtype=tf.complex64)
# define the network by functional model
x = BatchNormalization()(H_e_input)
x = Flatten()(x)
x = Dense(512, activation='sigmoid')(x)
x = Dense(256, activation='relu')(x)
f_G = Dense(2*N_x*N_y*(t+1))(x) # the front 2*N_x*N_y is for f
# f, G = Lambda(f_G_and_power)([f_G, P_a1])
f, G = Lambda(f_G_and_power)([f_G, P_a1])
Loss = Lambda(Loss_calculating)([f, G, H_bt_input, H_et_input, H_et_input2, H_et_input3, snrb, snre, snre2, snre3, delta])
model = Model(inputs=[H_e_input, H_bt_input, H_et_input, H_et_input2, H_et_input3, snrb, snre, snre2, snre3, delta, P_a1], outputs=Loss)
model.compile(optimizer='adam', loss=self_defined_mean)
# model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.summary()
y_train = np.zeros([N, 1])
P_a_input = np.expand_dims(np.repeat(P_a0, N), -1)
reduce_lr = callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, min_lr=0.00005)
ii = str(i+1)
print(ii)
checkpoint = callbacks.ModelCheckpoint('./output/multiEve/'+ii+'_trained.h5', monitor='val_loss',
verbose=1, save_best_only=True, mode='min')
model.fit(x=[H_input, H_bt, H_et, H_et2, H_et3, snr_b, snr_e, snr_e2, snr_e3, delta_, P_a_input], y=y_train, batch_size=8192,
epochs=100, verbose=1, validation_split=0.1, callbacks=[reduce_lr, checkpoint])
model.load_weights('./output/multiEve/'+ii+'_trained.h5')
model.summary()
H_bt1, H_et1, H_bk1, H_ek1 = H_bta[N:2*N, :, :], H_eta[N:2*N, :, :], H_bka[N:2*N, :, :], H_eka[N:2*N, :, :]
H_et2, H_ek2, H_et3, H_ek3 = H_eta2[N:2*N, :, :], H_eka2[N:2*N, :, :], H_eta3[N:2*N, :, :], H_eka3[N:2*N, :, :]
H_b = np.concatenate([np.real(H_bk1), np.imag(H_bk1)], 1)
H_e = np.concatenate([np.real(H_ek1), np.imag(H_ek1)], 1)
H_e2 = np.concatenate([np.real(H_ek2), np.imag(H_ek2)], 1)
H_e3 = np.concatenate([np.real(H_ek3), np.imag(H_ek3)], 1)
H_input = np.concatenate([H_b, H_e, H_e2, H_e3], 1) # for input to the network
# R_s = -model.predict([H_input, tf.cast(H_bt1, tf.complex64), tf.cast(H_et1, tf.complex64),
# tf. cast(snr_b, tf.complex64), tf.cast(snr_e, tf.complex64), tf.cast(delta_, tf.complex64)])
R_s = -model.predict([H_input, H_bt1, H_et1, H_et2, H_et3, snr_b, snr_e, snr_e2, snr_e3, delta_, P_a_input])
R_s1[0, i] = np.mean(R_s)
io.savemat('./output/multiEve/R_s_py1.mat', {'R_s_py': R_s1})
print(R_s1)
|
from __future__ import absolute_import, division, print_function
import os, sys
import numbers
import random
import numpy as np
import copy
from PIL import Image
import PIL.Image as pil
import fire
from collections import defaultdict
import torch
import torch.nn.functional as F
from torch.utils.data import Dataset
from torchvision import transforms
import nearest_neighbors.lib.python.nearest_neighbors as nearest_neighbors
def gen_affinity(depth, mask, knn=9, r=2):
n, c, h, w = depth.shape
locs = []
nnidxs = []
for i in range(n):
# (M,2) -> (1,M,2)
loc = torch.nonzero(mask[i, 0]>0)
coords = loc.float()
M = coords.size(0)
dev = coords.device
coords = coords.unsqueeze(0).detach().cpu().numpy()
# (M,1), (M, r*knn)
depths = depth[i, 0, loc[:,0], loc[:,1]].unsqueeze(1)
nnidx = nearest_neighbors.knn_batch(coords, coords, knn*r, omp=True)[0]
# distance (M, r*knn)
nnidx = torch.from_numpy(nnidx).to(dev)
nnidx_flat = nnidx.flatten().long()
sel_depths = depths[nnidx_flat,0].reshape(M, r*knn)
sel_depths_dist = torch.abs(depths - sel_depths)
# (M, r*knn) -> (M, knn)
sel_idx = torch.argsort(sel_depths_dist, dim=1, descending=False)
sel_idx = sel_idx[:,:knn]
nnidx_new = torch.gather(nnidx, 1, sel_idx)
locs.append(loc)
nnidxs.append(nnidx_new.long())
return locs, nnidxs
def depth_down(input_d, mask, k):
return F.avg_pool2d(input_d, k, k) / (F.avg_pool2d(mask, k, k) + 0.0001)
def pil_loader(path):
# open path as file to avoid ResourceWarning
# (https://github.com/python-pillow/Pillow/issues/835)
with open(path, 'rb') as f:
with Image.open(f) as img:
return img.convert('RGB')
def norm_depth(depth, min_depth, max_depth):
norm_depth = np.clip(depth, min_depth, max_depth)
return norm_depth
class BottomCrop(object):
"""Crops the given ``numpy.ndarray`` at the bottom.
Args:
size (sequence or int): Desired output size of the crop. If size is an
int instead of sequence like (h, w), a square crop (size, size) is
made.
"""
def __init__(self, size):
if isinstance(size, numbers.Number):
self.size = (int(size), int(size))
else:
self.size = size
@staticmethod
def get_params(img, output_size):
"""Get parameters for ``crop`` for bottom crop.
Args:
img (numpy.ndarray (C x H x W)): Image to be cropped.
output_size (tuple): Expected output size of the crop.
Returns:
tuple: params (i, j, h, w) to be passed to ``crop`` for bottom crop.
"""
h = img.shape[1]
w = img.shape[2]
th, tw = output_size
i = h - th
j = int(round((w - tw) / 2.))
return i, j, th, tw
def __call__(self, img):
"""
Args:
img (C x H x W): Image to be cropped
Returns:
img (C x H x W): Cropped image.
"""
i, j, h, w = self.get_params(img, self.size)
"""
i: Upper pixel coordinate.
j: Left pixel coordinate.
h: Height of the cropped image.
w: Width of the cropped image.
"""
def _is_tensor_image(img):
return torch.is_tensor(img) and img.ndimension() == 3
if not _is_tensor_image(img):
raise TypeError('img should be ndarray. Got {}'.format(type(img)))
return img[:, i:i + h, j:j + w]
def aug_pil_img(im):
choice = np.random.randint(0, 4)
if choice == 0:
new_im = transforms.ColorJitter(brightness=0.5)(im)
elif choice == 1:
new_im = transforms.ColorJitter(contrast=0.5)(im)
elif choice == 2:
new_im = transforms.ColorJitter(saturation=0.5)(im)
elif choice == 3:
new_im = transforms.ColorJitter(hue=0.3)(im)
return new_im
def generate_xyzm_map(mask, xyz_map):
mask = np.expand_dims(mask, 0)
xyz_map = np.transpose(xyz_map, [2, 0, 1])
xyzm_map = np.concatenate([xyz_map, mask], 0)
return xyzm_map
class MonoDataset(Dataset):
def __init__(self,
data_path,
filenames,
crop_h,
crop_w,
min_depth=0.1,
max_depth=100,
img_ext='.jpg'):
super(MonoDataset, self).__init__()
self.data_path = data_path
self.filenames = filenames
self.crop_h = crop_h
self.crop_w = crop_w
self.interp = Image.ANTIALIAS
self.min_depth = min_depth
self.max_depth = max_depth
self.img_ext = img_ext
self.loader = pil_loader
self.to_tensor = transforms.ToTensor() # (H x W x C) [0, 255] -> (C x H x W) [0.0, 1.0]
self.load_depth = self.check_depth()
self.load_depth_sd = self.check_depth_sd()
def crop_img(self, img):
assert img.size(1) >= self.crop_h, "[{}<{}]".format(img.size(1), self.crop_h)
assert img.size(2) >= self.crop_w, "[{}<{}]".format(img.size(2), self.crop_w)
transform = transforms.Compose([
BottomCrop((self.crop_h, self.crop_w)),
])
return transform(img)
def __len__(self):
# left and right
return len(self.filenames) * 2
def __getitem__(self, _index):
"""Returns a single training item from the dataset as a dictionary.
"""
inputs = {}
do_color_aug = random.random() > 0.5
do_flip = random.random() > 0.5
do_disp_aug = random.random() > 0.5
index, side = (_index,"l") if _index < len(self.filenames) else (_index-len(self.filenames),"r")
line = self.filenames[index].split()
folder = line[0]
frame_index = int(line[1])
inputs['folder'] = folder
inputs['frame_index'] = frame_index
inputs['side'] = side
inputs["color"] = self.get_color(folder, frame_index, side, do_flip)
if do_color_aug:
color_aug = aug_pil_img
else:
color_aug = (lambda x: x)
f = inputs["color"]
inputs["color"] = self.crop_img(self.to_tensor(f))
inputs["color_aug"] = self.crop_img(self.to_tensor(color_aug(f)))
if self.load_depth:
depth_gt = self.get_depth(folder, frame_index, side, do_flip)
depth_gt = np.expand_dims(depth_gt, 0)
depth_gt_norm = norm_depth(depth_gt, self.min_depth, self.max_depth)
inputs["depth_gt"] = torch.from_numpy(depth_gt_norm.astype(np.float32))
inputs["depth_gt"] = self.crop_img(inputs["depth_gt"])
if do_disp_aug:
depth_aug = np.random.normal(0, 0.01, depth_gt.shape) * (depth_gt > 0.1) + depth_gt
else:
depth_aug = depth_gt
depth_aug_norm = norm_depth(depth_aug, self.min_depth, self.max_depth)
inputs["depth_aug"] = torch.from_numpy(depth_aug_norm.astype(np.float32))
inputs["depth_aug"] = self.crop_img(inputs["depth_aug"])
inputs['mask'] = (inputs["depth_aug"] > 0.1).float()
if self.load_depth_sd:
depth_gt_sd = self.get_depth_sd(folder, frame_index, side, do_flip)
depth_sd_gt = np.expand_dims(depth_gt_sd, 0)
depth_sd_gt_norm = norm_depth(depth_sd_gt, self.min_depth, self.max_depth)
inputs["depth_sd_gt"] = torch.from_numpy(depth_sd_gt_norm.astype(np.float32))
inputs["depth_sd_gt"] = self.crop_img(inputs["depth_sd_gt"])
sdepth = inputs['depth_gt'].unsqueeze(0) # (1, 1, H, W)
mask = inputs['mask'].unsqueeze(0)
sdepthx2, maskx2 = depth_down(sdepth, mask, 2), F.max_pool2d(mask, 2, 2)
sdepthx4, maskx4 = depth_down(sdepth, mask, 4), F.max_pool2d(maskx2, 2, 2)
sdepthx8, maskx8 = depth_down(sdepth, mask, 8), F.max_pool2d(maskx4, 2, 2)
#
aff_locsx1, aff_nnidxsx1 = gen_affinity(sdepth, mask)
inputs['aff_locsx1'], inputs['aff_nnidxsx1'] = aff_locsx1[0], aff_nnidxsx1[0]
aff_locsx2, aff_nnidxsx2 = gen_affinity(sdepthx2, maskx2)
inputs['aff_locsx2'], inputs['aff_nnidxsx2'] = aff_locsx2[0], aff_nnidxsx2[0]
aff_locsx4, aff_nnidxsx4 = gen_affinity(sdepthx4, maskx4)
inputs['aff_locsx4'], inputs['aff_nnidxsx4'] = aff_locsx4[0], aff_nnidxsx4[0]
aff_locsx8, aff_nnidxsx8 = gen_affinity(sdepthx8, maskx8)
inputs['aff_locsx8'], inputs['aff_nnidxsx8'] = aff_locsx8[0], aff_nnidxsx8[0]
inputs['maskx2'] = maskx2[0]
inputs['maskx4'] = maskx4[0]
inputs['maskx8'] = maskx8[0]
return inputs
def get_color(self, folder, frame_index, side, do_flip):
raise NotImplementedError
def check_depth(self):
raise NotImplementedError
def check_depth_sd(self):
raise NotImplementedError
def get_depth(self, folder, frame_index, side, do_flip):
raise NotImplementedError
def get_depth_sd(self, folder, frame_index, side, do_flip):
raise NotImplementedError
class KITTIDataset(MonoDataset):
"""Superclass for different types of KITTI dataset loaders
"""
def __init__(self, *args, **kwargs):
super(KITTIDataset, self).__init__(*args, **kwargs)
self.full_res_shape = (1242, 375)
self.side_map = {"2": 2, "3": 3, "l": 2, "r": 3}
def check_depth(self):
line = self.filenames[0].split()
scene_name = line[0].split("/")[1]
frame_index = int(line[1])
velo_filename = os.path.join(
self.data_path,
"data_depth_annotated/",
scene_name,
"proj_depth/velodyne_raw/image_0{}/{:010d}.png".
format("2", int(frame_index)))
return os.path.isfile(velo_filename)
def check_depth_sd(self):
line = self.filenames[0].split()
scene_name = line[0].split("/")[1]
frame_index = int(line[1])
velo_filename = os.path.join(
self.data_path,
"data_depth_annotated/",
scene_name,
"proj_depth/groundtruth/image_0{}/{:010d}.png".
format("2", int(frame_index)))
return os.path.isfile(velo_filename)
def get_color(self, folder, frame_index, side, do_flip):
color = self.loader(self.get_image_path(folder, frame_index, side))
if do_flip:
color = color.transpose(pil.FLIP_LEFT_RIGHT)
return color
class KITTIRAWDataset(KITTIDataset):
"""KITTI dataset which loads the original velodyne depth maps for ground truth
"""
def __init__(self, *args, **kwargs):
super(KITTIRAWDataset, self).__init__(*args, **kwargs)
def get_image_path(self, folder, frame_index, side):
f_str = "{:010d}{}".format(frame_index, self.img_ext)
image_path = os.path.join(
self.data_path,
"raw",
folder,
"image_0{}/data".format(self.side_map[side]), f_str)
return image_path
def get_depth(self, folder, frame_index, side, do_flip):
scene_name = folder.split("/")[1]
velo_filename = os.path.join(
self.data_path,
"data_depth_annotated/",
scene_name,
"proj_depth/velodyne_raw/image_0{}/{:010d}.png".
format(self.side_map[side], int(frame_index)))
depth_gt = self.depth_png_read(velo_filename)
if do_flip:
depth_gt = np.fliplr(depth_gt)
return depth_gt
def get_depth_sd(self, folder, frame_index, side, do_flip):
scene_name = folder.split("/")[1]
velo_filename = os.path.join(
self.data_path,
"data_depth_annotated/",
scene_name,
"proj_depth/groundtruth/image_0{}/{:010d}.png".
format(self.side_map[side], int(frame_index)))
depth_gt = self.depth_png_read(velo_filename)
if do_flip:
depth_gt = np.fliplr(depth_gt)
return depth_gt
def depth_png_read(self, filename):
# loads depth map D from png file
# and returns it as a numpy array,
depth_png = np.array(Image.open(filename), dtype=int)
# make sure we have a proper 16bit depth map here.. not 8bit!
assert(np.max(depth_png) > 255)
depth = depth_png.astype(np.float) / 256.
return depth
class DAT_VAL_TEST(Dataset):
def __init__(self,
data_path,
is_test=False,
min_depth=0.0,
max_depth=85,
crop_h=350,
crop_w=1200):
super(DAT_VAL_TEST, self).__init__()
self.data_path = data_path
self.min_depth = min_depth
self.max_depth = max_depth
self.crop_h = crop_h
self.crop_w = crop_w
self.to_tensor = transforms.ToTensor() # (H x W x C) [0, 255] -> (C x H x W) [0.0, 1.0]
self.loader = pil_loader
self.has_gt = not is_test
if is_test:
self.dir = 'test_depth_completion_anonymous'
self.filenames = ['{:010d}'.format(i) for i in range(1000)]
else:
self.dir = 'val_selection_cropped'
self.filenames = readlines('splits/val.txt')
def bottom_crop_input_data(self, inputs: dict, crop_h, crop_w):
keys = ['color', 'depth_gt', 'depth_sd_gt', 'depth_color', 'mask']
for k,v in inputs.items():
# v in format [C,H,W]
if k in keys:
h = v.shape[1]
w = v.shape[2]
i = h - crop_h
j = int(round((w - crop_w) / 2.))
inputs[k] = v[:, i:i + crop_h, j:j + crop_w]
def __getitem__(self, index):
inputs = {}
filename = self.filenames[index]
color = self.get_image(filename)
inputs['color'] = self.to_tensor(color)
f_str = "{}.png".format(filename)
if self.has_gt:
fname = f_str.replace("XXX", "velodyne_raw")
else:
fname = f_str
velo_path = os.path.join(
self.data_path,
self.dir, "velodyne_raw",
fname)
depth = self.get_depth(velo_path)
depth = depth.astype(np.float32)
inputs['depth_gt'] = torch.from_numpy(depth).unsqueeze(0)
inputs['mask'] = (inputs["depth_gt"] > 0).float()
if self.has_gt:
fname = f_str.replace("XXX", "groundtruth_depth")
gt_path = os.path.join(
self.data_path,
self.dir, "groundtruth_depth",
fname)
gtdepth = self.get_depth(gt_path)
gtdepth = gtdepth.astype(np.float32)
inputs['depth_sd_gt'] = torch.from_numpy(gtdepth).unsqueeze(0)
inputs['frame_index'] = filename
self.bottom_crop_input_data(inputs, self.crop_h, self.crop_w)
sdepth = inputs['depth_gt'].unsqueeze(0) # (1, 1, H, W)
mask = inputs['mask'].unsqueeze(0)
sdepthx2, maskx2 = depth_down(sdepth, mask, 2), F.max_pool2d(mask, 2, 2)
sdepthx4, maskx4 = depth_down(sdepth, mask, 4), F.max_pool2d(maskx2, 2, 2)
sdepthx8, maskx8 = depth_down(sdepth, mask, 8), F.max_pool2d(maskx4, 2, 2)
#
aff_locsx1, aff_nnidxsx1 = gen_affinity(sdepth, mask)
inputs['aff_locsx1'], inputs['aff_nnidxsx1'] = aff_locsx1[0], aff_nnidxsx1[0]
aff_locsx2, aff_nnidxsx2 = gen_affinity(sdepthx2, maskx2)
inputs['aff_locsx2'], inputs['aff_nnidxsx2'] = aff_locsx2[0], aff_nnidxsx2[0]
aff_locsx4, aff_nnidxsx4 = gen_affinity(sdepthx4, maskx4)
inputs['aff_locsx4'], inputs['aff_nnidxsx4'] = aff_locsx4[0], aff_nnidxsx4[0]
aff_locsx8, aff_nnidxsx8 = gen_affinity(sdepthx8, maskx8)
inputs['aff_locsx8'], inputs['aff_nnidxsx8'] = aff_locsx8[0], aff_nnidxsx8[0]
inputs['maskx2'] = maskx2[0]
inputs['maskx4'] = maskx4[0]
inputs['maskx8'] = maskx8[0]
return inputs
def __len__(self):
return len(self.filenames)
def get_image(self, filename):
f_str = "{}.png".format(filename)
if self.has_gt:
fname = f_str.replace("XXX", "image")
else:
fname = f_str
image_path = os.path.join(
self.data_path,
self.dir, "image",
fname)
color = self.loader(image_path)
return color
def get_depth(self, path):
depth_gt = self.depth_read(path)
depth_gt = norm_depth(depth_gt, self.min_depth, self.max_depth)
return depth_gt
def depth_read(self, filename):
# loads depth map D from png file
# and returns it as a numpy array,
depth_png = np.array(Image.open(filename), dtype=int)
# make sure we have a proper 16bit depth map here.. not 8bit!
assert(np.max(depth_png) > 255)
depth = depth_png.astype(np.float) / 256.
return depth
from torch.utils.data import DataLoader
from options import CompletionOptions
import matplotlib.pyplot as plt
def readlines(filename):
"""Read all the lines in a text file and return as a list
"""
with open(filename, 'r') as f:
lines = f.read().splitlines()
return lines
def plt_img(fig, h, w, i, p, img, itype='color'):
# itype: color, gray, depth
fig.add_subplot(h, w, i)
timg = img.numpy()
timg = timg.transpose([1,2,0])
if itype == 'color':
cmap = None
elif itype == 'gray':
timg = timg.squeeze(2)
cmap = plt.get_cmap('gray')
elif itype == 'depth':
timg = timg.squeeze(2)
timg = (timg - np.min(timg)) / (np.max(timg) - np.min(timg))
mask = timg > 0
mask = np.expand_dims(mask, -1).astype(np.float32)
timg = 255 * plt.cm.jet(timg)[:, :, :3] # H, W, C
timg = timg * mask + (1-mask) * 255
timg = timg.astype('uint8')
cmap = None
elif itype == 'binary':
timg = timg.squeeze(2)
cmap = plt.get_cmap('binary')
p.imshow(timg, cmap=cmap)
p.xticks([0, timg.shape[1]])
p.yticks([0, timg.shape[0]])
def _merge_batch(batch_list, _unused=False):
example_merged = defaultdict(list)
for example in batch_list:
for k, v in example.items():
example_merged[k].append(v)
ret = {}
e_keys = ['folder', 'frame_index', 'side']
for key, elems in example_merged.items():
if key in e_keys or 'aff_' in key:
ret[key] = elems
else:
# [A,B] + [A,B] -> [2,A,B]
ret[key] = torch.stack(elems, dim=0)
return ret
class TestR:
def __init__(self):
super(TestR, self).__init__()
options = CompletionOptions()
print(sys.argv)
print(sys.argv[2:])
self.opt = options.parse(sys.argv[2:-1])
self.dataset = KITTIRAWDataset
fpath = os.path.join(os.path.dirname(__file__), "splits", self.opt.split, "{}_files.txt")
train_filenames = readlines(fpath.format("train"))
val_filenames = readlines(fpath.format("val"))
img_ext = '.png' if self.opt.png else '.jpg'
self.opt.batch_size = 2
self.opt.num_workers = 1
self.opt.crop_h = 256
self.opt.crop_w = 1216
train_dataset = self.dataset(
self.opt.data_path, train_filenames, self.opt.crop_h, self.opt.crop_w,
img_ext=img_ext, min_depth=self.opt.min_depth, max_depth=self.opt.max_depth)
self.train_loader = DataLoader(
train_dataset, self.opt.batch_size, True, collate_fn=_merge_batch,
num_workers=self.opt.num_workers, pin_memory=True, drop_last=True)
val_dataset = self.dataset(
self.opt.data_path, val_filenames, self.opt.crop_h, self.opt.crop_w,
img_ext=img_ext, min_depth=self.opt.min_depth, max_depth=self.opt.max_depth)
self.val_loader = DataLoader(
val_dataset, self.opt.batch_size, False, collate_fn=_merge_batch,
num_workers=self.opt.num_workers, pin_memory=True, drop_last=True)
print("Using split:\n ", self.opt.split)
print("There are {:d} training items and {:d} validation items\n".format(
len(train_dataset), len(val_dataset)))
def run(self):
for loader in [self.train_loader, self.val_loader]:
for batch_idx, inputs in enumerate(loader):
print(batch_idx, inputs.keys())
fig = plt.figure(num=batch_idx, figsize=(12, 4))
plt_img(fig, 3, 2, 1, plt, inputs['mask'][0], itype='binary')
plt_img(fig, 3, 2, 2, plt, inputs['color_aug'][0])
plt_img(fig, 3, 2, 3, plt, inputs['depth_aug'][0], itype='depth')
plt_img(fig, 3, 2, 4, plt, inputs['depth_sd_gt'][0], itype='depth')
plt_img(fig, 3, 2, 5, plt, inputs['color'][0])
print(inputs['folder'][0], inputs['frame_index'][0], inputs['side'][0])
print(inputs['folder'][1], inputs['frame_index'][1], inputs['side'][1])
print('aff_locsx2', inputs['aff_locsx2'][0].shape)
print('aff_nnidxsx8', inputs['aff_nnidxsx8'][1].shape)
plt.tight_layout()
plt.show()
class TestC:
def __init__(self):
super(TestC, self).__init__()
options = CompletionOptions()
print(sys.argv)
print(sys.argv[2:])
self.opt = options.parse(sys.argv[2:-1])
self.dataset = DAT_VAL_TEST
self.opt.data_path = '/data/KITTI_DAT'
self.opt.batch_size = 2
self.opt.num_workers = 1
self.test_dataset = self.dataset(
self.opt.data_path, is_test=True,
min_depth=self.opt.min_depth, max_depth=self.opt.max_depth)
self.test_loader = DataLoader(
self.test_dataset, self.opt.batch_size, False, collate_fn=_merge_batch,
num_workers=self.opt.num_workers, pin_memory=True, drop_last=True)
print("There are {:d} items\n".format(len(self.test_dataset)))
def run(self):
for loader in [self.test_loader]:
for batch_idx, inputs in enumerate(loader):
print(batch_idx, inputs.keys())
fig = plt.figure(num=batch_idx)
plt_img(fig, 2, 2, 1, plt, inputs['color'][0])
plt_img(fig, 2, 2, 2, plt, inputs['depth_gt'][0], itype='depth')
plt_img(fig, 2, 2, 3, plt, inputs['mask'][0], itype='binary')
if self.test_dataset.has_gt:
plt_img(fig, 2, 2, 4, plt, inputs['depth_sd_gt'][0], itype='depth')
print('aff_locsx4', inputs['aff_locsx4'][0].shape)
print('aff_nnidxsx2', inputs['aff_nnidxsx2'][1].shape)
plt.tight_layout()
plt.show()
def testr():
test = TestR()
test.run()
def testc():
test = TestC()
test.run()
if __name__ == "__main__":
fire.Fire()
|
#Retrieving coin information from coingecko, creating a coin_names ls
# See https://www.coingecko.com/en/api
from pycoingecko import CoinGeckoAPI
cg = CoinGeckoAPI()
coin_list = cg.get_coins_list()
coin_names = {}
for coin in coin_list:
name = coin['name']
coin_id = coin['id']
coin_names[name] = coin_id
#Retrieve the names of the pdfs we farmed using pydrive. Note you need a client secret key for this.
# See https://pythonhosted.org/PyDrive/quickstart.html
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
gauth = GoogleAuth()
gauth.LocalWebserverAuth()
drive = GoogleDrive(gauth)
#Find drive name
drive_id = '1D7lco7MJxvesBEqxc5-qAn_KF7FKUeDV' #id for our shared drive
file_list = drive.ListFile({'q': "'1D7lco7MJxvesBEqxc5-qAn_KF7FKUeDV' in parents and trashed=false"}).GetList()
for file1 in file_list:
print('title: %s, id: %s' % (file1['title'], file1['id']))
# title: whitepaper_pdf4, id: 1XxUoFz1-xfJC5r6O66VLhF3liTCRpjH_
# title: whitepaper_pdf3, id: 1qpyDrXbjCnnPSkSEWAfVPdDy3Lk0AX94
# title: whitepaper_pdfs2, id: 1gBcBJk_IeO2KMmqSvuQ8uxyTCXt-IJKh
# title: Whitepaper_pdfs, id: 19NQzctQhRIhuvBkieY3NFvpnckLwOVpT
#Creating a list of coin names from our pdfs called pdf_ls
pdf_ls = []
id4 = "'1XxUoFz1-xfJC5r6O66VLhF3liTCRpjH_'"
id3 = "'1qpyDrXbjCnnPSkSEWAfVPdDy3Lk0AX94'"
id2 = "'1gBcBJk_IeO2KMmqSvuQ8uxyTCXt-IJKh'"
id1 = "'19NQzctQhRIhuvBkieY3NFvpnckLwOVpT'"
id_ls = [id1, id2, id3]
def append_id(id, ls):
file_list = drive.ListFile({'q': f'{id} in parents and trashed=false'}).GetList()
for file1 in file_list:
ls.append(file1['title'])
for id in id_ls:
append_id(id, pdf_ls)
#Handling carol's folder
import re
pdf4_ls = []
append_id(id4, pdf4_ls)
def retrieve_name(text):
pattern = re.compile(r'(?<=\\)(.*?)(?=_)')
m = re.search(pattern, text)
name = m.group(0).split('\\')[-1]
return name
pdf4_ls_edit = [retrieve_name(title) for title in pdf4_ls]
for name in pdf4_ls_edit:
pdf_ls.append(name)
#ALternative method
# Fresh download of carol's assigned pdfs, manual download the remaining pdfs from our gdrive and combine them into a folder called 'combined'
import os
pdf_ls = os.listdir('combined')
#Matching our pdf_ls with the coin_names from coin gecko
def standardise(name):
"""
This function takes in a name tries to standardise the names as much as possible by removing spaces, werid characters to ensure proper matching.
"""
if '(' in name:
name = name.split('(')[0]
if '[' in name:
name = name.split('[')[0]
name = name.replace('#', '')
name = name.replace('-', '')
name = name.replace('?', '-')
name = name.replace('/', '-')
name = name.replace(' ', '')
name = name.replace(' ', '')
name = name.lower()
return name
#Create a standardised version of both list
pdf_ls_standardised = [standardise(x) for x in pdf_ls]
coin_names_standardised = [standardise(x) for x in coin_names.keys()]
#These dics helps us retrieve back the unstandardized version later
pdf_dic = dict(zip(pdf_ls_standardised, pdf_ls))
coin_dic = dict(zip(coin_names_standardised, coin_names))
#checking how many match between the two lists using sets in python
match_set = set(pdf_ls_standardised).intersection(set(coin_names_standardised))
print(len(match_set)) #889 matched
matchless_set = set(pdf_ls_standardised) - set(coin_names_standardised)
print(matchless_set)
#create a dataframe which contains coin_name and coin_id
import pandas as pd
pdf_final = []
coin_final = []
match_ls = sorted(list(match_set))
for name in match_ls:
pdf_final.append(pdf_dic[name])
coin_final.append(coin_dic[name])
len(pdf_final) == len(coin_final)
coin_id_ls = [coin_names[name] for name in coin_final]
data = pd.DataFrame()
data['pdf_name'] = pdf_final
data['coin_id'] = coin_id_ls
print(data)
#Use coin_gecko api to retrieve inital price and current price!
coin_prices_dic = {}
error = []
for name in coin_id_ls:
try:
price_dic = cg.get_coin_market_chart_by_id(name, vs_currency = 'usd', days = 'max')
price_list = price_dic['prices']
first_date = price_list[0][0]
first_price = price_list[0][1]
latest_date = price_list[-1][0]
latest_price = price_list[-1][1]
coin_prices_dic[name] = [first_date, first_price, latest_date, latest_price]
print(name, 'successful retrieval')
except Exception as e:
print(name, e)
error.append(name)
print(len(coin_prices_dic))
#combine coin prices with corresponding with our data frame
prices_df = pd.DataFrame.from_dict(coin_prices_dic, orient = 'index', columns = ['first_date', 'first_price', 'latest_date [9/9/19]', 'latest_price'])
data.set_index('coin_id', inplace = True)
df = data.join(prices_df)
df = df.reset_index()
#Create some new variables
df['price_change'] = df['latest_price'] - df['first_price']
df['price_drop_true'] = df['price_change'].apply(lambda x: 1 if x < 0 else 0)
#sort out timestamp to a datetime object
df['first_date'] = df['first_date'].apply(lambda x: pd.Timestamp.fromtimestamp(x/1000))
df['latest_date [9/9/19]'] = df['latest_date [9/9/19]'].apply(lambda x: pd.Timestamp.fromtimestamp(x/1000))
#filter out only pdfs with prices to a new folder called final_pdfs
import glob
import shutil
pdf_names = df['pdf_name'].tolist()
for name in pdf_names:
src = "C:/Users/Andy/OneDrive/UpLevel/combined/" + name
dest = "C:/Users/Andy/OneDrive/UpLevel/match/" + name
shutil.move(src, dest)
pdf_list = glob.glob(r"C:/Users/Andy/OneDrive/UpLevel/match/*/*.pdf")
len(pdf_list) #It's 886 instead of 889 (3 papers did not have .pdfs!)
set(pdf_names) - set([name.split('\\')[-2] for name in pdf_list])
#'MASTERNET', 'Obsidian', 'TeslaCoin' Remove these three from the dataframe!
for pdf in pdf_list:
name = pdf.split('\\')[-2]
src = pdf
dest = "C:/Users/Andy/OneDrive/UpLevel/pdfs_final/" + name + '.pdf'
shutil.copy(src, dest)
#edit df_final and output as df_final
df.set_index('pdf_name', inplace = True)
for name in ['MASTERNET', 'Obsidian', 'TeslaCoin' ]:
df.drop(name, inplace = True)
df.to_csv('df_final.csv', index = False, date_format = r'%d/%m/%Y')
#double check if the pdf files in our folder correspond to the coins in the dataframe
folder_ls = [x.replace('.pdf', '') for x in os.listdir('pdfs_final')]
pdf_names = df['pdf_name'].tolist()
set(folder_ls) - set(pdf_names) == set() |
from collections import deque
class Agent(object):
def __init__(self, plan=[], current_travel_time=0, time_to_pass_link=0, identifier="unset"):
self.__setstate__({
"plan": deque(plan),
"current_travel_time": current_travel_time,
"time_to_pass_link": time_to_pass_link,
"id": str(identifier)
})
def __repr__(self):
return "%s(%r, %i, %i, '%s')" %(
self.__class__.__name__,
self.plan,
self.current_travel_time,
self.time_to_pass_link,
self.id
)
def __getstate__(self):
return {
"plan": self.plan,
"current_travel_time": self.current_travel_time,
"time_to_pass_link": self.time_to_pass_link,
"id": self.id
}
def __setstate__(self, state):
self.__dict__.update(state)
self.plan_copy = list(self.plan)
def __str__(self):
return "ag_%s{o:%r; c:%s; t:%i}" %(self.id, self.plan_copy, self.plan, self.current_travel_time)
def tick(self, delta_t):
self.current_travel_time += delta_t |
welcome = input("Welcome to Prince's Basic calculator of Addition, Please Click Enter to continue !")
print(welcome)
num_1 = float(input("Enter Your First Number : "))
num_2 = float(input("Enter yoir Second Number : "))
result = round(num_1 + num_2, 2)
print(f"Your result is : {num_1+num_2}")
thank = input("Thank you for Using Prince's Basic Calculator.")
print(thank) |
import os
import re
import csv
import sys
import json
import time
import errno
import random
import urllib
import logging
import datetime
import requests
from bs4 import BeautifulSoup
from selenium import webdriver
#driver = webdriver.Chrome('./cdriver/chromedriver.exe')
#
#driver.get("https://www.wg-gesucht.de/en/")
#
#
#
#print(driver.title)
session = requests.Session()
payload = {
"login_email_username": "[email protected]",
"login_password": "wggesucht@neil94",
"login_form_auto_login": "1",
"display_language": "de"
}
headers = { 'Accept': 'application/json',
'Accept-Encoding': 'gzip, deflate, br',
'Accept-Language': 'en-US,en;q=0.9,de;q=0.8',
'Connection': 'keep-alive',
'Content-Length': '140',
'Content-Type': 'application/json',
'Host': 'www.wg-gesucht.de',
'Origin': 'https://www.wg-gesucht.de',
'Referer': 'https://www.wg-gesucht.de/en/logout.html',
'sec-ch-ua': '"Google Chrome";v="95", "Chromium";v="95", ";Not A Brand";v="99"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"Windows"',
'Sec-Fetch-Dest': 'empty',
'Sec-Fetch-Mode': 'cors',
'Sec-Fetch-Site': 'same-origin',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36',
'X-Authorization': 'Bearer',
'X-Client-Id': 'wg_desktop_website',
'X-Dev-Ref-No': '',
'X-Requested-With': 'XMLHttpRequest',
'X-User-Id':'' }
response = session.post(
"https://www.wg-gesucht.de/ajax/sessions.php?action=login",
data=json.dumps(payload), headers=headers
)
print("login status",response.json)
response=session.get("https://www.wg-gesucht.de/en/my-profile.html")
with open('index.html','w') as f:
f.write(response.text)
|
from __future__ import absolute_import
import logging
import six
import threading
from collections import defaultdict
from sentry.debug.utils.patch_context import PatchContext
DEFAULT_MAX_QUERIES = 25
DEFAULT_MAX_DUPES = 3
class State(threading.local):
def __init__(self):
self.count = 0
self.query_hashes = defaultdict(int)
def record_query(self, sql):
self.count += 1
self.query_hashes[hash(sql)] += 1
def count_dupes(self):
return sum(1 for n in six.itervalues(self.query_hashes) if n > 1)
class CursorWrapper(object):
def __init__(self, cursor, connection, state):
self.cursor = cursor
self.connection = connection
self._state = state
def execute(self, sql, params=()):
try:
return self.cursor.execute(sql, params)
finally:
self._state.record_query(sql)
def executemany(self, sql, paramlist):
try:
return self.cursor.executemany(sql, paramlist)
finally:
self._state.record_query(sql)
def __getattr__(self, attr):
if attr in self.__dict__:
return self.__dict__[attr]
else:
return getattr(self.cursor, attr)
def __iter__(self):
return iter(self.cursor)
def get_cursor_wrapper(state):
def cursor(func, self, *args, **kwargs):
result = func(self, *args, **kwargs)
return CursorWrapper(result, self, state)
return cursor
class SqlQueryCountMonitor(object):
def __init__(
self,
context,
max_queries=DEFAULT_MAX_QUERIES,
max_dupes=DEFAULT_MAX_DUPES,
logger=None,
**kwargs
):
self.context = context
self.max_queries = max_queries
self.max_dupes = max_dupes
self.logger = logger or logging.getLogger(__name__)
self.state = State()
self._cursor = get_cursor_wrapper(self.state)
self._patcher = PatchContext("django.db.backends.BaseDatabaseWrapper.cursor", self._cursor)
def __enter__(self):
self.start()
return self
def __exit__(self, *args, **kwargs):
self.stop()
def start(self):
self._patcher.patch()
def stop(self):
self._patcher.unpatch()
num_dupes = self.state.count_dupes()
if self.state.count > self.max_queries:
self.log_max_queries(num_dupes)
if num_dupes > self.max_dupes:
self.log_max_dupes(num_dupes)
def log_max_dupes(self, num_dupes):
state = self.state
context = {"stack": True, "data": {"query_count": state.count, "num_dupes": num_dupes}}
self.logger.warning(
"%d duplicate queries executed in %s", num_dupes, self.context, extra=context
)
def log_max_queries(self, num_dupes):
state = self.state
context = {"stack": True, "data": {"query_count": state.count, "num_dupes": num_dupes}}
self.logger.warning("%d queries executed in %s", state.count, self.context, extra=context)
|
import magma as m
from mantle.xilinx.spartan6.SRL import SRL16
from loam.boards.papiliopro import PapilioPro
from loam.shields.megawing import MegaWing
megawing = MegaWing(PapilioPro)
megawing.Clock.on()
megawing.Switch.on(5)
megawing.LED.on(1)
main = megawing.main()
A = main.SWITCH[0:4]
I = main.SWITCH[4]
O = main.LED
srl16= SRL16(init=1)
m.wire( srl16(A,I), O )
|
def insertionSort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j] :
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
lst = [1, 2, 3, 5, 4]
insertionSort(lst)
# since lists are mutable
# the main list itself changes
print(lst) |
from django import forms
from .models import Customer
class CustomerForm(forms.ModelForm):
"""
Форма покупателя для интерфейса кладовщика.
"""
class Meta:
model = Customer
fields = '__all__'
widgets = {'contact_info': forms.Textarea(attrs={'rows': '2',
'cols': '34'}),
'full_name': forms.TextInput(attrs={'size': '35'}),
'phone_number': forms.TextInput(attrs={'size': '35'}),
'email': forms.TextInput(attrs={'size': '35'}), }
|
"""
A module simulating a device using multiple threads to
collect and parse data imitating a crowdsense environment.
"""
from threading import Thread
import constants
from synchronize import Synchronize
from task import Task
from thread_pool import ThreadPool
class Device(object):
"""
Class that represents a device.
"""
def __init__(self, device_id, sensor_data, supervisor):
"""
Constructor.
@type device_id: Integer
@param device_id: the unique id of this node; between 0 and N-1
@type sensor_data: List of (Integer, Float)
@param sensor_data: a list containing (location, data)
as measured by this device
@type supervisor: Supervisor
@param supervisor: the testing infrastructure's
control and validation component
"""
self.device_id = device_id
self.sensor_data = sensor_data
self.supervisor = supervisor
self.scripts = []
self.sync = Synchronize()
self.thread_pool = ThreadPool(constants.NUMBER_OF_THREADS, self)
self.thread = DeviceThread(self)
self.thread.start()
def __str__(self):
"""
Pretty prints this device.
@rtype: String
@return: a string containing the id of this device
"""
return "Device %d" % self.device_id
def setup_devices(self, devices):
"""
Setup the devices before simulation begins.
@type devices: List of Device
@param devices: list containing all devices
"""
if self.device_id == 0:
self.sync.initialize_location_semaphores()
self.sync.initialize_barrier(len(devices))
for device in devices:
device.sync.barrier = self.sync.barrier
device.set_location_semaphores(self.sync.location_semaphores)
def add_task(self, task):
"""
Add a task in the worker pool
"""
self.thread_pool.add_task(task)
def assign_script(self, script, location):
"""
Provide a script for the device to execute.
@type script: Script
@param script: the script to execute from now on at each timepoint;
None if the current timepoint has ended
@type location: Integer
@param location: the location for which the script is interested in
"""
if script:
self.scripts.append((script, location))
def get_data(self, location):
"""
Returns the pollution value this device has for the given location.
@type location: Integer
@param location: a location for which obtain the data
@rtype: Float
@return: the pollution value
"""
if location in self.sensor_data:
return self.sensor_data[location]
return None
def set_data(self, location, data):
"""
Sets the pollution value stored by this device for the given location.
@type location: Integer
@param location: a location for which to set the data
@type data: Float
@param data: the pollution value
"""
if location in self.sensor_data:
self.sensor_data[location] = data
def shutdown(self):
"""
Instructs the device to shutdown (terminate all threads). This method
is invoked by the tester. This method must block until all the threads
started by this device terminate.
"""
self.thread.join()
def set_location_semaphores(self, location_semaphores):
"""
A wrapper function for setting the list of location semaphores
since setting it as we usually do took more than 79 chars per line. :(
@type location_semaphores: List of Semaphore objects
@param location_semaphores: A list of Semaphore objects we use to
make sure multiple devices are not
accessing the same data concurrently.
"""
self.sync.location_semaphores = location_semaphores
class DeviceThread(Thread):
"""
Class that implements the device's worker thread.
"""
def __init__(self, device):
"""
Constructor.
@type device: Device
@param device: the device which owns this thread
"""
Thread.__init__(self, name="Device Thread %d" % device.device_id)
self.device = device
def run(self):
while True:
neighbours = self.device.supervisor.get_neighbours()
if neighbours is None:
self.device.thread_pool.join_threads()
break
self.device.sync.barrier.wait()
for (script, location) in self.device.scripts:
self.device.add_task(Task(neighbours, script, location))
self.device.sync.barrier.wait()
|
import os
import shutil
import time
from typing import Iterator
import pytest
from py._path.local import LocalPath
@pytest.fixture
def here() -> str:
"""Returns the absoluate path of the project root
Returns:
str: path
"""
return os.path.abspath(os.path.dirname(__file__))
@pytest.fixture
def create_file(tmpdir: LocalPath) -> Iterator[str]:
"""Creates a random file for testing in the tmpdir fixture
Yields:
Iterator[TextIOWrapper]: file instance
"""
folder: LocalPath = tmpdir.mkdir(random_name())
file: str = folder.join(random_name())
with open(file, "w") as _file:
yield _file.name
shutil.rmtree(folder)
@pytest.fixture
def create_folder(tmpdir: LocalPath) -> Iterator[LocalPath]:
"""Creates a random folder in temp for testing in the tmpdir fixture
Yields:
Iterator[LocalPath]: folder instance
"""
folder: LocalPath = tmpdir.mkdir(random_name())
yield folder
shutil.rmtree(folder)
def random_name() -> str:
"""Returns a random string of ints based on the current time
Returns:
str: random string
"""
return str(int(time.time()))
def get_abs_path(relative_path: str) -> str:
"""Attempts to return the absolute path of a relative path
by joining the relative path with the project root
Args:
relative_path (str): the relative path
Returns:
str: the absolute path
"""
project_root = os.path.dirname(os.path.abspath(__file__))
return os.path.join(project_root, relative_path)
|
import pygame
from agent import Agent
class MyAgent(Agent):
def get_action(self, state, last_action, time_left):
played = False
action = None
while not played:
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONUP:
pos = pygame.mouse.get_pos()
valid_clic = False
if state.get_cur_player() == 0:
pawn = int(pos[0] / 100) - 1
if 0 <= pawn <= 4 and state.get_pawn_position(0, pawn)[1] <= pos[1] <= state.get_pawn_position(0, pawn)[1] + 100:
valid_clic = True
else:
pawn = int(pos[1] / 100) - 1
if 0 <= pawn <= 4 and state.get_pawn_position(1, pawn)[0] <= pos[0] <= state.get_pawn_position(1, pawn)[0] + 100:
valid_clic = True
if valid_clic and state.is_action_valid(pawn):
played = True
action = pawn
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
return action
def get_name(self):
return "human_agent" |
from eliot import log_call
from .extract_user_from_req import extract_user_from_req
@log_call
def extract_uid_from_req(req, hdr_name, claim_field):
return extract_user_from_req(req, hdr_name, claim_field)["uid"]
|
"""
@file qliblabels.py
@author xy
@since 2014-08-09
@brief qLib, node tagging/labeling functions (semantics).
"""
import hou
import re
import traceback
import datetime
import sys
labels = {
# a completed partial-result
'waypoint': {
'cats': ('sop', 'dop', ),
'color': (1.0, 0.6, 0.6),
'prefix': 'WP_',
'prefix.sop': 'GEO_',
'prefix.dop': 'DOP_',
},
# fetch-like op (ObjectMerge, etc.)
'fetch': {
'cats': ('sop', ),
'color': (0.8, 1.0, 0.8),
'prefix': 'IN_',
},
# export-like op (an output point for another fetch)
'export': {
'cats': ('sop', ),
'color': (0.0, 0.3, 0.0),
'prefix': 'OUT_',
},
# RENDER op
'render': {
'cats': ('sop', ),
'color': (0.4, 0.2, 0.6),
'name': 'RENDER',
},
# DISPLAY op
'display': {
'cats': ('sop', ),
'color': (0.0, 0.4, 1.0),
'name': 'DISPLAY',
},
'out': {
'cats': ('sop', ),
'color': (0.9, 0.9, 0.9),
'name': 'OUT',
},
# ----
# default op settings (do not delete this)
'default': {
'color': (0.8, 0.8, 0.8),
},
}
def msg(m):
msg = "[%s qliblabels.py] %s" % (
datetime.datetime.now().strftime("%y%m%d %H:%M.%S"), str(m), )
sys.stderr.write(msg+"\n")
#print msg
def warn(m):
msg('WARNING: %s' % m)
def err(m):
msg('ERROR: %s' % m)
def dbg(m):
msg('[debug] %s' % m)
dbg('LOADED')
# module-wide constants
#
# name/label for tags parameter
n_tags = '__tags'
l_tags = 'tags (semantics)'
# tag list separator
tags_s = ' '
def has_tags_parm(node):
'''.'''
#assert type(node) is hou.Node
r = node.parm(n_tags) is not None
return r
def add_tags_parm(node):
'''.'''
#assert type(node) is hou.Node
if not has_tags_parm(node):
pass # add tags parm
#hou_parm_template_group = hou.ParmTemplateGroup()
hou_parm_template_group = node.parmTemplateGroup()
# Code for parameter template
hou_parm_template = hou.StringParmTemplate(n_tags, l_tags,
1, default_value=([""]), naming_scheme=hou.parmNamingScheme.Base1,
string_type=hou.stringParmType.Regular,
menu_items=([]),
menu_labels=([]),
icon_names=([]),
item_generator_script="",
item_generator_script_language=hou.scriptLanguage.Python,
menu_type=hou.menuType.Normal)
hou_parm_template_group.append(hou_parm_template)
node.setParmTemplateGroup(hou_parm_template_group)
else:
dbg('%s already has tags parm' % node.path())
return node.parm(n_tags)
def rem_tags_parm(node):
'''.'''
# assert
if has_tags_parm(node):
g = node.parmTemplateGroup()
t = g.find(n_tags)
if t:
g.remove(t)
node.setParmTemplateGroup(g)
else:
dbg('%s -- no tags parm found' % node.path())
else:
dbg('%s has no tags parm' % node.path())
def tags_parm(node):
'''.'''
return add_tags_parm(node)
def get_tag_list(node):
'''.'''
r = []
if has_tags_parm(node):
p = tags_parm(node)
r = p.evalAsString().lower()
# strip of spaces (in case separator is not a space)
r = [n.strip() for n in r.split(tags_s)]
return r
def set_tag_list(node, taglist):
'''.'''
assert type(taglist) is list, 'expecting a list of strings'
l = [n.strip() for n in taglist if n.strip() != '']
dbg(' -- tags: %s' % str(l))
l = tags_s.join(l)
dbg(' -- writing tags: "%s"' % l)
if len(l) > 0:
p = tags_parm(node)
p.set(l)
else:
dbg('(removing parm)')
rem_tags_parm(node)
def get_label_table():
'''.'''
return labels
def find_all_prefixes(labels):
'''.'''
r = set()
for L in labels:
E = labels[L]
cats = E['cats'] if 'cats' in E else []
if 'prefix' in E:
r.add(E['prefix'])
for c in cats:
p = 'prefix.%s' % c
if p in E:
r.add(E[p])
r = list(r)
return r
def get_label_data(label):
L = get_label_table()
r = L[label] if label in L else {}
return r
def apply_color(node):
'''.'''
pass
# TODO: finish this
def apply_naming(node):
'''.'''
"""
TODO: make sure to
- remove _all_ known prefixes as well, when necessary
- rename to a default name if previous tagging had an explicit naming scheme
"""
pass
c = node.type().category().name().lower() # 'sop', etc.
def process_op(node, tags, tags_prev=[]):
'''.'''
# TODO: set color, prefix/name, etc.
had_prev_tags = len(tags_prev) > 0
if len(tags):
pass # TODO: apply new color, replace prefix, etc.
else:
pass # TODO: reset op to its defaults
def uimsg(msg, sev=hou.severityType.Message):
'''.'''
hou.ui.setStatusMessage('[qLib | semantics] %s' % str(msg), severity=sev)
def uiwarn(msg):
uimsg(msg, sev=hou.severityType.Warning)
def shelfToolClicked(kwargs):
'''.'''
dbg('shelfToolClicked(): %s' % str(kwargs))
assert type(kwargs) is dict, 'expecting a dict for kwargs'
try:
label = kwargs['toolname'].lower()
label = re.search('[a-z]*$', label).group(0)
nodes = hou.selectedNodes()
add_mode = kwargs['shiftclick'] is True
clear_mode = kwargs['altclick'] is True
if label:
uimsg("%s node(s) to '%s'" %
('added label to' if add_mode else 'labeled', label, ))
for n in nodes:
dbg(" -- %s" % n.path())
tags_prev = get_tag_list(n)
tags = tags_prev if add_mode else []
if label not in tags:
tags.append(label)
if clear_mode:
tags = []
set_tag_list(n, tags)
process_op(n, tags, tags_prev)
else:
uiwarn("couldn't determine label from shelf tool '%s'" %
kwargs['toolname'])
except:
err('shelfToolClicked() failed')
traceback.print_exc()
#dbg('%s' % str( traceback.format_exc() ) )
pass
|
"""
Synchronize Azure network security rules
"""
from common.methods import set_progress
from azure.common.credentials import ServicePrincipalCredentials
from resourcehandlers.azure_arm.models import AzureARMHandler
from azure.mgmt.network import NetworkManagementClient
from msrestazure.azure_exceptions import CloudError
import azure.mgmt.resource.resources as resources
RESOURCE_IDENTIFIER = 'azure_network_security_group_name'
def discover_resources(**kwargs):
discovered_virtual_nets = []
for handler in AzureARMHandler.objects.all():
set_progress('Connecting to Azure networks \
for handler: {}'.format(handler))
credentials = ServicePrincipalCredentials(
client_id=handler.client_id,
secret=handler.secret,
tenant=handler.tenant_id
)
network_client = NetworkManagementClient(credentials, handler.serviceaccount)
azure_resources_client = resources.ResourceManagementClient(credentials, handler.serviceaccount)
for resource_group in azure_resources_client.resource_groups.list():
try:
for security_group in network_client.network_security_groups.list(resource_group_name=resource_group.name):
for security_rule in network_client.security_rules.list(resource_group_name=resource_group.name, network_security_group_name=security_group.as_dict()['name']):
discovered_virtual_nets.append(
{
'name': 'Azure Security rule - ' + security_group.as_dict()['name'] + " " + security_rule.as_dict()['direction'],
'azure_network_security_group_name': security_group.as_dict()['name'],
'azure_location': security_group.as_dict()['location'],
'azure_rh_id': handler.id,
'resource_group_name': resource_group.name,
'azure_security_rule_protocol': security_rule.as_dict()['protocol'],
'azure_security_rule_access': security_rule.as_dict()['access'],
'azure_security_rule_direction': security_rule.as_dict()['direction'],
'azure_security_rule_name': security_rule.as_dict()['name'],
}
)
except CloudError as e:
set_progress('Azure Clouderror: {}'.format(e))
continue
return discovered_virtual_nets |
import argparse
import json
import requests
import properties
def retrieve_data(pubmedIds):
base_url = properties.base_url
efoTraits = properties.efoTraits
search = properties.uriSearch
# Header
print("EFO trait, URI")
print(" Author, publication date, title, journal, pubmed Id, accession Id, initial sample size, replication sample size")
for id in pubmedIds:
url = base_url+efoTraits+search+id
# It is a good practice not to hardcode the credentials. So ask the user to enter credentials at runtime
traitResponse = requests.get(url)
# For successful API call, response code will be 200 (OK)
if(traitResponse.ok):
# Loading the response data into a dict variable
# json.loads takes in only binary or string variables so using content to fetch binary content
# Loads (Load String) takes a Json file and converts into python data structure (dict or list, depending on JSON)
data = (json.loads(traitResponse.content))["_embedded"]["efoTraits"]
for x in range(len(data)):
e = data[x]
print(e["trait"] + " " + e["uri"])
studiesURL = e["_links"]["studies"]["href"]
studyResponse = requests.get(studiesURL)
if(studyResponse.ok):
studyData = json.loads(studyResponse.content)["_embedded"]["studies"]
for x in range(len(studyData)):
s = studyData[x]
# Print study data summary
print(" " + s["author"] + "; "+ s["publicationDate"] + "; "+ s["title"] + "; "+ s["publication"]
+ "; "+ s["pubmedId"] + "; "+ s["accessionId"] + "; "+ str(s["initialSampleSize"])+ "; "+ str(s["replicateSampleSize"]))
print("")
print("")
else:
# If response code is not ok (200), print the resulting http error code with description
traitResponse.raise_for_status()
if __name__ == "__main__":
# Parse the pubmed ID inputs
parser = argparse.ArgumentParser()
parser.add_argument('uris', nargs='+')
args = parser.parse_args()
retrieve_data(args.uris) |
"""
Goal: compute the shortest path given source node s and target node t.
Preprocessing phase:
Query Phase:
Similar to dijkstra, but we only follow edges going to nodes with a higher contraction order than the current node
"""
class ContractionHierarchy(object):
def __init__(self):
pass
def preprocessing(self):
pass
def query(self):
pass |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.