Datasets:

ytzi

/

the-stack-dedup-python-scored

like 0

0a1eaf6b7e32695b5e6a96b0eee80707d820de35

py

Python

colab_logica.py

smdesai/logica

ad099bcd6064e38e9c2bc9a99564832857c0768c

colab_logica.py

smdesai/logica

ad099bcd6064e38e9c2bc9a99564832857c0768c

colab_logica.py

smdesai/logica

ad099bcd6064e38e9c2bc9a99564832857c0768c

#!/usr/bin/python # # Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Library for using Logica in CoLab.""" from .common import color from .common import concertina_lib from .compiler import functors from .compiler import rule_translate from .compiler import universe import IPython from IPython.core.magic import register_cell_magic from IPython.display import display import os import pandas from .parser_py import parse from .common import sqlite3_logica BQ_READY = True # By default. try: from google.cloud import bigquery except: BQ_READY = False print('Could not import google.cloud.bigquery.') try: from google.colab import auth except: BQ_READY = False print('Could not import google.cloud.auth.') try: from google.colab import widgets WIDGETS_IMPORTED = True except: WIDGETS_IMPORTED = False print('Could not import google.colab.widgets.') PROJECT = None # TODO: Should this be renamed to PSQL_ENGINE, PSQL_CONNECTION? DB_ENGINE = None DB_CONNECTION = None USER_AUTHENTICATED = False TABULATED_OUTPUT = True SHOW_FULL_QUERY = True PREAMBLE = None def SetPreamble(preamble): global PREAMBLE PREAMBLE = preamble def SetProject(project): global PROJECT PROJECT = project def SetDbConnection(connection): global DB_CONNECTION DB_CONNECTION = connection def EnsureAuthenticatedUser(): global USER_AUTHENTICATED global PROJECT if USER_AUTHENTICATED: return auth.authenticate_user() if PROJECT is None: print("Please enter project_id to use for BigQuery queries.") PROJECT = input() print("project_id is set to %s" % PROJECT) print("You can change it with logica.colab_logica.SetProject command.") USER_AUTHENTICATED = True def SetTabulatedOutput(tabulated_output): global TABULATED_OUTPUT global SHOW_FULL_QUERY TABULATED_OUTPUT = tabulated_output SHOW_FULL_QUERY = TABULATED_OUTPUT if not WIDGETS_IMPORTED: SetTabulatedOutput(False) def TabBar(*args): """Returns a real TabBar or a mock. Useful for UIs that don't support JS.""" if TABULATED_OUTPUT: return widgets.TabBar(*args) class MockTab: def __init__(self): pass def __enter__(self): pass def __exit__(self, *x): pass class MockTabBar: def __init__(self): pass def output_to(self, x): return MockTab() return MockTabBar() @register_cell_magic def logica(line, cell): Logica(line, cell, run_query=True) def ParseList(line): line = line.strip() if not line: predicates = [] else: predicates = [p.strip() for p in line.split(',')] return predicates def RunSQL(sql, engine, connection=None, is_final=False): if engine == 'bigquery': client = bigquery.Client(project=PROJECT) return client.query(sql).to_dataframe() elif engine == 'psql': if is_final: return pandas.read_sql(sql, connection) else: return connection.execute(sql) elif engine == 'sqlite': statements = parse.SplitRaw(sql, ';') connection.executescript(sql) if is_final: return pandas.read_sql(statements[-1], connection) else: pass return None else: raise Exception('Logica only supports BigQuery, PostgreSQL and SQLite ' 'for now.') class SqliteRunner(object): def __init__(self): self.connection = sqlite3_logica.SqliteConnect() # TODO: Sqlite runner should not be accepting an engine. def __call__(self, sql, engine, is_final): return RunSQL(sql, engine, self.connection, is_final) class PostgresRunner(object): def __init__(self): global DB_CONNECTION global DB_ENGINE if DB_CONNECTION: self.engine = DB_ENGINE self.connection = DB_CONNECTION else: (self.engine, self.connection) = PostgresJumpStart() DB_ENGINE = self.engine DB_CONNECTION = self.connection def __call__(self, sql, engine, is_final): return RunSQL(sql, engine, self.connection, is_final) def ShowError(error_text): print(color.Format('[ {error}Error{end} ] ' + error_text)) def Logica(line, cell, run_query): """Running Logica predicates and storing results.""" predicates = ParseList(line) if not predicates: ShowError('No predicates to run.') return try: program = ';\n'.join(s for s in [PREAMBLE, cell] if s) parsed_rules = parse.ParseFile(program)['rule'] except parse.ParsingException as e: e.ShowMessage() return try: program = universe.LogicaProgram(parsed_rules) except functors.FunctorError as e: e.ShowMessage() return engine = program.annotations.Engine() if engine == 'bigquery' and not BQ_READY: ShowError( 'BigQuery client and/or authentification is not installed. \n' 'It is the easiest to run BigQuery requests from Google CoLab:\n' ' https://colab.research.google.com/.\n' 'Note that running Logica on SQLite requires no installation.\n' 'This could be a good fit for working with small data or learning Logica.\n' 'Use {warning}@Engine("sqlite");{end} annotation in your program to use SQLite.') return bar = TabBar(predicates + ['(Log)']) logs_idx = len(predicates) executions = [] sub_bars = [] ip = IPython.get_ipython() for idx, predicate in enumerate(predicates): with bar.output_to(logs_idx): try: sql = program.FormattedPredicateSql(predicate) executions.append(program.execution) ip.push({predicate + '_sql': sql}) except rule_translate.RuleCompileException as e: print('Encountered error when compiling %s.' % predicate) e.ShowMessage() return # Publish output to Colab cell. with bar.output_to(idx): sub_bar = TabBar(['SQL', 'Result']) sub_bars.append(sub_bar) with sub_bar.output_to(0): if SHOW_FULL_QUERY: print( color.Format( 'The following query is stored at {warning}%s{end} ' 'variable.' % ( predicate + '_sql'))) print(sql) else: print('Query is stored at %s variable.' % color.Warn(predicate + '_sql')) with bar.output_to(logs_idx): if engine == 'sqlite': sql_runner = SqliteRunner() elif engine == 'psql': sql_runner = PostgresRunner() elif engine == 'bigquery': EnsureAuthenticatedUser() sql_runner = RunSQL else: raise Exception('Logica only supports BigQuery, PostgreSQL and SQLite ' 'for now.') result_map = concertina_lib.ExecuteLogicaProgram( executions, sql_runner=sql_runner, sql_engine=engine) for idx, predicate in enumerate(predicates): t = result_map[predicate] ip.push({predicate: t}) with bar.output_to(idx): with sub_bars[idx].output_to(1): if run_query: print( color.Format( 'The following table is stored at {warning}%s{end} ' 'variable.' % predicate)) display(t) else: print('The query was not run.') print(' ') # To activate the tabbar. def PostgresJumpStart(): # Install postgresql server. print("Installing and configuring an empty PostgreSQL database.") result = 0 result += os.system('sudo apt-get -y -qq update') result += os.system('sudo apt-get -y -qq install postgresql') result += os.system('sudo service postgresql start') # Ignoring user creation error, as they may already exist. result += 0 * os.system( 'sudo -u postgres psql -c "CREATE USER logica WITH SUPERUSER"') result += os.system( 'sudo -u postgres psql -c "ALTER USER logica PASSWORD \'logica\';"') result += os.system( 'sudo -u postgres psql -U postgres -c \'CREATE DATABASE logica;\'') if result != 0: print("""Installation failed. Please try the following manually: # Install Logica. !pip install logica # Install postgresql server. !sudo apt-get -y -qq update !sudo apt-get -y -qq install postgresql !sudo service postgresql start # Prepare database for Logica. !sudo -u postgres psql -c "CREATE USER logica WITH SUPERUSER" !sudo -u postgres psql -c "ALTER USER logica PASSWORD 'logica';" !sudo -u postgres psql -U postgres -c 'CREATE DATABASE logica;' # Connect to the database. from logica import colab_logica from sqlalchemy import create_engine import pandas engine = create_engine('postgresql+psycopg2://logica:[email protected]', pool_recycle=3600); connection = engine.connect(); colab_logica.SetDbConnection(connection)""") return print('Installation succeeded. Connecting...') # Connect to the database. from logica import colab_logica from sqlalchemy import create_engine import pandas engine = create_engine('postgresql+psycopg2://logica:[email protected]', pool_recycle=3600) connection = engine.connect() print('Connected.') return engine, connection

0a1ed95ecf3a94b0314f7b8f523edacf4c486e8a

py

Python

pyccel/ast/basic.py

toddrme2178/pyccel

deec37503ab0c5d0bcca1a035f7909f7ce8ef653

pyccel/ast/basic.py

toddrme2178/pyccel

deec37503ab0c5d0bcca1a035f7909f7ce8ef653

pyccel/ast/basic.py

toddrme2178/pyccel

deec37503ab0c5d0bcca1a035f7909f7ce8ef653

from sympy.core.basic import Basic as sp_Basic class Basic(sp_Basic): """Basic class for Pyccel AST.""" _fst = None def set_fst(self, fst): """Sets the redbaron fst.""" self._fst = fst @property def fst(self): return self._fst

0a20c183c03d4133fca24e84a8755331075102c6

py

Python

alibi_detect/utils/tests/test_discretize.py

Clusks/alibi-detect

b39406a6cf88f315f401562d4fea93a42aa6dcc1

2019-11-19T15:38:40.000Z

2022-03-31T11:18:32.000Z

alibi_detect/utils/tests/test_discretize.py

Clusks/alibi-detect

b39406a6cf88f315f401562d4fea93a42aa6dcc1

2019-11-21T18:41:00.000Z

2022-03-31T21:08:56.000Z

alibi_detect/utils/tests/test_discretize.py

Clusks/alibi-detect

b39406a6cf88f315f401562d4fea93a42aa6dcc1

2019-11-19T14:23:23.000Z

2022-03-31T07:55:43.000Z

from itertools import product import numpy as np import pytest from alibi_detect.utils.discretizer import Discretizer x = np.random.rand(10, 4) n_features = x.shape[1] feature_names = [str(_) for _ in range(n_features)] categorical_features = [[], [1, 3]] percentiles = [list(np.arange(25, 100, 25)), list(np.arange(10, 100, 10))] tests = list(product(categorical_features, percentiles)) n_tests = len(tests) @pytest.fixture def cats_and_percentiles(request): cat, perc = tests[request.param] return cat, perc @pytest.mark.parametrize('cats_and_percentiles', list(range(n_tests)), indirect=True) def test_discretizer(cats_and_percentiles): cat, perc = cats_and_percentiles disc = Discretizer(x, cat, feature_names, perc) to_disc = list(disc.names.keys()) assert len(to_disc) == (x.shape[1] - len(cat)) x_disc = disc.discretize(x) for k, v in disc.names.items(): assert len(v) <= len(perc) + 1 assert callable(disc.lambdas[k]) assert (x_disc[:, k].min() == 0).all() assert (x_disc[:, k].max() == len(perc)).all() for i in range(x.shape[1]): if i not in to_disc: assert (x_disc[:, i] == x[:, i]).all()

0a21ba878c2e6396a56688811ff51897970088c4

py

Python

tinc/tests/parameter_space_test.py

AlloSphere-Research-Group/tinc-python

4c3390df9911a391833244de1eb1d33a2e19d330

2020-11-23T22:42:50.000Z

2020-11-23T22:42:50.000Z

tinc/tests/parameter_space_test.py

AlloSphere-Research-Group/tinc-python

4c3390df9911a391833244de1eb1d33a2e19d330

tinc/tests/parameter_space_test.py

AlloSphere-Research-Group/tinc-python

4c3390df9911a391833244de1eb1d33a2e19d330

# -*- coding: utf-8 -*- """ Created on Mon Jun 14 11:49:43 2021 @author: Andres """ import sys,time import unittest from tinc import * class ParameterSpaceTest(unittest.TestCase): def test_parameter(self): p1 = Parameter("param1") p2 = Parameter("param2") ps = ParameterSpace("ps") ps.register_parameters([p1, p2]) def test_process(self): p1 = Parameter("param1") p1.values = [0, 1,2,3,4] p2 = Parameter("param2") p2.values = [-0.3,-0.2, -0.1, 0] ps = ParameterSpace("ps") ps.register_parameters([p1, p2]) def func(param1, param2): return param1 * param2 result = ps.run_process(func) self.assertAlmostEqual(result, p1.value * p2.value) p1.value = 3 p2.value = -0.1 result = ps.run_process(func) self.assertAlmostEqual(result, p1.value * p2.value) p1.value = 3 p2.value = -0.1 def test_sweep_cache(self): p1 = Parameter("param1") p1.values = [0, 1,2,3,4] p2 = Parameter("param2") p2.values = [-0.3,-0.2, -0.1, 0] ps = ParameterSpace("ps") ps.register_parameters([p1, p2]) ps.enable_cache("ps_test") def func(param1, param2): return param1 * param2 ps.sweep(func) def test_data_directories(self): dim1 = Parameter("dim1") dim1.values = [0.1,0.2,0.3,0.4, 0.5] dim2 = Parameter("dim2") dim2.set_space_representation_type(parameter_space_representation_types.INDEX) dim2.values = [0.1,0.2,0.3,0.4, 0.5] dim3 = Parameter("dim3") dim3.set_space_representation_type(parameter_space_representation_types.ID) dim2.values = [0.1,0.2,0.3,0.4, 0.5] ps = ParameterSpace("ps") ps.register_parameters([dim1, dim2, dim3]) ps.set_current_path_template("file_%%dim1%%_%%dim2:INDEX%%") dim1.value=0.2 dim2.value=0.2 self.assertEqual(ps.get_current_relative_path(), 'file_0.2_1') # TODO ML complete tests see C++ tests for parameter space def test_common_id(self): dim1 = Parameter("dim1") dim1.values = [0.1, 0.1, 0.2, 0.2, 0.3, 0.3] dim1.ids = ["0.1_1" ,"0.1_2","0.2_1" ,"0.2_2", "0.3_1" ,"0.3_2"] dim2 = Parameter("dim2") dim2.set_space_representation_type(parameter_space_representation_types.INDEX) dim2.values = [1,1,1,2,2,2] dim2.ids = ["0.1_1", "0.2_1", "0.3_1", "0.1_2", "0.2_2", "0.3_2"] ps = ParameterSpace("ps") ps.register_parameters([dim1, dim2]) dim1.value = 0.1 dim2.value = 1 self.assertEqual(ps.get_common_id([dim1, dim2]), "0.1_1") dim1.value = 0.2 dim2.value = 1 self.assertEqual(ps.get_common_id([dim1, dim2]), "0.2_1") dim1.value = 0.1 dim2.value = 2 self.assertEqual(ps.get_common_id([dim1, dim2]), "0.1_2") dim1.value = 0.2 dim2.value = 2 self.assertEqual(ps.get_common_id([dim1, dim2]), "0.2_2") dim1.value = 0.3 dim2.value = 2 self.assertEqual(ps.get_common_id([dim1, dim2]), "0.3_2") if __name__ == '__main__': unittest.main()

0a247bd11d82f9ea0cd74cd38836b820c3903839

py

Python

interpretable_ddts/runfiles/gym_runner.py

CORE-Robotics-Lab/Interpretable_DDTS_AISTATS2020

a7fde4d2a7d70477b2e6c96b140f8c6587f78791

2021-08-11T14:58:36.000Z

2022-02-12T06:12:19.000Z

interpretable_ddts/runfiles/gym_runner.py

CORE-Robotics-Lab/Interpretable_DDTS_AISTATS2020

a7fde4d2a7d70477b2e6c96b140f8c6587f78791

interpretable_ddts/runfiles/gym_runner.py

CORE-Robotics-Lab/Interpretable_DDTS_AISTATS2020

a7fde4d2a7d70477b2e6c96b140f8c6587f78791

2020-10-21T03:57:52.000Z

2021-06-28T08:08:05.000Z

# Created by Andrew Silva on 8/28/19 import gym import numpy as np import torch from interpretable_ddts.agents.ddt_agent import DDTAgent from interpretable_ddts.agents.mlp_agent import MLPAgent from interpretable_ddts.opt_helpers.replay_buffer import discount_reward import torch.multiprocessing as mp import argparse import copy import random def run_episode(q, agent_in, ENV_NAME, seed=0): agent = agent_in.duplicate() if ENV_NAME == 'lunar': env = gym.make('LunarLander-v2') elif ENV_NAME == 'cart': env = gym.make('CartPole-v1') else: raise Exception('No valid environment selected') done = False torch.manual_seed(seed) env.seed(seed) np.random.seed(seed) env.action_space.seed(seed) random.seed(seed) state = env.reset() # Reset environment and record the starting state while not done: action = agent.get_action(state) # Step through environment using chosen action state, reward, done, _ = env.step(action) # env.render() # Save reward agent.save_reward(reward) if done: break reward_sum = np.sum(agent.replay_buffer.rewards_list) rewards_list, advantage_list, deeper_advantage_list = discount_reward(agent.replay_buffer.rewards_list, agent.replay_buffer.value_list, agent.replay_buffer.deeper_value_list) agent.replay_buffer.rewards_list = rewards_list agent.replay_buffer.advantage_list = advantage_list agent.replay_buffer.deeper_advantage_list = deeper_advantage_list to_return = [reward_sum, copy.deepcopy(agent.replay_buffer.__getstate__())] if q is not None: try: q.put(to_return) except RuntimeError as e: print(e) return to_return return to_return def main(episodes, agent, ENV_NAME): running_reward_array = [] for episode in range(episodes): reward = 0 returned_object = run_episode(None, agent_in=agent, ENV_NAME=ENV_NAME) reward += returned_object[0] running_reward_array.append(returned_object[0]) agent.replay_buffer.extend(returned_object[1]) if reward >= 499: agent.save('../models/'+str(episode)+'th') agent.end_episode(reward) running_reward = sum(running_reward_array[-100:]) / float(min(100.0, len(running_reward_array))) if episode % 50 == 0: print(f'Episode {episode} Last Reward: {reward} Average Reward: {running_reward}') if episode % 500 == 0: agent.save('../models/'+str(episode)+'th') return running_reward_array if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("-a", "--agent_type", help="architecture of agent to run", type=str, default='ddt') parser.add_argument("-e", "--episodes", help="how many episodes", type=int, default=2000) parser.add_argument("-l", "--num_leaves", help="number of leaves for DDT/DRL ", type=int, default=8) parser.add_argument("-n", "--num_hidden", help="number of hidden layers for MLP ", type=int, default=0) parser.add_argument("-env", "--env_type", help="environment to run on", type=str, default='cart') parser.add_argument("-gpu", help="run on GPU?", action='store_true') args = parser.parse_args() AGENT_TYPE = args.agent_type # 'ddt', 'mlp' NUM_EPS = args.episodes # num episodes Default 1000 ENV_TYPE = args.env_type # 'cart' or 'lunar' Default 'cart' USE_GPU = args.gpu # Applies for 'prolo' only. use gpu? Default false if ENV_TYPE == 'lunar': init_env = gym.make('LunarLander-v2') dim_in = init_env.observation_space.shape[0] dim_out = init_env.action_space.n elif ENV_TYPE == 'cart': init_env = gym.make('CartPole-v1') dim_in = init_env.observation_space.shape[0] dim_out = init_env.action_space.n else: raise Exception('No valid environment selected') print(f"Agent {AGENT_TYPE} on {ENV_TYPE} ") # mp.set_start_method('spawn') mp.set_sharing_strategy('file_system') for i in range(5): bot_name = AGENT_TYPE + ENV_TYPE if USE_GPU: bot_name += 'GPU' if AGENT_TYPE == 'ddt': policy_agent = DDTAgent(bot_name=bot_name, input_dim=dim_in, output_dim=dim_out, rule_list=False, num_rules=args.num_leaves) elif AGENT_TYPE == 'mlp': policy_agent = MLPAgent(input_dim=dim_in, bot_name=bot_name, output_dim=dim_out, num_hidden=args.num_hidden) else: raise Exception('No valid network selected') reward_array = main(NUM_EPS, policy_agent, ENV_TYPE)

0a263ee52f1bcf865cb343ad7cbe07411cfb3a5e

py

Python

Week 08/tw10_words_by_prefix.py

andrewn488/OMSBA-5061

8e57fff45d8965b0423a6fe338bd74cedfe94ea0

Week 08/tw10_words_by_prefix.py

andrewn488/OMSBA-5061

8e57fff45d8965b0423a6fe338bd74cedfe94ea0

Week 08/tw10_words_by_prefix.py

andrewn488/OMSBA-5061

8e57fff45d8965b0423a6fe338bd74cedfe94ea0

2022-02-07T02:42:43.000Z

2022-02-07T02:42:43.000Z

""" TW10: Words by Prefix Team: Tam Tamura, Andrew Nalundasan For: OMSBA 2061, Seattle University Date: 11/3/2020 """ def wordByPrefix(prefix_length, word): my_dict = {} for key in word: for letter in word: prefix_key = letter[:prefix_length] letter = word[:prefix_length] return prefix_key return letter question_2 = ['able', 'ability', 'apple', 'tryst', 'trial', 'tremendous', 'tree'] my_list = [] for elem in question_2: prefix = elem[:2] my_list.append(prefix) print(my_list) def question_3(prefix_length, word): my_list = [] for key in word: prefix = key[:prefix_length] my_list.append(prefix) return my_list def wordByPrefix(prefix_length, word): my_list = [] #count = 0 for key in word: prefix = key[:prefix_length] my_list.append(prefix) count = {} for letter in my_list: if letter.isalpha(): if letter not in count: count[letter] = 0 count[letter] += 1 return count def wordByPrefix(prefix_length, word): my_list = [] #count = 0 for key in word: prefix = key[:prefix_length] my_list.append(prefix) count = {} for letter in my_list: if letter.isalpha(): if letter not in count: letter[count] = [] count.update(letter) return count

0a26a5869fd7404e249d795b4a225c3eca2ac49a

py

Python

openff/bespokefit/executor/services/qcgenerator/cache.py

openforcefield/bespoke-f

27b072bd09610dc8209429118d739e1f453edd61

2020-08-28T20:49:00.000Z

2021-11-17T08:50:32.000Z

openff/bespokefit/executor/services/qcgenerator/cache.py

openforcefield/bespoke-f

27b072bd09610dc8209429118d739e1f453edd61

2020-02-19T18:40:54.000Z

2021-12-02T10:52:23.000Z

openff/bespokefit/executor/services/qcgenerator/cache.py

openforcefield/openff-bespokefit

85c92a51055a5a82e5d50fee1668a7de4ce2b1d4

2021-04-01T04:22:49.000Z

2021-04-13T03:19:10.000Z

import hashlib from typing import TypeVar, Union import redis from openff.toolkit.topology import Molecule from openff.bespokefit.executor.services.qcgenerator import worker from openff.bespokefit.schema.tasks import HessianTask, OptimizationTask, Torsion1DTask from openff.bespokefit.utilities.molecule import canonical_order_atoms _T = TypeVar("_T", HessianTask, OptimizationTask, Torsion1DTask) def _canonicalize_task(task: _T) -> _T: task = task.copy(deep=True) # Ensure the SMILES has a canonical ordering to help ensure cache hits. canonical_molecule = canonical_order_atoms( Molecule.from_smiles(task.smiles, allow_undefined_stereo=True) ) if isinstance(task, Torsion1DTask): map_to_atom_index = { j: i for i, j in canonical_molecule.properties["atom_map"].items() } central_atom_indices = sorted( map_to_atom_index[task.central_bond[i]] for i in (0, 1) ) canonical_molecule.properties["atom_map"] = { atom_index: (i + 1) for i, atom_index in enumerate(central_atom_indices) } canonical_smiles = canonical_molecule.to_smiles( isomeric=True, explicit_hydrogens=True, mapped=True ) task.central_bond = (1, 2) else: canonical_smiles = canonical_molecule.to_smiles( isomeric=True, explicit_hydrogens=True, mapped=False ) task.smiles = canonical_smiles return task def cached_compute_task( task: Union[HessianTask, OptimizationTask, Torsion1DTask], redis_connection: redis.Redis, ) -> str: """Checks to see if a QC task has already been executed and if not send it to a worker. """ if isinstance(task, Torsion1DTask): compute = worker.compute_torsion_drive elif isinstance(task, OptimizationTask): compute = worker.compute_optimization elif isinstance(task, HessianTask): compute = worker.compute_hessian else: raise NotImplementedError() # Canonicalize the task to improve the cache hit rate. task = _canonicalize_task(task) task_hash = hashlib.sha512(task.json().encode()).hexdigest() task_id = redis_connection.hget("qcgenerator:task-ids", task_hash) if task_id is not None: return task_id.decode() task_id = compute.delay(task_json=task.json()).id redis_connection.hset("qcgenerator:types", task_id, task.type) # Make sure to only set the hash after the type is set in case the connection # goes down before this information is entered and subsequently discarded. redis_connection.hset("qcgenerator:task-ids", task_hash, task_id) return task_id

0a277a87fbb9f9430d9ecdf658e9964b1157dc17

py

Python

advanced-workflows/task-graphs-lab/exercise/plugins/lab/plugin/workflows.py

jrzeszutek/cloudify-training-labs

5477750d269cb703ce47e35a1c13749fc88f3f6f

2015-07-06T01:10:08.000Z

2016-12-21T15:42:07.000Z

advanced-workflows/task-graphs-lab/exercise/plugins/lab/plugin/workflows.py

jrzeszutek/cloudify-training-labs

5477750d269cb703ce47e35a1c13749fc88f3f6f

2015-08-25T06:32:36.000Z

2016-09-07T07:01:34.000Z

advanced-workflows/task-graphs-lab/exercise/plugins/lab/plugin/workflows.py

jrzeszutek/cloudify-training-labs

5477750d269cb703ce47e35a1c13749fc88f3f6f

2015-03-28T05:45:58.000Z

2017-02-14T02:22:09.000Z

'''Copyright Gigaspaces, 2017, All Rights Reserved''' from cloudify.plugins import lifecycle OP_START = 'hacker.interfaces.lifecycle.start' OP_STOP = 'hacker.interfaces.lifecycle.stop' OP_SS_C = 'hacker.interfaces.lifecycle.create_snapshots' OP_SS_D = 'hacker.interfaces.lifecycle.delete_snapshots' REQUIRED_OPS = set([OP_START, OP_SS_C, OP_SS_D, OP_STOP]) def build_instance_sequence(instance, operation, state_start=None, state_end=None): ''' Builds sequenced subgraph tasks for an instance .. note:: The sequence will not be built if the instance provided does not have a node with an operation defined in the operation parameter. :param `CloudifyWorkflowNodeInstance` instance: Node instance to execute tasks against :param str operation: Node (lifecycle) operation to execute :param str state_start: Verb to describe operation start :param str state_stop: Verb to describe operation finish ''' tasks = list() # Only build the sequence if the node operation exists if operation not in instance.node.operations: return tasks # Add task starting state if state_start: tasks.append(instance.send_event('%s host' % state_start)) tasks.append(instance.set_state(state_start.lower())) # Add task operation tasks.append(instance.execute_operation(operation)) # Add task ended state if state_end: tasks.append(instance.send_event('%s host' % state_end)) tasks.append(instance.set_state(state_end.lower())) return tasks def build_instance_subgraph(instance, graph): ''' Builds a subgraph for an instance :param `CloudifyWorkflowNodeInstance` instance: Node instance to execute tasks against :param `TaskDependencyGraph` graph: Task graph to create sequences from ''' # Init a "stop instance" subgraph sg_stop = graph.subgraph('stop_subgraph') seq_stop = sg_stop.sequence() seq_stop.add(*build_instance_sequence( instance, OP_STOP, 'Stopping', 'Stopped')) # Init a "recreate snapshots" subgraph sg_snap = graph.subgraph('snapshot_subgraph') seq_snap = sg_snap.sequence() if OP_SS_D in instance.node.operations: seq_snap.add(*build_instance_sequence(instance, OP_SS_D)) if OP_SS_C in instance.node.operations: seq_snap.add(*build_instance_sequence(instance, OP_SS_C)) # Init a "start instance" subgraph sg_start = graph.subgraph('stop_subgraph') seq_start = sg_start.sequence() seq_start.add(*build_instance_sequence( instance, OP_START, 'Starting', 'Started')) # Create subgraph dependencies graph.add_dependency(sg_snap, sg_stop) graph.add_dependency(sg_start, sg_snap) def refresh_snapshots(ctx, **_): ''' Executes a complex, graph-based set of lifecycle events to stop all host (compute) instances, delete all existing instance snapshots, take new snapshots of all attached volumes, and start the instances back up when complete. ''' graph = ctx.graph_mode() # Find all compute hosts and build a sequence graph for node in ctx.nodes: if not REQUIRED_OPS.issubset(node.operations): ctx.logger.warn( 'Skipping refresh_snapshots workflow for node "%s" because ' 'it does not have all required operations defined' % node.id) continue # Iterate over each node instance for instance in node.instances: if not lifecycle.is_host_node(instance): ctx.logger.warn( 'Skipping refresh_snapshots workflow for node instance ' '"%s" because it is not a compute host' % instance.id) continue build_instance_subgraph(instance, graph) # Execute the sequences return graph.execute()

0a28f4c1d95b682b9a50e90e2f39fe8345b14eab

py

Python

File Transfer/Flyter/flyter.py

CryptoNyxz/Miscellaneous-Tools

797ea04d7c369469ab3d2a1ae2838c4a7b7b9c02

File Transfer/Flyter/flyter.py

CryptoNyxz/Miscellaneous-Tools

797ea04d7c369469ab3d2a1ae2838c4a7b7b9c02

File Transfer/Flyter/flyter.py

CryptoNyxz/Miscellaneous-Tools

797ea04d7c369469ab3d2a1ae2838c4a7b7b9c02

""" Flyter Tool for transferring files on the same network using raw sockets. Doesn't use encryption. """ __version__ = (0, 0, 0) __author__ = "CryptoNyxz" __license__ = """ MIT License Copyright (c) 2021 Jaymund Cyrus F. Floranza Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ from argparse import ArgumentParser from base64 import b64encode from datetime import timedelta from math import log from os import altsep, sep, \ mkdir, stat, unlink from os.path import dirname, exists, join from random import randint from secrets import token_bytes from shutil import get_terminal_size from socket import \ socket, error, timeout, \ ntohs, ntohl, htons, htonl, \ gethostname, \ AF_INET, SOCK_STREAM from threading import Thread from time import time from warnings import warn from sys import argv, exit, version_info if version_info < (3, 6): warn('[!] Some features are not be compatible with the version of your ' 'python interpreter') FROMTERMINAL = False # Utility Functions def random_port(host): """Return a random available TCP port.""" while True: port = randint(10_000, 65536) with socket(AF_INET, SOCK_STREAM) as sock: try: sock.bind((host, port)) except error: continue else: return port def printerror(errormsg): """Print an error message.""" global FROMTERMINAL if FROMTERMINAL: print(f'\n[x] {errormsg}') exit(-1) exit(-1) exit(-1) exit(-1) else: warn(errormsg) def printalert(alert): """Print an alert message.""" global FROMTERMINAL print(f'[!] {alert}') def int_to_bytes_s(integer): """Convert 16 - bit integer to bytes for packing.""" res = ntohs(integer) res = hex(res)[2:] res = '0'*(len(res) % 2) + res return bytes.fromhex(res) def bytes_to_int_s(byteseq): """Convert byte sequence to 16 - but integer for unpacking.""" res = bytes.hex(byteseq) res = int(res, 16) return htons(res) def int_to_bytes_l(integer): """Convert 32 - but integer to bytes for packing.""" res = ntohl(integer) res = hex(res)[2:] res = '0'*(len(res) % 2) + res return bytes.fromhex(res) def bytes_to_int_l(byteseq): """Convert byte sequence to 32 - but integer for unpacking.""" res = bytes.hex(byteseq) res = int(res, 16) return htonl(res) def pack_str(string): """Pack a string into a byte sequence.""" return string.encode() def unpack_str(byteseq): """Unpack a byte sequence into a string.""" return byteseq.decode() # Utility Classes class ProgressBar: """ For displaying progress bars. Parameters ---------- max_value : int, float The upper limit of the progress bar. length : :obj:`int`, optional The length of the progress bar. """ @staticmethod def byte_rescale(data, precision=1): scale = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'] p = int(log(data, 2)/10) if data else 0 r_bytes = round(data/pow(2, 10*p), precision) return f"{r_bytes}{scale[p]}" def __init__(self, max_value, length=50): self.max_value = max_value self.current_val = 0 self.length = length self.rate = None self.start_time = None self.start_value = None self.stopped = False @property def done(self): """Return if already finished.""" return self.current_val >= self.max_value or self.stopped def start(self): """Start the progress bar.""" self.stopped = False self.start_time = time() self.start_value = self.current_val def stop(self): """Stop the progress bar.""" self.stopped = True def add_progress(self, value): """ Count new progress. Parameter --------- value : int, float Added progress value. """ if self.stopped: return self.current_val += value def display(self): """Display the current progress.""" if self.stopped: return d_value = self.current_val - self.start_value d_max_value = self.max_value - self.start_value d_time = time() - self.start_time per = d_value/d_max_value prog = int(self.length*per) extra = self.length*round(per) > prog prog_bar = '█'*prog + '▌'*extra spaces = ' '*(self.length - (prog + extra)) rate = d_value/d_time if d_time else float('inf') eta_s = round((d_max_value - d_value)/rate) if rate else \ None eta = timedelta(seconds=eta_s) if eta_s is not None else '?' clear_line = " "*(get_terminal_size().columns - 1) print(f"{clear_line}\r" "Progress: " f"|{prog_bar}{spaces}| " f"{100*per:.1f}% " f"({ProgressBar.byte_rescale(d_value)}) " f"[{ProgressBar.byte_rescale(rate)}/s] " f"ETA: {eta}", end="\r") # Flyter Classes class FlyterSender: """ Handles Flyter file sending processes. Note: Sends to FlyterReceiver instances. Parameterss ---------- recver_ip : str The IP address of the receiver. main_port : int The main TCP port of the receiver. """ DEFAULT_PACKET_SIZE = 1024 def __init__(self, recver_ip, main_port): self.recver_ip = recver_ip self.main_port = main_port self.token = token_bytes(6) self._recver_hostname = None self._recver_token = None self._transfer_type = None self._worker_ports = None self._packet_size = FlyterSender.DEFAULT_PACKET_SIZE self._sending_file = False self._workers_active = 0 self._progress_bar = None try: self.socket = socket(AF_INET, SOCK_STREAM) self.socket.settimeout(60) except: printerror('Error initializing sockets') self.param_set = False def __del__(self): if isinstance(self.socket, socket): self.socket.close() def _send_s(self, filepath, file_size): """ Send a file with a single worker. Parameters ---------- filepath : str The filepath to the file to be sent. """ if not self.param_set: return printerror("Not yet set with receiver's parameters") if not exists(filepath): return printerror("File doesn't exist") self._sending_file = True try: fs = file_size with open(filepath, 'br') as f: while self._sending_file and fs: packet = f.read(self._packet_size) if not packet: break self.socket.send(packet) assert self.socket.recv(1) == b'\x06' # ACK self._progress_bar.add_progress(len(packet)) fs -= len(packet) except AssertionError: self._progress_bar.stop() return printerror("Receiver rejected packet") except FileNotFoundError: self._progress_bar.stop() return printerror("Couldn't access file") except PermissionError: self._progress_bar.stop() return printerror("Couldn't access file due to permission error") except timeout: self._progress_bar.stop() return printerror("Operation timed out") except: self._progress_bar.stop() return printerror(f"Error while sending file") else: self._sending_file = False return True def _send_m(self, filepath, file_sizes): """ Send a file with multiple workers. Speeds up transmission rate by using multiple workers. Parameters ---------- filepath : str The filepath to the file to be sent. file_sizes : list(int) The sizes of the split-up file to be sent. """ if not self.param_set: return printerror("Not yet set with receiver's parameters") if not exists(filepath): printerror("File doesn't exist") def threadfunc(worker_num, fpath, start, end): self._workers_active += 1 try: with socket(AF_INET, SOCK_STREAM) as sock: sock.connect( (self.recver_ip, self._worker_ports[worker_num]) ) sock.send(self.token) assert sock.recv(1) == b'\x06' # ACK fs = end - start with open(fpath, 'br') as f: f.seek(start) while self._sending_file and fs: end_size = f.tell() + self._packet_size size = (self._packet_size - max(0, end_size - end)) packet = f.read(size) if not packet: break sock.send(packet) assert sock.recv(1) == b'\x06' # ACK self._progress_bar.add_progress(len(packet)) fs -= len(packet) except KeyboardInterrupt: self._progress_bar.stop() self._sending_file = False return printerror("User aborted operation") except AssertionError: self._progress_bar.stop() self._sending_file = False return printerror(f"Receiver rejected packet") except FileNotFoundError: self._progress_bar.stop() self._sending_file = False return printerror("Couldn't access file") except PermissionError: self._progress_bar.stop() self._sending_file = False return printerror("Couldn't access file due to permission " "error") except timeout: self._progress_bar.stop() self._sending_file = False return printerror("Operation timed out") except: self._progress_bar.stop() self._sending_file = False return printerror(f"Error while sending file") finally: self._workers_active -= 1 num_workers = len(self._worker_ports) self._sending_file = True try: size = 0 for w in range(num_workers): Thread( target=threadfunc, args=( w, filepath, size, size + file_sizes[w] ), ).start() size += file_sizes[w] except FileNotFoundError: return printerror("Couldn't access file") except PermissionError: return printerror("Couldn't access file due to permission error") except: return printerror("Error while starting to send file") while self._workers_active: try: pass except KeyboardInterrupt: self._progress_bar.stop() self._sending_file = False return printerror("User aborted operation") self._sending_file = False return True def send_file(self, filepath): """ Send a file. Parameters ---------- filepath : str The filepath of the file to be sent. """ if not self.param_set: return printerror("Not yet set with receiver's parameters") if not exists(filepath): return printerror("File doesn't exist") # Headers try: tok = self.token num_w = max(1, len(self._worker_ports)) fpath = filepath.replace(altsep, sep) fname = fpath.split(sep)[-1] fsize = stat(fpath).st_size fsizes = [fsize//num_w for w in range(num_w)] fsizes[-1] += fsize - sum(fsizes) fn = pack_str(fname) len_fn = int_to_bytes_s(len(fn)) fs = [int_to_bytes_l(s) for s in fsizes] fs = b''.join(fs) len_fs = int_to_bytes_s(num_w) headers = b''.join([tok, len_fn, fn, len_fs, fs]) except: return printerror("Error while preparing headers") try: b64_tok = b64encode(self._recver_token).decode() printalert(f"Sending to {self._recver_hostname}-{b64_tok}:" f" [ {fname} ]") self.socket.send(headers) print("Waiting for receiver to accept file") assert self.socket.recv(1) == b'\x06' # ACK except KeyboardInterrupt: return printerror("User aborted operation") except AssertionError: return printerror("Receiver rejected") except timeout: return printerror("Operation timed out") except Exception: return printerror("Error while sending headers to receiver") print(f"[ {gethostname()}-{b64encode(self.token).decode()} ] " f"is now sending file ({ProgressBar.byte_rescale(fsize)})") # Progress bar thread self._progress_bar = ProgressBar(fsize, 40) self._progress_bar.start() def progress_thread(): try: # Wait until sending file while not self._sending_file: pass # Display until file is sent while not self._progress_bar.done: self._progress_bar.display() except: return printerror("Error with progress thread") Thread(target=progress_thread).start() # Start sending res = None try: if self._transfer_type == 'S': res = self._send_s(fpath, fsize) elif self._transfer_type == 'M': res = self._send_m(fpath, fsizes) assert self.socket.recv(1) == b'\x06' # ACK except: self._progress_bar.stop() self._sending_file = False return printerror(f"Sending file was unsuccessful") else: # Wait for progress bar while not self._progress_bar.done: pass self._progress_bar.display() print(f"\nSuccessfully sent: {fname}") return res def recv_param_set(self): """ Receive and unpack Receiver's parameter settings. Used to set Sender's parameter settings used during data transmissions. """ try: self.socket.connect((self.recver_ip, self.main_port)) except error: return printerror("Can't connect to " f"{self.recver_ip}:{self.main_port}") try: sender_hn = pack_str(gethostname()) len_sender_hn = int_to_bytes_s(len(sender_hn)) self.socket.send(b''.join([len_sender_hn, sender_hn])) assert self.socket.recv(1) == b'\x06' # ACK except AssertionError: return printerror("Receiver rejected handshake") except timeout: return printerror('Operation timed out') except: return printerror("Error during handshake") try: len_hn = bytes_to_int_s(self.socket.recv(2)) self._recver_hostname = unpack_str(self.socket.recv(len_hn)) self._recver_token = self.socket.recv(6) self._transfer_type = unpack_str(self.socket.recv(1)) len_wp = bytes_to_int_s(self.socket.recv(2)) self._worker_ports = [bytes_to_int_s(self.socket.recv(2)) for w in range(len_wp)] self.socket.send(b'\x06') # ACK except error: return printerror("Error getting connected with socket") except: self.socket.send(b'\x15') # NAK return printerror("Error getting parameters from receiver") else: self.param_set = True class FlyterReciever: """ Handles Flyter file receiving processes. Note: Receives from FlyterSender instances. Parameters ---------- host_ip : str The Host IP address to be used. main_port : int The main TCP port to be used. num_workers : int The amount of workers to be used during transmission. """ @staticmethod def storage_dir(hostname=None): """ Return the path of the storage dir for received files. If storage directory doesn't exist, creates it first. Parameters ---------- hostname : str The name of the subdirectory where that host's sent files are stored. """ app_dirname = dirname(__file__) appfiles_dirname = join(app_dirname, 'Flyter') if not exists(appfiles_dirname): mkdir(appfiles_dirname) storage_dirname = join(appfiles_dirname, 'Received Files') if not exists(storage_dirname): mkdir(storage_dirname) if hostname: host_storage_dirname = join(storage_dirname, hostname) if not exists(host_storage_dirname): mkdir(host_storage_dirname) return host_storage_dirname else: return storage_dirname DEFAULT_PACKET_SIZE = 512 def __init__(self, host_ip, main_port, num_workers): self.host_ip = host_ip self.main_port = main_port self.token = token_bytes(6) self.transfer_type = 'S' if num_workers == 1 else 'M' self.worker_ports = [ random_port(self.host_ip) for w in range(num_workers) ] if num_workers > 1 else [] self._sender_socket = None self._sender_hostname = None self._sender_token = None self._sender_filename = None self._sender_filesizes = None self._packet_size = FlyterSender.DEFAULT_PACKET_SIZE self._recving_file = False self._workers_active = 0 self._progress_bar = ProgressBar(None) try: self.socket = socket(AF_INET, SOCK_STREAM) self.socket.bind((self.host_ip, self.main_port)) self.socket.settimeout(60) self.workers = [ socket(AF_INET, SOCK_STREAM) for w in range(num_workers) ] if num_workers > 1 else [] if self.workers: for w in range(num_workers): self.workers[w].bind((self.host_ip, self.worker_ports[w])) self.workers[w].settimeout(60) except: printerror('Error initializing sockets') self.param_set = False def __del__(self): if isinstance(self.__dict__.get('socket'), socket): self.socket.close() if self.__dict__.get('workers'): for w in self.workers: w.close() def _recv_s(self): """Receive a file with a single worker.""" if not self.param_set: return printerror("Sender not yet set with parameters") try: self._recving_file = True path = join( FlyterReciever.storage_dir(self._sender_hostname), self._sender_filename ) fs = self._sender_filesizes[0] with open(path, 'bw') as f: while self._recving_file and fs: packet = self._sender_socket.recv(self._packet_size) f.write(packet) self._progress_bar.add_progress(len(packet)) fs -= len(packet) self._sender_socket.send(b'\x06') # ACK except timeout: self._progress_bar.stop() return printerror("Operation timed out") except FileNotFoundError: self._progress_bar.stop() return printerror("Downloading file has been deleted") except PermissionError: self._progress_bar.stop() return printerror("Couldn't access storage directory") except error: self._progress_bar.stop() return printerror("Error with socket") except: self._progress_bar.stop() return printerror("Error receiving file") else: self._recving_file = False return True def _recv_m(self): """ Receive a file with multiple workers. Speeds up transmission rate by using multiple workers. """ if not self.param_set: return printerror("Sender not yet set with parameters") def threadfunc(worker_num, fpath): self._workers_active += 1 try: recver_socket = self.workers[worker_num] recver_socket.listen(1) sender_socket, hostaddr = recver_socket.accept() send_tok = sender_socket.recv(6) if send_tok == self._sender_token: sender_socket.send(b'\x06') # ACK else: sender_socket.send(b'\x15') # NAK fs = self._sender_filesizes[worker_num] with open(fpath, 'bw') as f: while self._recving_file and f.writable() and fs: packet = sender_socket.recv(self._packet_size) f.write(packet) self._progress_bar.add_progress(len(packet)) fs -= len(packet) sender_socket.send(b'\x06') # ACK except KeyboardInterrupt: self._progress_bar.stop() self._recving_file = False return printerror("User aborted operation") except timeout: self._progress_bar.stop() self._recving_file = False return printerror("Operation timed out") except error: self._progress_bar.stop() self._recving_file = False return printerror("Error with sockets") except: self._progress_bar.stop() self._recving_file = False return printerror("Error while receiving file") finally: self._workers_active -= 1 num_workers = len(self.workers) self._recving_file = True try: for w in range(len(self.worker_ports)): wpath = join( FlyterReciever.storage_dir(self._sender_hostname), f"{w}_{self._sender_filename}" ) Thread( target=threadfunc, args=(w, wpath), ).start() except FileNotFoundError: return printerror("Couldn't access file") except PermissionError: return printerror("Couldn't access file due to permission error") while self._workers_active: try: pass except KeyboardInterrupt: self._progress_bar.stop() self._recving_file = False printerror("User aborted operation") self._recving_file = False try: # Build the file path = join( FlyterReciever.storage_dir(self._sender_hostname), self._sender_filename ) with open(path, 'bw') as output: for w in range(num_workers): wpath = join( FlyterReciever.storage_dir(self._sender_hostname), f"{w}_{self._sender_filename}" ) with open(wpath, 'br') as temp: packet = True while packet: packet = temp.read(self._packet_size) output.write(packet) # Clear the contents of the temp file open(wpath, 'bw').close() # Delete the temp files for w in range(num_workers): wpath = join( FlyterReciever.storage_dir(self._sender_hostname), f"{w}_{self._sender_filename}" ) unlink(wpath) except PermissionError: self._sender_socket.send(b'\x15') # NAK return printerror("Couldn't save file due to permissions") except error: return printerror("Error with sockets") except: self._sender_socket.send(b'\x15') # NAK return printerror("Error while saving file") else: return True def recv_file(self): """Receive a file.""" if not self.param_set: return printerror("Not yet set with receiver's parameters") # Headers try: tok = self._sender_socket.recv(6) b64_tok = b64encode(tok).decode() len_fn = bytes_to_int_s(self._sender_socket.recv(2)) fn = unpack_str(self._sender_socket.recv(len_fn)) len_fs = bytes_to_int_s(self._sender_socket.recv(2)) fs = [bytes_to_int_l(self._sender_socket.recv(4)) for s in range(len_fs)] fs_all = sum(fs) answer = input(f"{self._sender_hostname}-{b64_tok}" f" wants to send: {fn} " f"({ProgressBar.byte_rescale(fs_all)}). " "Accept? (y/n) ") if answer.lower() == 'y': self._sender_socket.send(b'\x06') # ACK else: self._sender_socket.send(b'\x06') # NAK return printalert("Rejected file transfer") except error: return printerror("Sender isn't available anymore") except: self._sender_socket.send(b'\x15') # NAK return printerror("Error while receiving headers") print(f"[ {gethostname()}-{b64encode(self.token).decode()} ] " f"is now receiving file ({ProgressBar.byte_rescale(fs_all)})") # Progress bar thread self._progress_bar = ProgressBar(fs_all, 35) self._progress_bar.start() def progress_thread(): try: # Wait until receiving file while not self._recving_file: pass # Display until file is received while not self._progress_bar.done: self._progress_bar.display() except: return printerror("Error with progress thread") Thread(target=progress_thread).start() self._sender_token = tok self._sender_filename = fn self._sender_filesizes = fs # Start receiving try: if self.transfer_type == 'S': res = self._recv_s() elif self.transfer_type == 'M': res = self._recv_m() else: res = None except: self._progress_bar.stop() self._recving_file = False return printerror("Receiving file was unsuccessful") else: self._sender_socket.send(b'\x06') # ACK # Wait for progress bar while not self._progress_bar.done: pass self._progress_bar.display() print(f"\nSuccessfully received: {self._sender_filename}") return res def send_param_set(self): """ Pack and send Receiver's parameter settings. Used to set Sender's parameter settings used during data transmissions. """ try: printalert("Waiting for sender") self.socket.listen(1) self._sender_socket, addrport = self.socket.accept() except timeout: return printerror("No sender available") except: return printerror("Error while waiting for sender") try: len_sender_hn = bytes_to_int_s(self._sender_socket.recv(2)) sender_hn = self._sender_socket.recv(len_sender_hn) self._sender_hostname = unpack_str(sender_hn) self._sender_socket.send(b'\x06') # ACK except timeout: return printerror("Operation timed out") except: return printerror("Error during handshake") try: hn = pack_str(gethostname()) len_hn = int_to_bytes_s(len(hn)) tok = self.token tr_type = pack_str(self.transfer_type) len_wp = int_to_bytes_s(len(self.worker_ports)) wp = [int_to_bytes_s(port) for port in self.worker_ports] wp = b''.join(wp) headers = b''.join([len_hn, hn, tok, tr_type, len_wp, wp]) except: return printerror("Error building headers") try: self._sender_socket.send(headers) assert self._sender_socket.recv(1) == b'\x06' # ACK except: return printerror("Error while sending headers to sender") else: self.param_set = True # Simplified Functions def send(ip_address, port, filepath): """ Send file to receiver on the same network. Parameters ---------- ip_address : str The target receiver's IP address. port : int The target receiver's main TCP port. filepath : str The path to the file to be sent. """ sender = FlyterSender(ip_address, port) sender.recv_param_set() return sender.send_file(filepath) def receive(host_ip_address, port, workers=1): """ Receive a file from sender on the same network. Parameters ---------- host_ip_address : str The receiver's host IP address. port : int The receiver's host port to listen on. workers : :obj:`int`, optional The number of workers to use. """ receiver = FlyterReciever(host_ip_address, port, workers) receiver.send_param_set() receiver.recv_file() if __name__ == '__main__': parser = ArgumentParser( prog="Flyter", epilog="See '<command> --help' to read about a specific sub-command." ) subparsers = parser.add_subparsers( dest="action", help="The action to be performed" ) send_parser = subparsers.add_parser("send") recv_parser = subparsers.add_parser("recv") send_parser.add_argument('-i', '--ip', required=True, help="Target receiver's IP address") send_parser.add_argument('-p', '--port', type=int, required=True, help="Target receiver's TCP port number") send_parser.add_argument('-f', '--file', required=True, help="Path to the file to be sent") recv_parser.add_argument('-i', '--ip', required=True, help="Host IP address") recv_parser.add_argument('-p', '--port', type=int, required=True, help="TCP port to listen on") recv_parser.add_argument('-w', '--workers', type=int, default=1, help="TCP port to listen on") if len(argv) > 1: FROMTERMINAL = True args = parser.parse_args() if args.action == "send": send(args.ip, args.port, args.file) elif args.action == "recv": receive(args.ip, args.port, args.workers) else: parser.print_help()

0a29f1417c7897dd77e238158ebcffa7aedd19a4

py

Python

tests/test_modeling_tf_led.py

patelrajnath/transformers

98afe9d7c94a840d4b30c7eb76f9bfe570d2ed50

tests/test_modeling_tf_led.py

patelrajnath/transformers

98afe9d7c94a840d4b30c7eb76f9bfe570d2ed50

tests/test_modeling_tf_led.py

patelrajnath/transformers

98afe9d7c94a840d4b30c7eb76f9bfe570d2ed50

# coding=utf-8 # Copyright Iz Beltagy, Matthew E. Peters, Arman Cohan and The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import unittest from transformers import LEDConfig, is_tf_available from transformers.testing_utils import require_tf, slow from .test_configuration_common import ConfigTester from .test_modeling_tf_common import TFModelTesterMixin, ids_tensor if is_tf_available(): import tensorflow as tf from transformers import TFLEDForConditionalGeneration, TFLEDModel @require_tf class TFLEDModelTester: config_cls = LEDConfig config_updates = {} hidden_act = "gelu" def __init__( self, parent, batch_size=13, seq_length=7, is_training=True, use_labels=False, vocab_size=99, hidden_size=32, num_hidden_layers=5, num_attention_heads=4, intermediate_size=37, hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1, max_position_embeddings=20, eos_token_id=2, pad_token_id=1, bos_token_id=0, attention_window=4, ): self.parent = parent self.batch_size = batch_size self.seq_length = seq_length self.is_training = is_training self.use_labels = use_labels self.vocab_size = vocab_size self.hidden_size = hidden_size self.num_hidden_layers = num_hidden_layers self.num_attention_heads = num_attention_heads self.intermediate_size = intermediate_size self.hidden_dropout_prob = hidden_dropout_prob self.attention_probs_dropout_prob = attention_probs_dropout_prob self.max_position_embeddings = max_position_embeddings self.eos_token_id = eos_token_id self.pad_token_id = pad_token_id self.bos_token_id = bos_token_id self.attention_window = attention_window # `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size # [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention # returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1] # because its local attention only attends to `self.attention_window` and one before and one after self.key_length = self.attention_window + 1 # because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for # the `test_attention_outputs` and `test_hidden_states_output` tests self.encoder_seq_length = ( self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window ) def prepare_config_and_inputs_for_common(self): input_ids = ids_tensor([self.batch_size, self.seq_length - 1], self.vocab_size) eos_tensor = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size), 1) input_ids = tf.concat([input_ids, eos_tensor], axis=1) decoder_input_ids = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) config = self.config_cls( vocab_size=self.vocab_size, d_model=self.hidden_size, encoder_layers=self.num_hidden_layers, decoder_layers=self.num_hidden_layers, encoder_attention_heads=self.num_attention_heads, decoder_attention_heads=self.num_attention_heads, encoder_ffn_dim=self.intermediate_size, decoder_ffn_dim=self.intermediate_size, dropout=self.hidden_dropout_prob, attention_dropout=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, eos_token_ids=[2], bos_token_id=self.bos_token_id, pad_token_id=self.pad_token_id, decoder_start_token_id=self.pad_token_id, attention_window=self.attention_window, **self.config_updates, ) inputs_dict = prepare_led_inputs_dict(config, input_ids, decoder_input_ids) global_attention_mask = tf.concat( [tf.zeros_like(input_ids)[:, :-1], tf.ones_like(input_ids)[:, -1:]], axis=-1, ) inputs_dict["global_attention_mask"] = global_attention_mask return config, inputs_dict def check_decoder_model_past_large_inputs(self, config, inputs_dict): model = TFLEDModel(config=config).get_decoder() input_ids = inputs_dict["input_ids"] input_ids = input_ids[:1, :] attention_mask = inputs_dict["attention_mask"][:1, :] self.batch_size = 1 # first forward pass outputs = model(input_ids, attention_mask=attention_mask, use_cache=True) output, past_key_values = outputs.to_tuple() past_key_values = past_key_values[1] # create hypothetical next token and extent to next_input_ids next_tokens = ids_tensor((self.batch_size, 3), config.vocab_size) next_attn_mask = tf.cast(ids_tensor((self.batch_size, 3), 2), tf.int8) # append to next input_ids and next_input_ids = tf.concat([input_ids, next_tokens], axis=-1) next_attention_mask = tf.concat([attention_mask, next_attn_mask], axis=-1) output_from_no_past = model(next_input_ids, attention_mask=next_attention_mask)[0] output_from_past = model(next_tokens, attention_mask=next_attention_mask, past_key_values=past_key_values)[0] self.parent.assertEqual(next_tokens.shape[1], output_from_past.shape[1]) # select random slice random_slice_idx = int(ids_tensor((1,), output_from_past.shape[-1])) output_from_no_past_slice = output_from_no_past[:, -3:, random_slice_idx] output_from_past_slice = output_from_past[:, :, random_slice_idx] # test that outputs are equal for slice tf.debugging.assert_near(output_from_past_slice, output_from_no_past_slice, rtol=1e-3) def prepare_led_inputs_dict( config, input_ids, decoder_input_ids, attention_mask=None, decoder_attention_mask=None, ): if attention_mask is None: attention_mask = tf.cast(tf.math.not_equal(input_ids, config.pad_token_id), tf.int8) if decoder_attention_mask is None: decoder_attention_mask = tf.cast(tf.math.not_equal(decoder_input_ids, config.pad_token_id), tf.int8) return { "input_ids": input_ids, "attention_mask": attention_mask, "decoder_input_ids": decoder_input_ids, "decoder_attention_mask": decoder_attention_mask, } @require_tf class TFLEDModelTest(TFModelTesterMixin, unittest.TestCase): all_model_classes = (TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else () all_generative_model_classes = (TFLEDForConditionalGeneration,) if is_tf_available() else () is_encoder_decoder = True test_pruning = False def setUp(self): self.model_tester = TFLEDModelTester(self) self.config_tester = ConfigTester(self, config_class=LEDConfig) def test_config(self): self.config_tester.run_common_tests() def test_decoder_model_past_large_inputs(self): config_and_inputs = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_decoder_model_past_large_inputs(*config_and_inputs) def test_model_common_attributes(self): config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: model = model_class(config) assert isinstance(model.get_input_embeddings(), tf.keras.layers.Layer) x = model.get_output_layer_with_bias() assert x is None name = model.get_prefix_bias_name() assert name is None def test_attention_outputs(self): config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common() inputs_dict["global_attention_mask"] = tf.zeros_like(inputs_dict["attention_mask"]) num_global_attn_indices = 2 inputs_dict["global_attention_mask"] = tf.where( tf.range(self.model_tester.seq_length)[None, :] < num_global_attn_indices, 1, inputs_dict["global_attention_mask"], ) config.return_dict = True seq_length = self.model_tester.seq_length encoder_seq_length = self.model_tester.encoder_seq_length def check_decoder_attentions_output(outputs): decoder_attentions = outputs.decoder_attentions self.assertEqual(len(decoder_attentions), self.model_tester.num_hidden_layers) self.assertListEqual( list(decoder_attentions[0].shape[-3:]), [self.model_tester.num_attention_heads, seq_length, seq_length], ) def check_encoder_attentions_output(outputs): attentions = [t.numpy() for t in outputs.encoder_attentions] global_attentions = [t.numpy() for t in outputs.encoder_global_attentions] self.assertEqual(len(attentions), self.model_tester.num_hidden_layers) self.assertEqual(len(global_attentions), self.model_tester.num_hidden_layers) self.assertListEqual( list(attentions[0].shape[-3:]), [self.model_tester.num_attention_heads, encoder_seq_length, seq_length], ) self.assertListEqual( list(global_attentions[0].shape[-3:]), [self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices], ) for model_class in self.all_model_classes: inputs_dict["output_attentions"] = True inputs_dict["use_cache"] = False config.output_hidden_states = False model = model_class(config) outputs = model(self._prepare_for_class(inputs_dict, model_class)) out_len = len(outputs) self.assertEqual(config.output_hidden_states, False) check_encoder_attentions_output(outputs) if self.is_encoder_decoder: model = model_class(config) outputs = model(self._prepare_for_class(inputs_dict, model_class)) self.assertEqual(config.output_hidden_states, False) check_decoder_attentions_output(outputs) # Check that output attentions can also be changed via the config del inputs_dict["output_attentions"] config.output_attentions = True model = model_class(config) outputs = model(self._prepare_for_class(inputs_dict, model_class)) self.assertEqual(config.output_hidden_states, False) check_encoder_attentions_output(outputs) # Check attention is always last and order is fine inputs_dict["output_attentions"] = True config.output_hidden_states = True model = model_class(config) outputs = model(self._prepare_for_class(inputs_dict, model_class)) self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1), len(outputs)) self.assertEqual(model.config.output_hidden_states, True) check_encoder_attentions_output(outputs) @slow def test_saved_model_with_attentions_output(self): # longformer has special attentions which are not # compatible in graph mode pass @slow def test_saved_model_with_hidden_states_output(self): # TODO(JPLU, PVP) this test should pass!!! PVP: # IMO there is a problem with the signature check. # Test passes for TFLEDModel, but not for TFLEDForConditionalGeneration # IMO the reason is that the tensor variable name cannot be changed # from decoder_input_ids -> input_ids, which poses a BIG restrictions pass def _assert_tensors_equal(a, b, atol=1e-12, prefix=""): """If tensors not close, or a and b arent both tensors, raise a nice Assertion error.""" if a is None and b is None: return True try: if tf.debugging.assert_near(a, b, atol=atol): return True raise except Exception: msg = "{} != {}".format(a, b) if prefix: msg = prefix + ": " + msg raise AssertionError(msg) def _long_tensor(tok_lst): return tf.constant(tok_lst, dtype=tf.int32) TOLERANCE = 1e-4 @slow @require_tf class TFLEDModelIntegrationTest(unittest.TestCase): def test_inference_no_head(self): model = TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384").led # change to intended input here input_ids = _long_tensor([512 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]) decoder_input_ids = _long_tensor([128 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]) inputs_dict = prepare_led_inputs_dict(model.config, input_ids, decoder_input_ids) output = model(**inputs_dict)[0] expected_shape = (1, 1024, 768) self.assertEqual(output.shape, expected_shape) # change to expected output here expected_slice = tf.convert_to_tensor( [[2.3050, 2.8279, 0.6531], [-1.8457, -0.1455, -3.5661], [-1.0186, 0.4586, -2.2043]], ) tf.debugging.assert_near(output[:, :3, :3], expected_slice, atol=TOLERANCE) def test_inference_with_head(self): model = TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384") # change to intended input here input_ids = _long_tensor([512 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]) decoder_input_ids = _long_tensor([128 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]) inputs_dict = prepare_led_inputs_dict(model.config, input_ids, decoder_input_ids) output = model(**inputs_dict)[0] expected_shape = (1, 1024, model.config.vocab_size) self.assertEqual(output.shape, expected_shape) # change to expected output here expected_slice = tf.convert_to_tensor( [[33.6507, 6.4572, 16.8089], [5.8739, -2.4238, 11.2902], [-3.2139, -4.3149, 4.2783]], ) tf.debugging.assert_near(output[:, :3, :3], expected_slice, atol=TOLERANCE)

0a2a4e7e62506f1bbd8360775e618cece1d71944

py

Python

src/wann_genetic/individual/numpy/ffnn.py

plonerma/wann-genetic

c4a8a1db81665b2549994d615e1d347dbe00226a

src/wann_genetic/individual/numpy/ffnn.py

plonerma/wann-genetic

c4a8a1db81665b2549994d615e1d347dbe00226a

src/wann_genetic/individual/numpy/ffnn.py

plonerma/wann-genetic

c4a8a1db81665b2549994d615e1d347dbe00226a

import numpy as np import sklearn import logging from wann_genetic.individual.network_base import BaseFFNN def softmax(x, axis=-1): """Compute softmax values for each sets of scores in x. Returns: softmax - softmax normalized in dim axis """ e_x = np.exp(x - np.expand_dims(np.max(x,axis=axis), axis=axis)) s = (e_x / np.expand_dims(e_x.sum(axis=-1), axis=axis)) return s def apply_act_function(available_funcs, selected_funcs, x=None): """Apply the activation function of the selected nodes to their sums. This fullfils the same function as the :class:`wann_genetic.individual.torch.ffn.MultiActivationModule`. """ if x is not None: result = np.empty(x.shape) for i, func in enumerate(selected_funcs): assert func < len(available_funcs) result[..., i] = available_funcs[func][1](x[..., i]) return result else: return np.array([ # return function names available_funcs[func][0] for func in selected_funcs ]) class Network(BaseFFNN): """Numpy implmentation of a Feed Forward Neural Network For an explanation of how propagation works, see :doc:`numpy_network`. """ # Definition of the activations functions available_act_functions = [ ('relu', lambda x: np.maximum(0, x)), ('sigmoid', lambda x: (np.tanh(x/2.0) + 1.0)/2.0), ('tanh', lambda x: np.tanh(x)), ('gaussian (standard)', lambda x: np.exp(-np.multiply(x, x) / 2.0)), ('step', lambda x: 1.0*(x>0.0)), ('identity', lambda x: x), ('inverse', lambda x: -x), ('squared', lambda x: x**2), # unstable if applied multiple times ('abs', lambda x: np.abs(x)), ('cos', lambda x: np.cos(np.pi*x)), ('sin ', lambda x: np.sin(np.pi*x)), ] enabled_act_functions = available_act_functions def get_measurements(self, weights, x, y_true=None, measures=['predictions']): assert len(x.shape) == 2 # multiple one dimensional input arrays assert isinstance(weights, np.ndarray) # initial activations act_vec = np.empty((weights.shape[0], x.shape[0], self.n_nodes), dtype=float) act_vec[..., :self.n_in] = x[...] act_vec[..., self.n_in] = 1 # bias # propagate signal through all layers for active_nodes in self.layers(): act_vec[..., active_nodes] = self.calc_act(act_vec, active_nodes, weights) # if any node is nan, we cant rely on the result valid = np.all(~np.isnan(act_vec), axis=-1) act_vec[~valid, :] = np.nan y_raw = act_vec[..., -self.n_out:] return self.measurements_from_output(y_raw, y_true, measures) def measurements_from_output(self, y_raw, y_true, measures): return_values = dict() if 'raw' in measures: return_values['raw'] = y_raw y_pred = np.argmax(y_raw, axis=-1) y_prob = softmax(y_raw, axis=-1) if 'probabilities' in measures: return_values['probabilities'] = y_prob if 'predictions' in measures: return_values['predictions'] = y_pred y_raw = y_raw.reshape(y_raw.shape[0], -1, self.n_out) y_prob = y_prob.reshape(y_raw.shape[0], -1, self.n_out) y_pred = y_pred.reshape(y_raw.shape[0], -1) if y_true is not None: y_true = y_true.reshape(-1) if 'log_loss' in measures: # nan is same as maximally falsely predicted y_prob[~np.isfinite(y_prob)] = 0 return_values['log_loss'] = np.array([ sklearn.metrics.log_loss(y_true, prob, labels=np.arange(self.n_out)) for prob in y_prob ]) if 'mse_loss' in measures: return_values['mse_loss'] = np.array([ sklearn.metrics.mean_squared_error(y_true, raw) for raw in y_raw ]) if 'accuracy' in measures: return_values['accuracy'] = np.array([ sklearn.metrics.accuracy_score(y_true, pred) for pred in y_pred ]) if 'kappa' in measures: return_values['kappa'] = np.array([ sklearn.metrics.cohen_kappa_score(y_true, pred) for pred in y_pred ]) return return_values def activation_functions(self, nodes, x=None): funcs = self.nodes['func'][nodes - self.offset] return apply_act_function(self.enabled_act_functions, funcs, x) def calc_act(self, x, active_nodes, base_weights, add_to_sum=0): """Apply updates for active nodes (active nodes can't share edges). """ addend_nodes = active_nodes[0] M = self.weight_matrix[:addend_nodes, active_nodes - self.offset] # x3d: weights, samples, source nodes # M3d: weights, source, target # multiply relevant weight matrix with base weights M3d = M[None, :, :] * base_weights[:, None, None] x3d = x[..., :addend_nodes] act_sums = np.matmul(x3d, M3d) + add_to_sum # apply activation function for active nodes return self.activation_functions(active_nodes, act_sums)

0a2acc58ab0f0250a6af12c5eb3f75f975289067

py

Python

common/tests/util.py

uktrade/tamato

4ba2ffb25eea2887e4e081c81da7634cd7b4f9ca

2020-03-25T11:11:29.000Z

2022-03-08T20:41:33.000Z

common/tests/util.py

uktrade/tamato

4ba2ffb25eea2887e4e081c81da7634cd7b4f9ca

2020-03-25T10:42:09.000Z

2022-03-30T15:32:26.000Z

common/tests/util.py

uktrade/tamato

4ba2ffb25eea2887e4e081c81da7634cd7b4f9ca

2020-08-06T12:22:41.000Z

2022-01-16T11:51:12.000Z

import contextlib from datetime import date from datetime import datetime from datetime import timezone from functools import wraps from io import BytesIO from itertools import count from typing import Any from typing import Dict from typing import Sequence import pytest from dateutil.parser import parse as parse_date from dateutil.relativedelta import relativedelta from django import forms from django.core.exceptions import ValidationError from django.template.loader import render_to_string from django.urls import reverse from freezegun import freeze_time from lxml import etree from common.models.records import TrackedModel from common.renderers import counter_generator from common.serializers import validate_taric_xml_record_order from common.util import TaricDateRange from common.util import get_accessor from common.util import get_field_tuple INTERDEPENDENT_IMPORT_IMPLEMENTED = True UPDATE_IMPORTER_IMPLEMENTED = True EXPORT_REFUND_NOMENCLATURE_IMPLEMENTED = False COMMODITIES_IMPLEMENTED = True MEURSING_TABLES_IMPLEMENTED = False PARTIAL_TEMPORARY_STOP_IMPLEMENTED = False UTC = timezone.utc requires_commodities = pytest.mark.skipif( not COMMODITIES_IMPLEMENTED, reason="Commodities not implemented", ) requires_export_refund_nomenclature = pytest.mark.skipif( not EXPORT_REFUND_NOMENCLATURE_IMPLEMENTED, reason="Export refund nomenclature not implemented", ) requires_meursing_tables = pytest.mark.skipif( not MEURSING_TABLES_IMPLEMENTED, reason="Meursing tables not implemented", ) requires_partial_temporary_stop = pytest.mark.skipif( not PARTIAL_TEMPORARY_STOP_IMPLEMENTED, reason="Partial temporary stop not implemented", ) requires_interdependent_import = pytest.mark.skipif( not INTERDEPENDENT_IMPORT_IMPLEMENTED, reason="Interdependent imports not implemented", ) requires_update_importer = pytest.mark.skipif( not UPDATE_IMPORTER_IMPLEMENTED, reason="Requires Updating importers to be implemented", ) @contextlib.contextmanager def raises_if(exception, expected): try: yield except exception: if not expected: raise else: if expected: pytest.fail(f"Did not raise {exception}") def check_validator(validate, value, expected_valid): try: validate(value) except ValidationError: if expected_valid: pytest.fail(f'Unexpected validation error for value "{value}"') except Exception: raise else: if not expected_valid: pytest.fail(f'Expected validation error for value "{value}"') def make_duplicate_record(factory, identifying_fields=None): """Creates two records using the passed factory that are duplicates of each other and returns the record created last.""" existing = factory.create() # allow overriding identifying_fields if identifying_fields is None: identifying_fields = list(factory._meta.model.identifying_fields) return factory.create( **dict(get_field_tuple(existing, field) for field in identifying_fields) ) def make_non_duplicate_record(factory, identifying_fields=None): """Creates two records using the passed factory that are not duplicates of each other and returns the record created last.""" existing = factory.create() not_duplicate = factory.create() if identifying_fields is None: identifying_fields = list(factory._meta.model.identifying_fields) assert any( get_field_tuple(existing, f) != get_field_tuple(not_duplicate, f) for f in identifying_fields ) return not_duplicate def get_checkable_data(model: TrackedModel, ignore=frozenset()): """ Returns a dict representing the model's data ignoring any automatically set fields and fields with names passed to `ignore`. The returned data will contain the identifying fields for any linked models rather than internal PKs. For example: get_checkable_data(FootnoteDescriptionFactory(), ignore={"sid"}) # { # "description": "My sample footnote text", # "described_footnote": { # "footnote_type__footnote_type_id": "FN" # "footnote_id": "123", # }, # } """ checked_field_names = {f.name for f in model.copyable_fields} - ignore data = { name: getattr(model, get_accessor(model._meta.get_field(name))) for name in checked_field_names } identifying_fields = { name: data[name].get_identifying_fields() for name in checked_field_names if hasattr(data[name], "get_identifying_fields") } data.update(identifying_fields) return data def assert_records_match( expected: TrackedModel, imported: TrackedModel, ignore=frozenset(), ): """ Asserts that every value for every field in the imported model is the same as the data in the expected model. System fields that will change from model to model are not checked. Any field names given to `ignore` will also not be checked. """ expected_data = get_checkable_data(expected, ignore=ignore) imported_data = get_checkable_data(imported, ignore=ignore) assert expected_data == imported_data def assert_many_records_match( expected: Sequence[TrackedModel], imported: Sequence[TrackedModel], ignore=frozenset(), ): """ Asserts that every value for every field in the imported models is the same as the data in the expected models, and that the count of both is equal. System fields that will change from model to model are not checked. Any field names given to `ignore` will also not be checked. """ expected_data = [get_checkable_data(e, ignore=ignore) for e in expected] imported_data = [get_checkable_data(i, ignore=ignore) for i in imported] assert expected_data == imported_data _transaction_counter = count(start=1) def generate_test_import_xml(obj: dict) -> BytesIO: xml = render_to_string( template_name="workbaskets/taric/transaction_detail.xml", context={ "envelope_id": next(_transaction_counter), "tracked_models": [obj], "transaction_id": next(_transaction_counter), "message_counter": counter_generator(), "counter_generator": counter_generator, }, ) return BytesIO(xml.encode()) def taric_xml_record_codes(xml): """Yields tuples of (record_code, subrecord_code)""" records = xml.xpath(".//*[local-name() = 'record']") codes = etree.XPath( ".//*[local-name()='record.code' or local-name()='subrecord.code']/text()", ) return [tuple(codes(record)) for record in records] def validate_taric_xml( factory=None, instance=None, factory_kwargs=None, check_order=True, ): def decorator(func): def wraps( api_client, taric_schema, approved_transaction, valid_user, *args, **kwargs, ): if not factory and not instance: raise AssertionError( "Either a factory or an object instance need to be provided", ) if factory and instance: raise AssertionError( "Either a factory or an object instance need to be provided - not both.", ) current_instance = instance or factory.create( transaction=approved_transaction, **factory_kwargs or {} ) api_client.force_login(user=valid_user) response = api_client.get( reverse( "workbaskets:workbasket-detail", kwargs={"pk": approved_transaction.workbasket.pk}, ), {"format": "xml"}, ) assert response.status_code == 200 content = response.content xml = etree.XML(content) taric_schema.validate(xml) assert not taric_schema.error_log, f"XML errors: {taric_schema.error_log}" if check_order: validate_taric_xml_record_order(xml) kwargs = {"xml": xml, **kwargs} func( *args, **kwargs, ) return wraps return decorator class Dates: deltas = { "normal": (relativedelta(), relativedelta(months=+1)), "earlier": (relativedelta(years=-1), relativedelta(years=-1, months=+1)), "later": ( relativedelta(years=+1, months=+1, days=+1), relativedelta(years=+1, months=+2), ), "big": (relativedelta(years=-2), relativedelta(years=+2, days=+1)), "adjacent": (relativedelta(days=+1), relativedelta(months=+1)), "adjacent_earlier": (relativedelta(months=-1), relativedelta(days=-1)), "adjacent_later": (relativedelta(months=+1, days=+1), relativedelta(months=+2)), "adjacent_no_end": (relativedelta(months=+1, days=+1), None), "adjacent_even_later": ( relativedelta(months=+2, days=+1), relativedelta(months=+3), ), "adjacent_earlier_big": ( relativedelta(years=-2, months=-2), relativedelta(years=-2), ), "adjacent_later_big": ( relativedelta(months=+1, days=+1), relativedelta(years=+2, months=+2), ), "overlap_normal": ( relativedelta(days=+15), relativedelta(days=+14, months=+1, years=+1), ), "overlap_normal_earlier": ( relativedelta(months=-1, days=+14), relativedelta(days=+14), ), "overlap_normal_same_year": ( relativedelta(days=+15), relativedelta(days=+14, months=+1), ), "overlap_big": (relativedelta(years=+1), relativedelta(years=+3, days=+2)), "after_big": ( relativedelta(years=+3, months=+1), relativedelta(years=+3, months=+2), ), "backwards": (relativedelta(months=+1), relativedelta(days=+1)), "starts_with_normal": (relativedelta(), relativedelta(days=+14)), "ends_with_normal": (relativedelta(days=+14), relativedelta(months=+1)), "current": (relativedelta(weeks=-4), relativedelta(weeks=+4)), "future": (relativedelta(weeks=+10), relativedelta(weeks=+20)), "no_end": (relativedelta(), None), "normal_first_half": (relativedelta(), relativedelta(days=+14)), } @property def now(self): return self.datetime_now.date() @property def datetime_now(self): return datetime.now(tz=UTC).replace(hour=0, minute=0, second=0, microsecond=0) def __getattr__(self, name): if name in self.deltas: start, end = self.deltas[name] start = self.now + start if end is not None: end = self.now + end return TaricDateRange(start, end) raise AttributeError(name) @classmethod def short_before(cls, dt): return TaricDateRange( dt + relativedelta(months=-1), dt + relativedelta(days=-14), ) @classmethod def medium_before(cls, dt): return TaricDateRange( dt + relativedelta(months=-1), dt + relativedelta(days=-1), ) @classmethod def short_after(cls, dt): return TaricDateRange( dt + relativedelta(days=+14), dt + relativedelta(months=+1), ) @classmethod def short_overlap(cls, dt): return TaricDateRange( dt + relativedelta(months=-1), dt + relativedelta(months=+1), ) @classmethod def no_end_before(cls, dt): return TaricDateRange( dt + relativedelta(months=-1), None, ) def only_applicable_after(cutoff): """ Decorator which asserts that a test fails after a specified cutoff date. :param cutoff: A date string, or datetime object before which the test should fail. """ cutoff = parse_date(cutoff) def decorator(fn): @wraps(fn) def do_test(*args, **kwargs): # test should pass normally fn(*args, **kwargs) # test should fail before cutoff with freeze_time(cutoff + relativedelta(days=-1)): try: fn(*args, **kwargs) except pytest.fail.Exception: pass except Exception: raise else: pytest.fail(f"Rule applied before {cutoff:%Y-%m-%d}") return True return do_test return decorator def validity_period_post_data(start: date, end: date) -> Dict[str, int]: """ Construct a POST data fragment for the validity period start and end dates of a ValidityPeriodForm from the given date objects, eg: >>> validity_period_post_data( >>> datetime.date(2021, 1, 2), >>> datetime.date(2022, 3, 4), >>> ) { "start_date_0": 1, "start_date_1": 2, "start_date_2": 2021, "end_date_0": 4, "end_date_1": 3, "end_date_2": 2022, } """ return { f"{name}_{i}": part for name, date in (("start_date", start), ("end_date", end)) for i, part in enumerate([date.day, date.month, date.year]) } def get_form_data(form: forms.ModelForm) -> Dict[str, Any]: """Returns a dictionary of the fields that the form will put onto a page and their current values, taking account of any fields that have sub-fields and hence result in multiple HTML <input> objects.""" data = {**form.initial} for field in form.rendered_fields: value = data[field] if field in data else form.fields[field].initial if hasattr(form.fields[field].widget, "decompress"): # If the widget can be decompressed, then it is not just a simple # value and has some internal structure. So we need to generate one # form item per decompressed value and append the name with _0, _1, # etc. This mirrors the MultiValueWidget in django/forms/widgets.py. if field in data: del data[field] value = form.fields[field].widget.decompress(value) data.update( **{f"{field}_{i}": v for i, v in enumerate(value) if v is not None} ) elif value is not None: data.setdefault(field, value) return data

0a2ad964a50ee086e447a623b3863c7fbb9ef26a

py

Python

src/com/python/email/send_mail.py

Leeo1124/pythonDemo

72e2209c095301a3f1f61edfe03ea69c3c05be40

src/com/python/email/send_mail.py

Leeo1124/pythonDemo

72e2209c095301a3f1f61edfe03ea69c3c05be40

src/com/python/email/send_mail.py

Leeo1124/pythonDemo

72e2209c095301a3f1f61edfe03ea69c3c05be40

''' Created on 2016年8月10日 @author: Administrator ''' from email import encoders from email.header import Header from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart from email.mime.multipart import MIMEBase from email.utils import parseaddr, formataddr import smtplib def _format_addr(s): name, addr = parseaddr(s) return formataddr((Header(name, 'utf-8').encode(), addr)) from_addr = '[email protected]'#input('From: ') password = input('Password: ') to_addr = '[email protected]'#input('To: ') smtp_server = 'smtp.163.com'#input('SMTP server: ') # 发送纯文本邮件 # msg = MIMEText('hello, send by Python...', 'plain', 'utf-8') # 发送HTML邮件 # msg = MIMEText('<html><body><h1>Hello</h1>' + # '<p>send by <a href="http://www.python.org">Python</a>...</p>' + # '</body></html>', 'html', 'utf-8') # 发送带附件的邮件 # 邮件对象: msg = MIMEMultipart() msg['From'] = _format_addr('Python爱好者 <%s>' % from_addr) msg['To'] = _format_addr('管理员 <%s>' % to_addr) msg['Subject'] = Header('来自SMTP的问候……', 'utf-8').encode() # 邮件正文是MIMEText: msg.attach(MIMEText('send with file...', 'plain', 'utf-8')) # 添加附件就是加上一个MIMEBase，从本地读取一个图片: with open('D:/pythonWorkspace/pthonDemo/src/com/python/email/test.jpg', 'rb') as f: # 设置附件的MIME和文件名，这里是png类型: mime = MIMEBase('image', 'png', filename='test.png') # 加上必要的头信息: mime.add_header('Content-Disposition', 'attachment', filename='test.png') mime.add_header('Content-ID', '<0>') mime.add_header('X-Attachment-Id', '0') # 把附件的内容读进来: mime.set_payload(f.read()) # 用Base64编码: encoders.encode_base64(mime) # 添加到MIMEMultipart: msg.attach(mime) msg['From'] = _format_addr('Python爱好者 <%s>' % from_addr) msg['To'] = _format_addr('管理员 <%s>' % to_addr) msg['Subject'] = Header('来自SMTP的问候……', 'utf-8').encode() server = smtplib.SMTP(smtp_server, 25) server.set_debuglevel(1) server.login(from_addr, password) server.sendmail(from_addr, [to_addr], msg.as_string()) server.quit()

0a2b055f1a31031a96cc1310b503a9a15b43be19

py

Python

aqui_carattino/blog/migrations/0002_auto_20200424_1452.py

aquilesC/aquicarattino

b6d873aea6e3ec9d1b802ea13952746e4fcc22b6

aqui_carattino/blog/migrations/0002_auto_20200424_1452.py

aquilesC/aquicarattino

b6d873aea6e3ec9d1b802ea13952746e4fcc22b6

2020-05-08T04:30:26.000Z

2021-06-17T20:19:02.000Z

aqui_carattino/blog/migrations/0002_auto_20200424_1452.py

aquilesC/aquicarattino

b6d873aea6e3ec9d1b802ea13952746e4fcc22b6

# Generated by Django 3.0.5 on 2020-04-24 12:52 from django.db import migrations, models import django.db.models.deletion import modelcluster.contrib.taggit import modelcluster.fields import wagtail.core.blocks import wagtail.core.fields import wagtail.images.blocks class Migration(migrations.Migration): dependencies = [ ('wagtailimages', '0001_squashed_0021'), ('wagtailcore', '0045_assign_unlock_grouppagepermission'), ('taggit', '0003_taggeditem_add_unique_index'), ('blog', '0001_initial'), ] operations = [ migrations.CreateModel( name='ArticlePage', fields=[ ('page_ptr', models.OneToOneField(auto_created=True, on_delete=django.db.models.deletion.CASCADE, parent_link=True, primary_key=True, serialize=False, to='wagtailcore.Page')), ('body', wagtail.core.fields.StreamField([('text', wagtail.core.blocks.RichTextBlock(icon='fa fa-paragraph', template='blocks/paragraph_block.html')), ('alert_block', wagtail.core.blocks.StructBlock([('text', wagtail.core.blocks.RichTextBlock(required=True))], required=False)), ('button_block', wagtail.core.blocks.StructBlock([('url', wagtail.core.blocks.URLBlock(required=True)), ('text', wagtail.core.blocks.CharBlock(required=True))], required=False)), ('carousel_block', wagtail.core.blocks.StructBlock([('image_items', wagtail.core.blocks.ListBlock(wagtail.images.blocks.ImageChooserBlock(required=True), label='Image Item'))])), ('testimonial', wagtail.core.blocks.StructBlock([('text', wagtail.core.blocks.TextBlock(required=True)), ('author', wagtail.core.blocks.CharBlock(label='Who said this?', required=True)), ('author_title', wagtail.core.blocks.CharBlock(label='Role of this person', required=False)), ('image', wagtail.images.blocks.ImageChooserBlock(required=False)), ('link', wagtail.core.blocks.URLBlock(label='Link to the person website', required=False))])), ('code_block', wagtail.core.blocks.StructBlock([('language', wagtail.core.blocks.CharBlock(help_text='In which language this is written', max_length=20, required=True)), ('code', wagtail.core.blocks.TextBlock(help_text='The actual code', required=True))]))])), ('header_image', models.ForeignKey(blank=True, help_text='Image to appear at the top of the page, before author information', null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to='wagtailimages.Image')), ], options={ 'abstract': False, }, bases=('wagtailcore.page',), ), migrations.CreateModel( name='Sidebar', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('title', models.CharField(max_length=50)), ('text', models.TextField()), ('cta', models.CharField(blank=True, max_length=15, null=True, verbose_name='Call to action text')), ('image', models.ForeignKey(blank=True, help_text='Image to appear at the top of the page, before author information', null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to='wagtailimages.Image')), ], ), migrations.CreateModel( name='BlogPageTag', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('content_object', modelcluster.fields.ParentalKey(on_delete=django.db.models.deletion.CASCADE, related_name='tagged_items', to='blog.ArticlePage')), ('tag', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='blog_blogpagetag_items', to='taggit.Tag')), ], options={ 'abstract': False, }, ), migrations.AddField( model_name='articlepage', name='tags', field=modelcluster.contrib.taggit.ClusterTaggableManager(blank=True, help_text='A comma-separated list of tags.', through='blog.BlogPageTag', to='taggit.Tag', verbose_name='Tags'), ), ]

0a2b4094e1ca26bb245cb9af7bc67b4f16fdf9b2

py

Python

studies/mixture_feasibility/parsley_benchmark/alcohol_ester/run.py

openforcefield/nistdataselection

d797d597f4ff528a7219d58daa8ef6508d438b24

2020-03-25T02:42:04.000Z

2020-07-20T10:39:35.000Z

studies/mixture_feasibility/parsley_benchmark/alcohol_ester/run.py

openforcefield/nistdataselection

d797d597f4ff528a7219d58daa8ef6508d438b24

2019-09-05T00:20:03.000Z

2020-03-05T23:58:04.000Z

studies/mixture_feasibility/parsley_benchmark/alcohol_ester/run.py

openforcefield/nistdataselection

d797d597f4ff528a7219d58daa8ef6508d438b24

from evaluator import unit from evaluator.backends import QueueWorkerResources from evaluator.backends.dask import DaskLSFBackend from evaluator.client import ConnectionOptions, EvaluatorClient from evaluator.datasets import PhysicalPropertyDataSet from evaluator.forcefield import SmirnoffForceFieldSource from evaluator.server import EvaluatorServer from evaluator.utils import setup_timestamp_logging def main(): setup_timestamp_logging() # Load in the force field force_field_path = "openff-1.0.0.offxml" force_field_source = SmirnoffForceFieldSource.from_path(force_field_path) # Load in the test set. data_set = PhysicalPropertyDataSet.from_json("full_set.json") # Set up a server object to run the calculations using. working_directory = "working_directory" # Set up a backend to run the calculations on. This assume running # on a HPC resources with the LSF queue system installed. queue_resources = QueueWorkerResources( number_of_threads=1, number_of_gpus=1, preferred_gpu_toolkit=QueueWorkerResources.GPUToolkit.CUDA, per_thread_memory_limit=5 * unit.gigabyte, wallclock_time_limit="05:59", ) worker_script_commands = ["conda activate forcebalance", "module load cuda/10.1"] calculation_backend = DaskLSFBackend( minimum_number_of_workers=1, maximum_number_of_workers=50, resources_per_worker=queue_resources, queue_name="gpuqueue", setup_script_commands=worker_script_commands, adaptive_interval="1000ms", ) with calculation_backend: server = EvaluatorServer( calculation_backend=calculation_backend, working_directory=working_directory, port=8004, ) with server: # Request the estimates. client = EvaluatorClient(ConnectionOptions(server_port=8004)) request, _ = client.request_estimate( property_set=data_set, force_field_source=force_field_source, ) # Wait for the results. results, _ = request.results(True, 5) results.json(f"results.json") if __name__ == "__main__": main()

0a2b482bae656ac79eb981d550db6a1224027b57

py

Python

nuplan/planning/simulation/observation/idm/test/test_profile_idm_observation.py

motional/nuplan-devkit

e39029e788b17f47f2fcadb774098ef8fbdd0d67

2021-12-06T15:41:14.000Z

2022-03-29T13:16:32.000Z

nuplan/planning/simulation/observation/idm/test/test_profile_idm_observation.py

motional/nuplan-devkit

e39029e788b17f47f2fcadb774098ef8fbdd0d67

2021-12-11T08:11:31.000Z

2022-03-25T02:35:43.000Z

nuplan/planning/simulation/observation/idm/test/test_profile_idm_observation.py

motional/nuplan-devkit

e39029e788b17f47f2fcadb774098ef8fbdd0d67

2021-12-11T04:12:26.000Z

2022-03-24T06:38:30.000Z

import logging import unittest from pyinstrument import Profiler from nuplan.planning.scenario_builder.nuplan_db.test.nuplan_scenario_test_utils import get_test_nuplan_scenario from nuplan.planning.simulation.history.simulation_history_buffer import SimulationHistoryBuffer from nuplan.planning.simulation.observation.idm_agents import IDMAgents from nuplan.planning.simulation.simulation_time_controller.simulation_iteration import SimulationIteration logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) class TestProfileIDM(unittest.TestCase): """ Profiling test for IDM agents. """ def setUp(self) -> None: """ Inherited, see super class. """ self.n_repeat_trials = 1 self.display_results = True self.scenario = get_test_nuplan_scenario() def test_profile_idm_agent_observation(self) -> None: """Profile IDMAgents.""" profiler = Profiler(interval=0.0001) profiler.start() # How many times to repeat runtime test for _ in range(self.n_repeat_trials): observation = IDMAgents( target_velocity=10, min_gap_to_lead_agent=0.5, headway_time=1.5, accel_max=1.0, decel_max=2.0, scenario=self.scenario, ) for step in range(self.scenario.get_number_of_iterations() - 1): iteration = SimulationIteration(time_point=self.scenario.get_time_point(step), index=step) next_iteration = SimulationIteration(time_point=self.scenario.get_time_point(step + 1), index=step + 1) buffer = SimulationHistoryBuffer.initialize_from_list( 1, [self.scenario.get_ego_state_at_iteration(step)], [self.scenario.get_tracked_objects_at_iteration(step)], next_iteration.time_point.time_s - iteration.time_point.time_s, ) observation.update_observation(iteration, next_iteration, buffer) profiler.stop() if self.display_results: logger.info(profiler.output_text(unicode=True, color=True)) if __name__ == "__main__": unittest.main()

0a2c405aef1ab33457cf8c88423bb2ac392300fb

py

Python

baselines/ddpg/ddpg.py

RDaneelOlivav/baselines

fea6ba932055bb76d68b4b22e812bab738fc18f8

2021-02-23T17:15:21.000Z

2021-09-08T21:31:57.000Z

baselines/ddpg/ddpg.py

RDaneelOlivav/baselines

fea6ba932055bb76d68b4b22e812bab738fc18f8

2021-03-04T05:49:46.000Z

2021-03-04T10:50:59.000Z

baselines/ddpg/ddpg.py

RDaneelOlivav/baselines

fea6ba932055bb76d68b4b22e812bab738fc18f8

2021-01-29T10:40:35.000Z

2021-03-03T08:03:59.000Z

import os import os.path as osp import time from collections import deque import pickle from baselines.ddpg.ddpg_learner import DDPG from baselines.ddpg.models import Actor, Critic from baselines.ddpg.memory import Memory from baselines.ddpg.noise import AdaptiveParamNoiseSpec, NormalActionNoise, OrnsteinUhlenbeckActionNoise from baselines.common import set_global_seeds from baselines import logger import tensorflow as tf import numpy as np try: from mpi4py import MPI except ImportError: MPI = None def learn(network, env, seed=None, total_timesteps=None, nb_epochs=None, # with default settings, perform 1M steps total nb_epoch_cycles=20, nb_rollout_steps=100, reward_scale=1.0, render=False, render_eval=False, noise_type='adaptive-param_0.2', normalize_returns=False, normalize_observations=True, critic_l2_reg=1e-2, actor_lr=1e-4, critic_lr=1e-3, popart=False, gamma=0.99, clip_norm=None, nb_train_steps=50, # per epoch cycle and MPI worker, nb_eval_steps=100, batch_size=64, # per MPI worker tau=0.01, eval_env=None, param_noise_adaption_interval=50, load_path=None, **network_kwargs): set_global_seeds(seed) if total_timesteps is not None: assert nb_epochs is None nb_epochs = int(total_timesteps) // (nb_epoch_cycles * nb_rollout_steps) else: nb_epochs = 500 if MPI is not None: rank = MPI.COMM_WORLD.Get_rank() else: rank = 0 nb_actions = env.action_space.shape[-1] assert (np.abs(env.action_space.low) == env.action_space.high).all() # we assume symmetric actions. memory = Memory(limit=int(1e6), action_shape=env.action_space.shape, observation_shape=env.observation_space.shape) critic = Critic(nb_actions, ob_shape=env.observation_space.shape, network=network, **network_kwargs) actor = Actor(nb_actions, ob_shape=env.observation_space.shape, network=network, **network_kwargs) action_noise = None param_noise = None if noise_type is not None: for current_noise_type in noise_type.split(','): current_noise_type = current_noise_type.strip() if current_noise_type == 'none': pass elif 'adaptive-param' in current_noise_type: _, stddev = current_noise_type.split('_') param_noise = AdaptiveParamNoiseSpec(initial_stddev=float(stddev), desired_action_stddev=float(stddev)) elif 'normal' in current_noise_type: _, stddev = current_noise_type.split('_') action_noise = NormalActionNoise(mu=np.zeros(nb_actions), sigma=float(stddev) * np.ones(nb_actions)) elif 'ou' in current_noise_type: _, stddev = current_noise_type.split('_') action_noise = OrnsteinUhlenbeckActionNoise(mu=np.zeros(nb_actions), sigma=float(stddev) * np.ones(nb_actions)) else: raise RuntimeError('unknown noise type "{}"'.format(current_noise_type)) max_action = env.action_space.high logger.info('scaling actions by {} before executing in env'.format(max_action)) agent = DDPG(actor, critic, memory, env.observation_space.shape, env.action_space.shape, gamma=gamma, tau=tau, normalize_returns=normalize_returns, normalize_observations=normalize_observations, batch_size=batch_size, action_noise=action_noise, param_noise=param_noise, critic_l2_reg=critic_l2_reg, actor_lr=actor_lr, critic_lr=critic_lr, enable_popart=popart, clip_norm=clip_norm, reward_scale=reward_scale) logger.info('Using agent with the following configuration:') logger.info(str(agent.__dict__.items())) if load_path is not None: load_path = osp.expanduser(load_path) ckpt = tf.train.Checkpoint(model=agent) manager = tf.train.CheckpointManager(ckpt, load_path, max_to_keep=None) ckpt.restore(manager.latest_checkpoint) print("Restoring from {}".format(manager.latest_checkpoint)) eval_episode_rewards_history = deque(maxlen=100) episode_rewards_history = deque(maxlen=100) # Prepare everything. agent.initialize() agent.reset() obs = env.reset() if eval_env is not None: eval_obs = eval_env.reset() nenvs = obs.shape[0] episode_reward = np.zeros(nenvs, dtype = np.float32) #vector episode_step = np.zeros(nenvs, dtype = int) # vector episodes = 0 #scalar t = 0 # scalar epoch = 0 start_time = time.time() epoch_episode_rewards = [] epoch_episode_steps = [] epoch_actions = [] epoch_qs = [] epoch_episodes = 0 for epoch in range(nb_epochs): for cycle in range(nb_epoch_cycles): # Perform rollouts. if nenvs > 1: # if simulating multiple envs in parallel, impossible to reset agent at the end of the episode in each # of the environments, so resetting here instead agent.reset() for t_rollout in range(nb_rollout_steps): # Predict next action. action, q, _, _ = agent.step(tf.constant(obs), apply_noise=True, compute_Q=True) action, q = action.numpy(), q.numpy() # Execute next action. if rank == 0 and render: env.render() # max_action is of dimension A, whereas action is dimension (nenvs, A) - the multiplication gets broadcasted to the batch new_obs, r, done, info = env.step(max_action * action) # scale for execution in env (as far as DDPG is concerned, every action is in [-1, 1]) # note these outputs are batched from vecenv t += 1 if rank == 0 and render: env.render() episode_reward += r episode_step += 1 # Book-keeping. epoch_actions.append(action) epoch_qs.append(q) agent.store_transition(obs, action, r, new_obs, done) #the batched data will be unrolled in memory.py's append. obs = new_obs for d in range(len(done)): if done[d]: # Episode done. epoch_episode_rewards.append(episode_reward[d]) episode_rewards_history.append(episode_reward[d]) epoch_episode_steps.append(episode_step[d]) episode_reward[d] = 0. episode_step[d] = 0 epoch_episodes += 1 episodes += 1 if nenvs == 1: agent.reset() # Train. epoch_actor_losses = [] epoch_critic_losses = [] epoch_adaptive_distances = [] for t_train in range(nb_train_steps): # Adapt param noise, if necessary. if memory.nb_entries >= batch_size and t_train % param_noise_adaption_interval == 0: batch = agent.memory.sample(batch_size=batch_size) obs0 = tf.constant(batch['obs0']) distance = agent.adapt_param_noise(obs0) epoch_adaptive_distances.append(distance) cl, al = agent.train() epoch_critic_losses.append(cl) epoch_actor_losses.append(al) agent.update_target_net() # Evaluate. eval_episode_rewards = [] eval_qs = [] if eval_env is not None: nenvs_eval = eval_obs.shape[0] eval_episode_reward = np.zeros(nenvs_eval, dtype = np.float32) for t_rollout in range(nb_eval_steps): eval_action, eval_q, _, _ = agent.step(eval_obs, apply_noise=False, compute_Q=True) eval_obs, eval_r, eval_done, eval_info = eval_env.step(max_action * eval_action) # scale for execution in env (as far as DDPG is concerned, every action is in [-1, 1]) if render_eval: eval_env.render() eval_episode_reward += eval_r eval_qs.append(eval_q) for d in range(len(eval_done)): if eval_done[d]: eval_episode_rewards.append(eval_episode_reward[d]) eval_episode_rewards_history.append(eval_episode_reward[d]) eval_episode_reward[d] = 0.0 if MPI is not None: mpi_size = MPI.COMM_WORLD.Get_size() else: mpi_size = 1 # Log stats. # XXX shouldn't call np.mean on variable length lists duration = time.time() - start_time stats = agent.get_stats() combined_stats = stats.copy() combined_stats['rollout/return'] = np.mean(epoch_episode_rewards) combined_stats['rollout/return_std'] = np.std(epoch_episode_rewards) combined_stats['rollout/return_history'] = np.mean(episode_rewards_history) combined_stats['rollout/return_history_std'] = np.std(episode_rewards_history) combined_stats['rollout/episode_steps'] = np.mean(epoch_episode_steps) combined_stats['rollout/actions_mean'] = np.mean(epoch_actions) combined_stats['rollout/Q_mean'] = np.mean(epoch_qs) combined_stats['train/loss_actor'] = np.mean(epoch_actor_losses) combined_stats['train/loss_critic'] = np.mean(epoch_critic_losses) combined_stats['train/param_noise_distance'] = np.mean(epoch_adaptive_distances) combined_stats['total/duration'] = duration combined_stats['total/steps_per_second'] = float(t) / float(duration) combined_stats['total/episodes'] = episodes combined_stats['rollout/episodes'] = epoch_episodes combined_stats['rollout/actions_std'] = np.std(epoch_actions) # Evaluation statistics. if eval_env is not None: combined_stats['eval/return'] = eval_episode_rewards combined_stats['eval/return_history'] = np.mean(eval_episode_rewards_history) combined_stats['eval/Q'] = eval_qs combined_stats['eval/episodes'] = len(eval_episode_rewards) def as_scalar(x): if isinstance(x, np.ndarray): assert x.size == 1 return x[0] elif np.isscalar(x): return x else: raise ValueError('expected scalar, got %s'%x) combined_stats_sums = np.array([ np.array(x).flatten()[0] for x in combined_stats.values()]) if MPI is not None: combined_stats_sums = MPI.COMM_WORLD.allreduce(combined_stats_sums) combined_stats = {k : v / mpi_size for (k,v) in zip(combined_stats.keys(), combined_stats_sums)} # Total statistics. combined_stats['total/epochs'] = epoch + 1 combined_stats['total/steps'] = t for key in sorted(combined_stats.keys()): logger.record_tabular(key, combined_stats[key]) if rank == 0: logger.dump_tabular() logger.info('') logdir = logger.get_dir() if rank == 0 and logdir: if hasattr(env, 'get_state'): with open(os.path.join(logdir, 'env_state.pkl'), 'wb') as f: pickle.dump(env.get_state(), f) if eval_env and hasattr(eval_env, 'get_state'): with open(os.path.join(logdir, 'eval_env_state.pkl'), 'wb') as f: pickle.dump(eval_env.get_state(), f) return agent

0a2e0012f198d1fec400f883216fa2149bcfd26b

py

Python

footprints/transaction_details.py

enwawerueli/footprints

d9b2a0064b21495edfd0563cb521b0675ee4363d

2018-10-11T19:23:08.000Z

2018-10-11T19:23:08.000Z

footprints/transaction_details.py

enwawerueli/footprints

d9b2a0064b21495edfd0563cb521b0675ee4363d

footprints/transaction_details.py

enwawerueli/footprints

d9b2a0064b21495edfd0563cb521b0675ee4363d

import os from datetime import datetime from PySide2.QtGui import * from PySide2.QtCore import * from PySide2.QtWidgets import * from PySide2.QtPrintSupport import QPrinter, QPrintDialog from jinja2 import TemplateNotFound from .ui.ui_transaction_details import Ui_TransactionDetails from .ui import images_rc from . import jinja_env from .exceptions import PrinterError class TransactionDetails(QDialog, Ui_TransactionDetails): def __init__(self, transaction, parent=None, *args, **kwargs): QDialog.__init__(self, parent, *args, **kwargs) self._transaction = transaction self.setupUi(self) self.setWindowTitle(QApplication.applicationName()) self.print_pb.setIcon(QIcon.fromTheme('document-print-symbolic', QIcon(':/icons/print'))) try: trans = jinja_env.get_template('trans.jinja2.html') except TemplateNotFound: pass else: html = trans.render(transaction=self._transaction, standalone=True) self.statement_tb.setHtml(html) self.print_pb.clicked.connect(self.print_statement) def print_statement(self): printer = QPrinter() printer.setOutputFileName(os.path.join( os.environ.get('HOME'), '%s_%s.pdf' % (self._transaction.created_at.strftime('%Y%m%d'), self._transaction.transaction_code))) if QPrintDialog(printer, self.parentWidget()).exec_() != QDialog.Accepted: return None try: trans = jinja_env.get_template('trans.jinja2.html') except TemplateNotFound as e: raise PrinterError('Printer data source unavailable') from e html = trans.render(transaction=self._transaction, printed_at=datetime.now().strftime('%d/%m/%Y, %I:%M:%S %p')) doc = QTextDocument(self) doc.setHtml(html) doc.print_(printer) return None

0a2e68851d4d316362a1de570d5c1e2e08a4775e

py

Python

yt/units/yt_array.py

FeiLi5/git-github.com-yt-project-yt

0c6cf75351b91e4da80f6a0207ebbcb73dd72a59

yt/units/yt_array.py

FeiLi5/git-github.com-yt-project-yt

0c6cf75351b91e4da80f6a0207ebbcb73dd72a59

yt/units/yt_array.py

FeiLi5/git-github.com-yt-project-yt

0c6cf75351b91e4da80f6a0207ebbcb73dd72a59

""" YTArray class. """ from __future__ import print_function #----------------------------------------------------------------------------- # Copyright (c) 2013, yt Development Team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file COPYING.txt, distributed with this software. #----------------------------------------------------------------------------- import copy import numpy as np from distutils.version import LooseVersion from functools import wraps from numpy import \ add, subtract, multiply, divide, logaddexp, logaddexp2, true_divide, \ floor_divide, negative, power, remainder, mod, absolute, rint, \ sign, conj, exp, exp2, log, log2, log10, expm1, log1p, sqrt, square, \ reciprocal, sin, cos, tan, arcsin, arccos, arctan, arctan2, \ hypot, sinh, cosh, tanh, arcsinh, arccosh, arctanh, deg2rad, rad2deg, \ bitwise_and, bitwise_or, bitwise_xor, invert, left_shift, right_shift, \ greater, greater_equal, less, less_equal, not_equal, equal, logical_and, \ logical_or, logical_xor, logical_not, maximum, minimum, fmax, fmin, \ isreal, iscomplex, isfinite, isinf, isnan, signbit, copysign, nextafter, \ modf, ldexp, frexp, fmod, floor, ceil, trunc, fabs, spacing try: # numpy 1.13 or newer from numpy import positive, divmod as divmod_, isnat, heaviside except ImportError: positive, divmod_, isnat, heaviside = (None,)*4 from yt.units.unit_object import Unit, UnitParseError from yt.units.unit_registry import UnitRegistry from yt.units.dimensions import \ angle, \ current_mks, \ dimensionless, \ em_dimensions from yt.utilities.exceptions import \ YTUnitOperationError, YTUnitConversionError, \ YTUfuncUnitError, YTIterableUnitCoercionError, \ YTInvalidUnitEquivalence, YTEquivalentDimsError from yt.utilities.lru_cache import lru_cache from numbers import Number as numeric_type from yt.utilities.on_demand_imports import _astropy from sympy import Rational from yt.units.unit_lookup_table import \ default_unit_symbol_lut from yt.units.equivalencies import equivalence_registry from yt.utilities.logger import ytLogger as mylog from .pint_conversions import convert_pint_units NULL_UNIT = Unit() POWER_SIGN_MAPPING = {multiply: 1, divide: -1} # redefine this here to avoid a circular import from yt.funcs def iterable(obj): try: len(obj) except: return False return True def return_arr(func): @wraps(func) def wrapped(*args, **kwargs): ret, units = func(*args, **kwargs) if ret.shape == (): return YTQuantity(ret, units) else: # This could be a subclass, so don't call YTArray directly. return type(args[0])(ret, units) return wrapped @lru_cache(maxsize=128, typed=False) def sqrt_unit(unit): return unit**0.5 @lru_cache(maxsize=128, typed=False) def multiply_units(unit1, unit2): return unit1 * unit2 def preserve_units(unit1, unit2=None): return unit1 @lru_cache(maxsize=128, typed=False) def power_unit(unit, power): return unit**power @lru_cache(maxsize=128, typed=False) def square_unit(unit): return unit*unit @lru_cache(maxsize=128, typed=False) def divide_units(unit1, unit2): return unit1/unit2 @lru_cache(maxsize=128, typed=False) def reciprocal_unit(unit): return unit**-1 def passthrough_unit(unit, unit2=None): return unit def return_without_unit(unit, unit2=None): return None def arctan2_unit(unit1, unit2): return NULL_UNIT def comparison_unit(unit1, unit2=None): return None def invert_units(unit): raise TypeError( "Bit-twiddling operators are not defined for YTArray instances") def bitop_units(unit1, unit2): raise TypeError( "Bit-twiddling operators are not defined for YTArray instances") def get_inp_u_unary(ufunc, inputs, out_arr=None): inp = inputs[0] u = getattr(inp, 'units', None) if u is None: u = NULL_UNIT if u.dimensions is angle and ufunc in trigonometric_operators: inp = inp.in_units('radian').v if out_arr is not None: out_arr = ufunc(inp).view(np.ndarray) return out_arr, inp, u def get_inp_u_binary(ufunc, inputs): inp1 = coerce_iterable_units(inputs[0]) inp2 = coerce_iterable_units(inputs[1]) unit1 = getattr(inp1, 'units', None) unit2 = getattr(inp2, 'units', None) ret_class = get_binary_op_return_class(type(inp1), type(inp2)) if unit1 is None: unit1 = Unit(registry=getattr(unit2, 'registry', None)) if unit2 is None and ufunc is not power: unit2 = Unit(registry=getattr(unit1, 'registry', None)) elif ufunc is power: unit2 = inp2 if isinstance(unit2, np.ndarray): if isinstance(unit2, YTArray): if unit2.units.is_dimensionless: pass else: raise YTUnitOperationError(ufunc, unit1, unit2) unit2 = 1.0 return (inp1, inp2), (unit1, unit2), ret_class def handle_preserve_units(inps, units, ufunc, ret_class): if units[0] != units[1]: any_nonzero = [np.any(inps[0]), np.any(inps[1])] if any_nonzero[0] == np.bool_(False): units = (units[1], units[1]) elif any_nonzero[1] == np.bool_(False): units = (units[0], units[0]) else: if not units[0].same_dimensions_as(units[1]): raise YTUnitOperationError(ufunc, *units) inps = (inps[0], ret_class(inps[1]).to( ret_class(inps[0]).units)) return inps, units def handle_comparison_units(inps, units, ufunc, ret_class, raise_error=False): if units[0] != units[1]: u1d = units[0].is_dimensionless u2d = units[1].is_dimensionless any_nonzero = [np.any(inps[0]), np.any(inps[1])] if any_nonzero[0] == np.bool_(False): units = (units[1], units[1]) elif any_nonzero[1] == np.bool_(False): units = (units[0], units[0]) elif not any([u1d, u2d]): if not units[0].same_dimensions_as(units[1]): raise YTUnitOperationError(ufunc, *units) else: if raise_error: raise YTUfuncUnitError(ufunc, *units) inps = (inps[0], ret_class(inps[1]).to( ret_class(inps[0]).units)) return inps, units def handle_multiply_divide_units(unit, units, out, out_arr): if unit.is_dimensionless and unit.base_value != 1.0: if not units[0].is_dimensionless: if units[0].dimensions == units[1].dimensions: out_arr = np.multiply(out_arr.view(np.ndarray), unit.base_value, out=out) unit = Unit(registry=unit.registry) return out, out_arr, unit def coerce_iterable_units(input_object): if isinstance(input_object, np.ndarray): return input_object if iterable(input_object): if any([isinstance(o, YTArray) for o in input_object]): ff = getattr(input_object[0], 'units', NULL_UNIT, ) if any([ff != getattr(_, 'units', NULL_UNIT) for _ in input_object]): raise YTIterableUnitCoercionError(input_object) # This will create a copy of the data in the iterable. return YTArray(input_object) return input_object else: return input_object def sanitize_units_mul(this_object, other_object): inp = coerce_iterable_units(this_object) ret = coerce_iterable_units(other_object) # If the other object is a YTArray and has the same dimensions as the object # under consideration, convert so we don't mix units with the same # dimensions. if isinstance(ret, YTArray): if inp.units.same_dimensions_as(ret.units): ret.in_units(inp.units) return ret def sanitize_units_add(this_object, other_object, op_string): inp = coerce_iterable_units(this_object) ret = coerce_iterable_units(other_object) # Make sure the other object is a YTArray before we use the `units` # attribute. if isinstance(ret, YTArray): if not inp.units.same_dimensions_as(ret.units): # handle special case of adding or subtracting with zero or # array filled with zero if not np.any(other_object): return ret.view(np.ndarray) elif not np.any(this_object): return ret raise YTUnitOperationError(op_string, inp.units, ret.units) ret = ret.in_units(inp.units) else: # If the other object is not a YTArray, then one of the arrays must be # dimensionless or filled with zeros if not inp.units.is_dimensionless and np.any(ret): raise YTUnitOperationError(op_string, inp.units, dimensionless) return ret def validate_comparison_units(this, other, op_string): # Check that other is a YTArray. if hasattr(other, 'units'): if this.units.expr is other.units.expr: if this.units.base_value == other.units.base_value: return other if not this.units.same_dimensions_as(other.units): raise YTUnitOperationError(op_string, this.units, other.units) return other.in_units(this.units) return other @lru_cache(maxsize=128, typed=False) def _unit_repr_check_same(my_units, other_units): """ Takes a Unit object, or string of known unit symbol, and check that it is compatible with this quantity. Returns Unit object. """ # let Unit() handle units arg if it's not already a Unit obj. if not isinstance(other_units, Unit): other_units = Unit(other_units, registry=my_units.registry) equiv_dims = em_dimensions.get(my_units.dimensions, None) if equiv_dims == other_units.dimensions: if current_mks in equiv_dims.free_symbols: base = "SI" else: base = "CGS" raise YTEquivalentDimsError(my_units, other_units, base) if not my_units.same_dimensions_as(other_units): raise YTUnitConversionError( my_units, my_units.dimensions, other_units, other_units.dimensions) return other_units unary_operators = ( negative, absolute, rint, sign, conj, exp, exp2, log, log2, log10, expm1, log1p, sqrt, square, reciprocal, sin, cos, tan, arcsin, arccos, arctan, sinh, cosh, tanh, arcsinh, arccosh, arctanh, deg2rad, rad2deg, invert, logical_not, isreal, iscomplex, isfinite, isinf, isnan, signbit, floor, ceil, trunc, modf, frexp, fabs, spacing, positive, isnat, ) binary_operators = ( add, subtract, multiply, divide, logaddexp, logaddexp2, true_divide, power, remainder, mod, arctan2, hypot, bitwise_and, bitwise_or, bitwise_xor, left_shift, right_shift, greater, greater_equal, less, less_equal, not_equal, equal, logical_and, logical_or, logical_xor, maximum, minimum, fmax, fmin, copysign, nextafter, ldexp, fmod, divmod_, heaviside ) trigonometric_operators = ( sin, cos, tan, ) class YTArray(np.ndarray): """ An ndarray subclass that attaches a symbolic unit object to the array data. Parameters ---------- input_array : :obj:`!iterable` A tuple, list, or array to attach units to input_units : String unit specification, unit symbol object, or astropy units The units of the array. Powers must be specified using python syntax (cm**3, not cm^3). registry : ~yt.units.unit_registry.UnitRegistry The registry to create units from. If input_units is already associated with a unit registry and this is specified, this will be used instead of the registry associated with the unit object. dtype : data-type The dtype of the array data. Defaults to the dtype of the input data, or, if none is found, uses np.float64 bypass_validation : boolean If True, all input validation is skipped. Using this option may produce corrupted, invalid units or array data, but can lead to significant speedups in the input validation logic adds significant overhead. If set, input_units *must* be a valid unit object. Defaults to False. Examples -------- >>> from yt import YTArray >>> a = YTArray([1, 2, 3], 'cm') >>> b = YTArray([4, 5, 6], 'm') >>> a + b YTArray([ 401., 502., 603.]) cm >>> b + a YTArray([ 4.01, 5.02, 6.03]) m NumPy ufuncs will pass through units where appropriate. >>> import numpy as np >>> a = YTArray(np.arange(8) - 4, 'g/cm**3') >>> np.abs(a) YTArray([4, 3, 2, 1, 0, 1, 2, 3]) g/cm**3 and strip them when it would be annoying to deal with them. >>> np.log10(a) array([ -inf, 0. , 0.30103 , 0.47712125, 0.60205999, 0.69897 , 0.77815125, 0.84509804]) YTArray is tightly integrated with yt datasets: >>> import yt >>> ds = yt.load('IsolatedGalaxy/galaxy0030/galaxy0030') >>> a = ds.arr(np.ones(5), 'code_length') >>> a.in_cgs() YTArray([ 3.08600000e+24, 3.08600000e+24, 3.08600000e+24, 3.08600000e+24, 3.08600000e+24]) cm This is equivalent to: >>> b = YTArray(np.ones(5), 'code_length', registry=ds.unit_registry) >>> np.all(a == b) True """ _ufunc_registry = { add: preserve_units, subtract: preserve_units, multiply: multiply_units, divide: divide_units, logaddexp: return_without_unit, logaddexp2: return_without_unit, true_divide: divide_units, floor_divide: divide_units, negative: passthrough_unit, power: power_unit, remainder: preserve_units, mod: preserve_units, fmod: preserve_units, absolute: passthrough_unit, fabs: passthrough_unit, rint: return_without_unit, sign: return_without_unit, conj: passthrough_unit, exp: return_without_unit, exp2: return_without_unit, log: return_without_unit, log2: return_without_unit, log10: return_without_unit, expm1: return_without_unit, log1p: return_without_unit, sqrt: sqrt_unit, square: square_unit, reciprocal: reciprocal_unit, sin: return_without_unit, cos: return_without_unit, tan: return_without_unit, sinh: return_without_unit, cosh: return_without_unit, tanh: return_without_unit, arcsin: return_without_unit, arccos: return_without_unit, arctan: return_without_unit, arctan2: arctan2_unit, arcsinh: return_without_unit, arccosh: return_without_unit, arctanh: return_without_unit, hypot: preserve_units, deg2rad: return_without_unit, rad2deg: return_without_unit, bitwise_and: bitop_units, bitwise_or: bitop_units, bitwise_xor: bitop_units, invert: invert_units, left_shift: bitop_units, right_shift: bitop_units, greater: comparison_unit, greater_equal: comparison_unit, less: comparison_unit, less_equal: comparison_unit, not_equal: comparison_unit, equal: comparison_unit, logical_and: comparison_unit, logical_or: comparison_unit, logical_xor: comparison_unit, logical_not: return_without_unit, maximum: preserve_units, minimum: preserve_units, fmax: preserve_units, fmin: preserve_units, isreal: return_without_unit, iscomplex: return_without_unit, isfinite: return_without_unit, isinf: return_without_unit, isnan: return_without_unit, signbit: return_without_unit, copysign: passthrough_unit, nextafter: preserve_units, modf: passthrough_unit, ldexp: bitop_units, frexp: return_without_unit, floor: passthrough_unit, ceil: passthrough_unit, trunc: passthrough_unit, spacing: passthrough_unit, positive: passthrough_unit, divmod_: passthrough_unit, isnat: return_without_unit, heaviside: preserve_units, } __array_priority__ = 2.0 def __new__(cls, input_array, input_units=None, registry=None, dtype=None, bypass_validation=False): if dtype is None: dtype = getattr(input_array, 'dtype', np.float64) if bypass_validation is True: obj = np.asarray(input_array, dtype=dtype).view(cls) obj.units = input_units if registry is not None: obj.units.registry = registry return obj if input_array is NotImplemented: return input_array.view(cls) if registry is None and isinstance(input_units, (str, bytes)): if input_units.startswith('code_'): raise UnitParseError( "Code units used without referring to a dataset. \n" "Perhaps you meant to do something like this instead: \n" "ds.arr(%s, \"%s\")" % (input_array, input_units) ) if isinstance(input_array, YTArray): ret = input_array.view(cls) if input_units is None: if registry is None: ret.units = input_array.units else: units = Unit(str(input_array.units), registry=registry) ret.units = units elif isinstance(input_units, Unit): ret.units = input_units else: ret.units = Unit(input_units, registry=registry) return ret elif isinstance(input_array, np.ndarray): pass elif iterable(input_array) and input_array: if isinstance(input_array[0], YTArray): return YTArray(np.array(input_array, dtype=dtype), input_array[0].units, registry=registry) # Input array is an already formed ndarray instance # We first cast to be our class type obj = np.asarray(input_array, dtype=dtype).view(cls) # Check units type if input_units is None: # Nothing provided. Make dimensionless... units = Unit() elif isinstance(input_units, Unit): if registry and registry is not input_units.registry: units = Unit(str(input_units), registry=registry) else: units = input_units else: # units kwarg set, but it's not a Unit object. # don't handle all the cases here, let the Unit class handle if # it's a str. units = Unit(input_units, registry=registry) # Attach the units obj.units = units return obj def __repr__(self): """ """ return super(YTArray, self).__repr__()+' '+self.units.__repr__() def __str__(self): """ """ return str(self.view(np.ndarray)) + ' ' + str(self.units) # # Start unit conversion methods # def convert_to_units(self, units): """ Convert the array and units to the given units. Parameters ---------- units : Unit object or str The units you want to convert to. """ new_units = _unit_repr_check_same(self.units, units) (conversion_factor, offset) = self.units.get_conversion_factor(new_units) self.units = new_units values = self.d values *= conversion_factor if offset: np.subtract(self, offset*self.uq, self) return self def convert_to_base(self, unit_system="cgs"): """ Convert the array and units to the equivalent base units in the specified unit system. Parameters ---------- unit_system : string, optional The unit system to be used in the conversion. If not specified, the default base units of cgs are used. Examples -------- >>> E = YTQuantity(2.5, "erg/s") >>> E.convert_to_base(unit_system="galactic") """ return self.convert_to_units(self.units.get_base_equivalent(unit_system)) def convert_to_cgs(self): """ Convert the array and units to the equivalent cgs units. """ return self.convert_to_units(self.units.get_cgs_equivalent()) def convert_to_mks(self): """ Convert the array and units to the equivalent mks units. """ return self.convert_to_units(self.units.get_mks_equivalent()) def in_units(self, units, equivalence=None, **kwargs): """ Creates a copy of this array with the data in the supplied units, and returns it. Optionally, an equivalence can be specified to convert to an equivalent quantity which is not in the same dimensions. .. note:: All additional keyword arguments are passed to the equivalency, which should be used if that particular equivalency requires them. Parameters ---------- units : Unit object or string The units you want to get a new quantity in. equivalence : string, optional The equivalence you wish to use. To see which equivalencies are supported for this unitful quantity, try the :meth:`list_equivalencies` method. Default: None Returns ------- YTArray """ if equivalence is None: new_units = _unit_repr_check_same(self.units, units) (conversion_factor, offset) = self.units.get_conversion_factor(new_units) new_array = type(self)(self.ndview * conversion_factor, new_units) if offset: np.subtract(new_array, offset*new_array.uq, new_array) return new_array else: return self.to_equivalent(units, equivalence, **kwargs) def to(self, units, equivalence=None, **kwargs): """ An alias for YTArray.in_units(). See the docstrings of that function for details. """ return self.in_units(units, equivalence=equivalence, **kwargs) def to_value(self, units=None, equivalence=None, **kwargs): """ Creates a copy of this array with the data in the supplied units, and returns it without units. Output is therefore a bare NumPy array. Optionally, an equivalence can be specified to convert to an equivalent quantity which is not in the same dimensions. .. note:: All additional keyword arguments are passed to the equivalency, which should be used if that particular equivalency requires them. Parameters ---------- units : Unit object or string, optional The units you want to get the bare quantity in. If not specified, the value will be returned in the current units. equivalence : string, optional The equivalence you wish to use. To see which equivalencies are supported for this unitful quantity, try the :meth:`list_equivalencies` method. Default: None Returns ------- NumPy array """ if units is None: v = self.value else: v = self.in_units(units, equivalence=equivalence, **kwargs).value if isinstance(self, YTQuantity): return float(v) else: return v def in_base(self, unit_system="cgs"): """ Creates a copy of this array with the data in the specified unit system, and returns it in that system's base units. Parameters ---------- unit_system : string, optional The unit system to be used in the conversion. If not specified, the default base units of cgs are used. Examples -------- >>> E = YTQuantity(2.5, "erg/s") >>> E_new = E.in_base(unit_system="galactic") """ return self.in_units(self.units.get_base_equivalent(unit_system)) def in_cgs(self): """ Creates a copy of this array with the data in the equivalent cgs units, and returns it. Returns ------- Quantity object with data converted to cgs units. """ return self.in_units(self.units.get_cgs_equivalent()) def in_mks(self): """ Creates a copy of this array with the data in the equivalent mks units, and returns it. Returns ------- Quantity object with data converted to mks units. """ return self.in_units(self.units.get_mks_equivalent()) def to_equivalent(self, unit, equiv, **kwargs): """ Convert a YTArray or YTQuantity to an equivalent, e.g., something that is related by only a constant factor but not in the same units. Parameters ---------- unit : string The unit that you wish to convert to. equiv : string The equivalence you wish to use. To see which equivalencies are supported for this unitful quantity, try the :meth:`list_equivalencies` method. Examples -------- >>> a = yt.YTArray(1.0e7,"K") >>> a.to_equivalent("keV", "thermal") """ conv_unit = Unit(unit, registry=self.units.registry) if self.units.same_dimensions_as(conv_unit): return self.in_units(conv_unit) this_equiv = equivalence_registry[equiv]() oneway_or_equivalent = ( conv_unit.has_equivalent(equiv) or this_equiv._one_way) if self.has_equivalent(equiv) and oneway_or_equivalent: new_arr = this_equiv.convert( self, conv_unit.dimensions, **kwargs) if isinstance(new_arr, tuple): try: return type(self)(new_arr[0], new_arr[1]).in_units(unit) except YTUnitConversionError: raise YTInvalidUnitEquivalence(equiv, self.units, unit) else: return new_arr.in_units(unit) else: raise YTInvalidUnitEquivalence(equiv, self.units, unit) def list_equivalencies(self): """ Lists the possible equivalencies associated with this YTArray or YTQuantity. """ self.units.list_equivalencies() def has_equivalent(self, equiv): """ Check to see if this YTArray or YTQuantity has an equivalent unit in *equiv*. """ return self.units.has_equivalent(equiv) def ndarray_view(self): """ Returns a view into the array, but as an ndarray rather than ytarray. Returns ------- View of this array's data. """ return self.view(np.ndarray) def to_ndarray(self): """ Creates a copy of this array with the unit information stripped """ return np.array(self) @classmethod def from_astropy(cls, arr, unit_registry=None): """ Convert an AstroPy "Quantity" to a YTArray or YTQuantity. Parameters ---------- arr : AstroPy Quantity The Quantity to convert from. unit_registry : yt UnitRegistry, optional A yt unit registry to use in the conversion. If one is not supplied, the default one will be used. """ # Converting from AstroPy Quantity u = arr.unit ap_units = [] for base, exponent in zip(u.bases, u.powers): unit_str = base.to_string() # we have to do this because AstroPy is silly and defines # hour as "h" if unit_str == "h": unit_str = "hr" ap_units.append("%s**(%s)" % (unit_str, Rational(exponent))) ap_units = "*".join(ap_units) if isinstance(arr.value, np.ndarray): return YTArray(arr.value, ap_units, registry=unit_registry) else: return YTQuantity(arr.value, ap_units, registry=unit_registry) def to_astropy(self, **kwargs): """ Creates a new AstroPy quantity with the same unit information. """ if _astropy.units is None: raise ImportError("You don't have AstroPy installed, so you can't convert to " + "an AstroPy quantity.") return self.value*_astropy.units.Unit(str(self.units), **kwargs) @classmethod def from_pint(cls, arr, unit_registry=None): """ Convert a Pint "Quantity" to a YTArray or YTQuantity. Parameters ---------- arr : Pint Quantity The Quantity to convert from. unit_registry : yt UnitRegistry, optional A yt unit registry to use in the conversion. If one is not supplied, the default one will be used. Examples -------- >>> from pint import UnitRegistry >>> import numpy as np >>> ureg = UnitRegistry() >>> a = np.random.random(10) >>> b = ureg.Quantity(a, "erg/cm**3") >>> c = yt.YTArray.from_pint(b) """ p_units = [] for base, exponent in arr._units.items(): bs = convert_pint_units(base) p_units.append("%s**(%s)" % (bs, Rational(exponent))) p_units = "*".join(p_units) if isinstance(arr.magnitude, np.ndarray): return YTArray(arr.magnitude, p_units, registry=unit_registry) else: return YTQuantity(arr.magnitude, p_units, registry=unit_registry) def to_pint(self, unit_registry=None): """ Convert a YTArray or YTQuantity to a Pint Quantity. Parameters ---------- arr : YTArray or YTQuantity The unitful quantity to convert from. unit_registry : Pint UnitRegistry, optional The Pint UnitRegistry to use in the conversion. If one is not supplied, the default one will be used. NOTE: This is not the same as a yt UnitRegistry object. Examples -------- >>> a = YTQuantity(4.0, "cm**2/s") >>> b = a.to_pint() """ from pint import UnitRegistry if unit_registry is None: unit_registry = UnitRegistry() powers_dict = self.units.expr.as_powers_dict() units = [] for unit, pow in powers_dict.items(): # we have to do this because Pint doesn't recognize # "yr" as "year" if str(unit).endswith("yr") and len(str(unit)) in [2,3]: unit = str(unit).replace("yr","year") units.append("%s**(%s)" % (unit, Rational(pow))) units = "*".join(units) return unit_registry.Quantity(self.value, units) # # End unit conversion methods # def write_hdf5(self, filename, dataset_name=None, info=None, group_name=None): r"""Writes a YTArray to hdf5 file. Parameters ---------- filename: string The filename to create and write a dataset to dataset_name: string The name of the dataset to create in the file. info: dictionary A dictionary of supplementary info to write to append as attributes to the dataset. group_name: string An optional group to write the arrays to. If not specified, the arrays are datasets at the top level by default. Examples -------- >>> a = YTArray([1,2,3], 'cm') >>> myinfo = {'field':'dinosaurs', 'type':'field_data'} >>> a.write_hdf5('test_array_data.h5', dataset_name='dinosaurs', ... info=myinfo) """ from yt.utilities.on_demand_imports import _h5py as h5py from yt.extern.six.moves import cPickle as pickle if info is None: info = {} info['units'] = str(self.units) info['unit_registry'] = np.void(pickle.dumps(self.units.registry.lut)) if dataset_name is None: dataset_name = 'array_data' f = h5py.File(filename) if group_name is not None: if group_name in f: g = f[group_name] else: g = f.create_group(group_name) else: g = f if dataset_name in g.keys(): d = g[dataset_name] # Overwrite without deleting if we can get away with it. if d.shape == self.shape and d.dtype == self.dtype: d[...] = self for k in d.attrs.keys(): del d.attrs[k] else: del f[dataset_name] d = g.create_dataset(dataset_name, data=self) else: d = g.create_dataset(dataset_name, data=self) for k, v in info.items(): d.attrs[k] = v f.close() @classmethod def from_hdf5(cls, filename, dataset_name=None, group_name=None): r"""Attempts read in and convert a dataset in an hdf5 file into a YTArray. Parameters ---------- filename: string The filename to of the hdf5 file. dataset_name: string The name of the dataset to read from. If the dataset has a units attribute, attempt to infer units as well. group_name: string An optional group to read the arrays from. If not specified, the arrays are datasets at the top level by default. """ import h5py from yt.extern.six.moves import cPickle as pickle if dataset_name is None: dataset_name = 'array_data' f = h5py.File(filename) if group_name is not None: g = f[group_name] else: g = f dataset = g[dataset_name] data = dataset[:] units = dataset.attrs.get('units', '') if 'unit_registry' in dataset.attrs.keys(): unit_lut = pickle.loads(dataset.attrs['unit_registry'].tostring()) else: unit_lut = None f.close() registry = UnitRegistry(lut=unit_lut, add_default_symbols=False) return cls(data, units, registry=registry) # # Start convenience methods # @property def value(self): """Get a copy of the array data as a numpy ndarray""" return np.array(self) v = value @property def ndview(self): """Get a view of the array data.""" return self.ndarray_view() d = ndview @property def unit_quantity(self): """Get a YTQuantity with the same unit as this array and a value of 1.0""" return YTQuantity(1.0, self.units) uq = unit_quantity @property def unit_array(self): """Get a YTArray filled with ones with the same unit and shape as this array""" return np.ones_like(self) ua = unit_array def __getitem__(self, item): ret = super(YTArray, self).__getitem__(item) if ret.shape == (): return YTQuantity(ret, self.units, bypass_validation=True) else: if hasattr(self, 'units'): ret.units = self.units return ret # # Start operation methods # if LooseVersion(np.__version__) < LooseVersion('1.13.0'): def __add__(self, right_object): """ Add this ytarray to the object on the right of the `+` operator. Must check for the correct (same dimension) units. """ ro = sanitize_units_add(self, right_object, "addition") return super(YTArray, self).__add__(ro) def __radd__(self, left_object): """ See __add__. """ lo = sanitize_units_add(self, left_object, "addition") return super(YTArray, self).__radd__(lo) def __iadd__(self, other): """ See __add__. """ oth = sanitize_units_add(self, other, "addition") np.add(self, oth, out=self) return self def __sub__(self, right_object): """ Subtract the object on the right of the `-` from this ytarray. Must check for the correct (same dimension) units. """ ro = sanitize_units_add(self, right_object, "subtraction") return super(YTArray, self).__sub__(ro) def __rsub__(self, left_object): """ See __sub__. """ lo = sanitize_units_add(self, left_object, "subtraction") return super(YTArray, self).__rsub__(lo) def __isub__(self, other): """ See __sub__. """ oth = sanitize_units_add(self, other, "subtraction") np.subtract(self, oth, out=self) return self def __neg__(self): """ Negate the data. """ return super(YTArray, self).__neg__() def __mul__(self, right_object): """ Multiply this YTArray by the object on the right of the `*` operator. The unit objects handle being multiplied. """ ro = sanitize_units_mul(self, right_object) return super(YTArray, self).__mul__(ro) def __rmul__(self, left_object): """ See __mul__. """ lo = sanitize_units_mul(self, left_object) return super(YTArray, self).__rmul__(lo) def __imul__(self, other): """ See __mul__. """ oth = sanitize_units_mul(self, other) np.multiply(self, oth, out=self) return self def __div__(self, right_object): """ Divide this YTArray by the object on the right of the `/` operator. """ ro = sanitize_units_mul(self, right_object) return super(YTArray, self).__div__(ro) def __rdiv__(self, left_object): """ See __div__. """ lo = sanitize_units_mul(self, left_object) return super(YTArray, self).__rdiv__(lo) def __idiv__(self, other): """ See __div__. """ oth = sanitize_units_mul(self, other) np.divide(self, oth, out=self) return self def __truediv__(self, right_object): ro = sanitize_units_mul(self, right_object) return super(YTArray, self).__truediv__(ro) def __rtruediv__(self, left_object): """ See __div__. """ lo = sanitize_units_mul(self, left_object) return super(YTArray, self).__rtruediv__(lo) def __itruediv__(self, other): """ See __div__. """ oth = sanitize_units_mul(self, other) np.true_divide(self, oth, out=self) return self def __floordiv__(self, right_object): ro = sanitize_units_mul(self, right_object) return super(YTArray, self).__floordiv__(ro) def __rfloordiv__(self, left_object): """ See __div__. """ lo = sanitize_units_mul(self, left_object) return super(YTArray, self).__rfloordiv__(lo) def __ifloordiv__(self, other): """ See __div__. """ oth = sanitize_units_mul(self, other) np.floor_divide(self, oth, out=self) return self def __or__(self, right_object): return super(YTArray, self).__or__(right_object) def __ror__(self, left_object): return super(YTArray, self).__ror__(left_object) def __ior__(self, other): np.bitwise_or(self, other, out=self) return self def __xor__(self, right_object): return super(YTArray, self).__xor__(right_object) def __rxor__(self, left_object): return super(YTArray, self).__rxor__(left_object) def __ixor__(self, other): np.bitwise_xor(self, other, out=self) return self def __and__(self, right_object): return super(YTArray, self).__and__(right_object) def __rand__(self, left_object): return super(YTArray, self).__rand__(left_object) def __iand__(self, other): np.bitwise_and(self, other, out=self) return self def __pow__(self, power): """ Raise this YTArray to some power. Parameters ---------- power : float or dimensionless YTArray. The pow value. """ if isinstance(power, YTArray): if not power.units.is_dimensionless: raise YTUnitOperationError('power', power.unit) # Work around a sympy issue (I think?) # # If I don't do this, super(YTArray, self).__pow__ returns a YTArray # with a unit attribute set to the sympy expression 1/1 rather than # a dimensionless Unit object. if self.units.is_dimensionless and power == -1: ret = super(YTArray, self).__pow__(power) return type(self)(ret, input_units='') return super(YTArray, self).__pow__(power) def __abs__(self): """ Return a YTArray with the abs of the data. """ return super(YTArray, self).__abs__() # # Start comparison operators. # def __lt__(self, other): """ Test if this is less than the object on the right. """ # converts if possible oth = validate_comparison_units(self, other, 'less_than') return super(YTArray, self).__lt__(oth) def __le__(self, other): """Test if this is less than or equal to the object on the right. """ oth = validate_comparison_units(self, other, 'less_than or equal') return super(YTArray, self).__le__(oth) def __eq__(self, other): """ Test if this is equal to the object on the right. """ # Check that other is a YTArray. if other is None: # self is a YTArray, so it can't be None. return False oth = validate_comparison_units(self, other, 'equal') return super(YTArray, self).__eq__(oth) def __ne__(self, other): """ Test if this is not equal to the object on the right. """ # Check that the other is a YTArray. if other is None: return True oth = validate_comparison_units(self, other, 'not equal') return super(YTArray, self).__ne__(oth) def __ge__(self, other): """ Test if this is greater than or equal to other. """ # Check that the other is a YTArray. oth = validate_comparison_units( self, other, 'greater than or equal') return super(YTArray, self).__ge__(oth) def __gt__(self, other): """ Test if this is greater than the object on the right. """ # Check that the other is a YTArray. oth = validate_comparison_units(self, other, 'greater than') return super(YTArray, self).__gt__(oth) # # End comparison operators # # # Begin reduction operators # @return_arr def prod(self, axis=None, dtype=None, out=None): if axis is not None: units = self.units**self.shape[axis] else: units = self.units**self.size return super(YTArray, self).prod(axis, dtype, out), units @return_arr def mean(self, axis=None, dtype=None, out=None): return super(YTArray, self).mean(axis, dtype, out), self.units @return_arr def sum(self, axis=None, dtype=None, out=None): return super(YTArray, self).sum(axis, dtype, out), self.units @return_arr def std(self, axis=None, dtype=None, out=None, ddof=0): return super(YTArray, self).std(axis, dtype, out, ddof), self.units def __array_wrap__(self, out_arr, context=None): ret = super(YTArray, self).__array_wrap__(out_arr, context) if isinstance(ret, YTQuantity) and ret.shape != (): ret = ret.view(YTArray) if context is None: if ret.shape == (): return ret[()] else: return ret ufunc = context[0] inputs = context[1] if ufunc in unary_operators: out_arr, inp, u = get_inp_u_unary(ufunc, inputs, out_arr) unit = self._ufunc_registry[context[0]](u) ret_class = type(self) elif ufunc in binary_operators: unit_operator = self._ufunc_registry[context[0]] inps, units, ret_class = get_inp_u_binary(ufunc, inputs) if unit_operator in (preserve_units, comparison_unit, arctan2_unit): inps, units = handle_comparison_units( inps, units, ufunc, ret_class, raise_error=True) unit = unit_operator(*units) if unit_operator in (multiply_units, divide_units): out_arr, out_arr, unit = handle_multiply_divide_units( unit, units, out_arr, out_arr) else: raise RuntimeError( "Support for the %s ufunc has not been added " "to YTArray." % str(context[0])) if unit is None: out_arr = np.array(out_arr, copy=False) return out_arr out_arr.units = unit if out_arr.size == 1: return YTQuantity(np.array(out_arr), unit) else: if ret_class is YTQuantity: # This happens if you do ndarray * YTQuantity. Explicitly # casting to YTArray avoids creating a YTQuantity with # size > 1 return YTArray(np.array(out_arr), unit) return ret_class(np.array(out_arr, copy=False), unit) else: # numpy version equal to or newer than 1.13 def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): func = getattr(ufunc, method) if 'out' in kwargs: out_orig = kwargs.pop('out') out = np.asarray(out_orig[0]) else: out = None if len(inputs) == 1: _, inp, u = get_inp_u_unary(ufunc, inputs) out_arr = func(np.asarray(inp), out=out, **kwargs) if ufunc in (multiply, divide) and method == 'reduce': power_sign = POWER_SIGN_MAPPING[ufunc] if 'axis' in kwargs and kwargs['axis'] is not None: unit = u**(power_sign*inp.shape[kwargs['axis']]) else: unit = u**(power_sign*inp.size) else: unit = self._ufunc_registry[ufunc](u) ret_class = type(self) elif len(inputs) == 2: unit_operator = self._ufunc_registry[ufunc] inps, units, ret_class = get_inp_u_binary(ufunc, inputs) if unit_operator in (comparison_unit, arctan2_unit): inps, units = handle_comparison_units( inps, units, ufunc, ret_class) elif unit_operator is preserve_units: inps, units = handle_preserve_units( inps, units, ufunc, ret_class) unit = unit_operator(*units) out_arr = func(np.asarray(inps[0]), np.asarray(inps[1]), out=out, **kwargs) if unit_operator in (multiply_units, divide_units): out, out_arr, unit = handle_multiply_divide_units( unit, units, out, out_arr) else: raise RuntimeError( "Support for the %s ufunc with %i inputs has not been" "added to YTArray." % (str(ufunc), len(inputs))) if unit is None: out_arr = np.array(out_arr, copy=False) elif ufunc in (modf, divmod_): out_arr = tuple((ret_class(o, unit) for o in out_arr)) elif out_arr.size == 1: out_arr = YTQuantity(np.asarray(out_arr), unit) else: if ret_class is YTQuantity: # This happens if you do ndarray * YTQuantity. Explicitly # casting to YTArray avoids creating a YTQuantity with # size > 1 out_arr = YTArray(np.asarray(out_arr), unit) else: out_arr = ret_class(np.asarray(out_arr), unit) if out is not None: out_orig[0].flat[:] = out.flat[:] if isinstance(out_orig[0], YTArray): out_orig[0].units = unit return out_arr def copy(self, order='C'): return type(self)(np.copy(np.asarray(self)), self.units) def __array_finalize__(self, obj): if obj is None and hasattr(self, 'units'): return self.units = getattr(obj, 'units', NULL_UNIT) def __pos__(self): """ Posify the data. """ # this needs to be defined for all numpy versions, see # numpy issue #9081 return type(self)(super(YTArray, self).__pos__(), self.units) @return_arr def dot(self, b, out=None): return super(YTArray, self).dot(b), self.units*b.units def __reduce__(self): """Pickle reduction method See the documentation for the standard library pickle module: http://docs.python.org/2/library/pickle.html Unit metadata is encoded in the zeroth element of third element of the returned tuple, itself a tuple used to restore the state of the ndarray. This is always defined for numpy arrays. """ np_ret = super(YTArray, self).__reduce__() obj_state = np_ret[2] unit_state = (((str(self.units), self.units.registry.lut),) + obj_state[:],) new_ret = np_ret[:2] + unit_state + np_ret[3:] return new_ret def __setstate__(self, state): """Pickle setstate method This is called inside pickle.read() and restores the unit data from the metadata extracted in __reduce__ and then serialized by pickle. """ super(YTArray, self).__setstate__(state[1:]) try: unit, lut = state[0] except TypeError: # this case happens when we try to load an old pickle file # created before we serialized the unit symbol lookup table # into the pickle file unit, lut = str(state[0]), default_unit_symbol_lut.copy() # need to fix up the lut if the pickle was saved prior to PR #1728 # when the pickle format changed if len(lut['m']) == 2: lut.update(default_unit_symbol_lut) for k, v in [(k, v) for k, v in lut.items() if len(v) == 2]: lut[k] = v + (0.0, r'\rm{' + k.replace('_', '\ ') + '}') registry = UnitRegistry(lut=lut, add_default_symbols=False) self.units = Unit(unit, registry=registry) def __deepcopy__(self, memodict=None): """copy.deepcopy implementation This is necessary for stdlib deepcopy of arrays and quantities. """ if memodict is None: memodict = {} ret = super(YTArray, self).__deepcopy__(memodict) return type(self)(ret, copy.deepcopy(self.units)) class YTQuantity(YTArray): """ A scalar associated with a unit. Parameters ---------- input_scalar : an integer or floating point scalar The scalar to attach units to input_units : String unit specification, unit symbol object, or astropy units The units of the quantity. Powers must be specified using python syntax (cm**3, not cm^3). registry : A UnitRegistry object The registry to create units from. If input_units is already associated with a unit registry and this is specified, this will be used instead of the registry associated with the unit object. dtype : data-type The dtype of the array data. Examples -------- >>> from yt import YTQuantity >>> a = YTQuantity(1, 'cm') >>> b = YTQuantity(2, 'm') >>> a + b 201.0 cm >>> b + a 2.01 m NumPy ufuncs will pass through units where appropriate. >>> import numpy as np >>> a = YTQuantity(12, 'g/cm**3') >>> np.abs(a) 12 g/cm**3 and strip them when it would be annoying to deal with them. >>> print(np.log10(a)) 1.07918124605 YTQuantity is tightly integrated with yt datasets: >>> import yt >>> ds = yt.load('IsolatedGalaxy/galaxy0030/galaxy0030') >>> a = ds.quan(5, 'code_length') >>> a.in_cgs() 1.543e+25 cm This is equivalent to: >>> b = YTQuantity(5, 'code_length', registry=ds.unit_registry) >>> np.all(a == b) True """ def __new__(cls, input_scalar, input_units=None, registry=None, dtype=np.float64, bypass_validation=False): if not isinstance(input_scalar, (numeric_type, np.number, np.ndarray)): raise RuntimeError("YTQuantity values must be numeric") ret = YTArray.__new__(cls, input_scalar, input_units, registry, dtype=dtype, bypass_validation=bypass_validation) if ret.size > 1: raise RuntimeError("YTQuantity instances must be scalars") return ret def __repr__(self): return str(self) def validate_numpy_wrapper_units(v, arrs): if not any(isinstance(a, YTArray) for a in arrs): return v if not all(isinstance(a, YTArray) for a in arrs): raise RuntimeError("Not all of your arrays are YTArrays.") a1 = arrs[0] if not all(a.units == a1.units for a in arrs[1:]): raise RuntimeError("Your arrays must have identical units.") v.units = a1.units return v def uconcatenate(arrs, axis=0): """Concatenate a sequence of arrays. This wrapper around numpy.concatenate preserves units. All input arrays must have the same units. See the documentation of numpy.concatenate for full details. Examples -------- >>> A = yt.YTArray([1, 2, 3], 'cm') >>> B = yt.YTArray([2, 3, 4], 'cm') >>> uconcatenate((A, B)) YTArray([ 1., 2., 3., 2., 3., 4.]) cm """ v = np.concatenate(arrs, axis=axis) v = validate_numpy_wrapper_units(v, arrs) return v def ucross(arr1, arr2, registry=None, axisa=-1, axisb=-1, axisc=-1, axis=None): """Applies the cross product to two YT arrays. This wrapper around numpy.cross preserves units. See the documentation of numpy.cross for full details. """ v = np.cross(arr1, arr2, axisa=axisa, axisb=axisb, axisc=axisc, axis=axis) units = arr1.units * arr2.units arr = YTArray(v, units, registry=registry) return arr def uintersect1d(arr1, arr2, assume_unique=False): """Find the sorted unique elements of the two input arrays. A wrapper around numpy.intersect1d that preserves units. All input arrays must have the same units. See the documentation of numpy.intersect1d for full details. Examples -------- >>> A = yt.YTArray([1, 2, 3], 'cm') >>> B = yt.YTArray([2, 3, 4], 'cm') >>> uintersect1d(A, B) YTArray([ 2., 3.]) cm """ v = np.intersect1d(arr1, arr2, assume_unique=assume_unique) v = validate_numpy_wrapper_units(v, [arr1, arr2]) return v def uunion1d(arr1, arr2): """Find the union of two arrays. A wrapper around numpy.intersect1d that preserves units. All input arrays must have the same units. See the documentation of numpy.intersect1d for full details. Examples -------- >>> A = yt.YTArray([1, 2, 3], 'cm') >>> B = yt.YTArray([2, 3, 4], 'cm') >>> uunion1d(A, B) YTArray([ 1., 2., 3., 4.]) cm """ v = np.union1d(arr1, arr2) v = validate_numpy_wrapper_units(v, [arr1, arr2]) return v def unorm(data, ord=None, axis=None, keepdims=False): """Matrix or vector norm that preserves units This is a wrapper around np.linalg.norm that preserves units. See the documentation for that function for descriptions of the keyword arguments. The keepdims argument is ignored if the version of numpy installed is older than numpy 1.10.0. """ if LooseVersion(np.__version__) < LooseVersion('1.10.0'): norm = np.linalg.norm(data, ord=ord, axis=axis) else: norm = np.linalg.norm(data, ord=ord, axis=axis, keepdims=keepdims) if norm.shape == (): return YTQuantity(norm, data.units) return YTArray(norm, data.units) def udot(op1, op2): """Matrix or vector dot product that preserves units This is a wrapper around np.dot that preserves units. """ dot = np.dot(op1.d, op2.d) units = op1.units*op2.units if dot.shape == (): return YTQuantity(dot, units) return YTArray(dot, units) def uvstack(arrs): """Stack arrays in sequence vertically (row wise) while preserving units This is a wrapper around np.vstack that preserves units. """ v = np.vstack(arrs) v = validate_numpy_wrapper_units(v, arrs) return v def uhstack(arrs): """Stack arrays in sequence horizontally (column wise) while preserving units This is a wrapper around np.hstack that preserves units. """ v = np.hstack(arrs) v = validate_numpy_wrapper_units(v, arrs) return v def ustack(arrs, axis=0): """Join a sequence of arrays along a new axis while preserving units The axis parameter specifies the index of the new axis in the dimensions of the result. For example, if ``axis=0`` it will be the first dimension and if ``axis=-1`` it will be the last dimension. This is a wrapper around np.stack that preserves units. """ v = np.stack(arrs) v = validate_numpy_wrapper_units(v, arrs) return v def array_like_field(data, x, field): field = data._determine_fields(field)[0] if isinstance(field, tuple): finfo = data.ds._get_field_info(field[0],field[1]) else: finfo = data.ds._get_field_info(field) if finfo.sampling_type == 'particle': units = finfo.output_units else: units = finfo.units if isinstance(x, YTArray): arr = copy.deepcopy(x) arr.convert_to_units(units) return arr if isinstance(x, np.ndarray): return data.ds.arr(x, units) else: return data.ds.quan(x, units) def get_binary_op_return_class(cls1, cls2): if cls1 is cls2: return cls1 if cls1 in (np.ndarray, np.matrix, np.ma.masked_array) or issubclass(cls1, (numeric_type, np.number, list, tuple)): return cls2 if cls2 in (np.ndarray, np.matrix, np.ma.masked_array) or issubclass(cls2, (numeric_type, np.number, list, tuple)): return cls1 if issubclass(cls1, YTQuantity): return cls2 if issubclass(cls2, YTQuantity): return cls1 if issubclass(cls1, cls2): return cls1 if issubclass(cls2, cls1): return cls2 else: raise RuntimeError("Undefined operation for a YTArray subclass. " "Received operand types (%s) and (%s)" % (cls1, cls2)) def loadtxt(fname, dtype='float', delimiter='\t', usecols=None, comments='#'): r""" Load YTArrays with unit information from a text file. Each row in the text file must have the same number of values. Parameters ---------- fname : str Filename to read. dtype : data-type, optional Data-type of the resulting array; default: float. delimiter : str, optional The string used to separate values. By default, this is any whitespace. usecols : sequence, optional Which columns to read, with 0 being the first. For example, ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. The default, None, results in all columns being read. comments : str, optional The character used to indicate the start of a comment; default: '#'. Examples -------- >>> temp, velx = yt.loadtxt("sphere.dat", usecols=(1,2), delimiter="\t") """ f = open(fname, 'r') next_one = False units = [] num_cols = -1 for line in f.readlines(): words = line.strip().split() if len(words) == 0: continue if line[0] == comments: if next_one: units = words[1:] if len(words) == 2 and words[1] == "Units": next_one = True else: # Here we catch the first line of numbers try: col_words = line.strip().split(delimiter) for word in col_words: float(word) num_cols = len(col_words) break except ValueError: mylog.warning("Unrecognized character at beginning of line: \"%s\"." % line[0]) f.close() if len(units) != num_cols: mylog.warning("Malformed or incomplete units header. Arrays will be " "dimensionless!") units = ["dimensionless"]*num_cols arrays = np.loadtxt(fname, dtype=dtype, comments=comments, delimiter=delimiter, converters=None, unpack=True, usecols=usecols, ndmin=0) if usecols is not None: units = [units[col] for col in usecols] mylog.info("Array units: %s" % ", ".join(units)) return tuple([YTArray(arr, unit) for arr, unit in zip(arrays, units)]) def savetxt(fname, arrays, fmt='%.18e', delimiter='\t', header='', footer='', comments='#'): r""" Write YTArrays with unit information to a text file. Parameters ---------- fname : str The file to write the YTArrays to. arrays : list of YTArrays or single YTArray The array(s) to write to the file. fmt : str or sequence of strs, optional A single format (%10.5f), or a sequence of formats. delimiter : str, optional String or character separating columns. header : str, optional String that will be written at the beginning of the file, before the unit header. footer : str, optional String that will be written at the end of the file. comments : str, optional String that will be prepended to the ``header`` and ``footer`` strings, to mark them as comments. Default: '# ', as expected by e.g. ``yt.loadtxt``. Examples -------- >>> sp = ds.sphere("c", (100,"kpc")) >>> a = sp["density"] >>> b = sp["temperature"] >>> c = sp["velocity_x"] >>> yt.savetxt("sphere.dat", [a,b,c], header='My sphere stuff', delimiter="\t") """ if not isinstance(arrays, list): arrays = [arrays] units = [] for array in arrays: if hasattr(array, "units"): units.append(str(array.units)) else: units.append("dimensionless") if header != '': header += '\n' header += " Units\n " + '\t'.join(units) np.savetxt(fname, np.transpose(arrays), header=header, fmt=fmt, delimiter=delimiter, footer=footer, newline='\n', comments=comments)

0a306266dca5739cfacd9015b52dba19c79b8c41

py

Python

src/posts/api/serializers.py

MahmoudMagdi20/django_rest_blog_api

e1969c75e20b4d807baf26051924a0b99a23b4dc

src/posts/api/serializers.py

MahmoudMagdi20/django_rest_blog_api

e1969c75e20b4d807baf26051924a0b99a23b4dc

src/posts/api/serializers.py

MahmoudMagdi20/django_rest_blog_api

e1969c75e20b4d807baf26051924a0b99a23b4dc

from rest_framework import serializers from posts.models import Post class PostCreateUpdateSerializer(serializers.ModelSerializer): class Meta: model = Post fields = [ #'id', 'title', #'slug', 'content', 'publish', ] post_detail_url = serializers.HyperlinkedIdentityField( view_name='posts-api:detail', lookup_field='slug', ) class PostDetailSerializer(serializers.ModelSerializer): url = post_detail_url user = serializers.SerializerMethodField() image = serializers.SerializerMethodField() html = serializers.SerializerMethodField() class Meta: model = Post fields = [ 'url', 'id', 'title', 'slug', 'content', 'publish', 'user', 'image', 'html', ] def get_html(self, obj): return obj.get_markdown() def get_user(self, obj): return str(obj.user.username) def get_image(self, obj): try: image = obj.image.url except: image = None return image class PostListSerializer(serializers.ModelSerializer): url = post_detail_url user = serializers.SerializerMethodField() class Meta: model = Post fields = [ 'url', 'user', 'title', 'content', 'publish', ] def get_user(self, obj): return str(obj.user.username)

0a31cb53c607d4ae46c2c3f0ae523a2030f68afc

py

Python

Protheus_WebApp/Modules/SIGAGTP/GTPA036ETestCase.py

98llm/tir-script-samples

0bff8393b79356aa562e9e6512c11ee6e039b177

2018-09-24T17:27:08.000Z

2021-09-16T19:09:46.000Z

Protheus_WebApp/Modules/SIGAGTP/GTPA036ETestCase.py

98llm/tir-script-samples

0bff8393b79356aa562e9e6512c11ee6e039b177

2018-09-24T17:30:32.000Z

2022-01-03T11:39:30.000Z

Protheus_WebApp/Modules/SIGAGTP/GTPA036ETestCase.py

98llm/tir-script-samples

0bff8393b79356aa562e9e6512c11ee6e039b177

2019-06-07T17:41:34.000Z

2022-01-31T18:17:31.000Z

from tir import Webapp import unittest class GTPA036E(unittest.TestCase): @classmethod def setUpClass(inst): inst.oHelper = Webapp() inst.oHelper.Setup("SIGAGTP", "05/08/2020", "T1", "D MG 01 ") inst.oHelper.Program('GTPA036') def test_GTPA036E_CT001(self): self.oHelper.SetButton('Avançar') self.oHelper.ClickLabel("Arquivo não formatado") self.oHelper.SetButton('Avançar') self.oHelper.SetValue('XXX_DATADE', '02/08/2020') self.oHelper.SetValue('XXX_DATATE', '07/08/2020') self.oHelper.ScrollGrid(column='Agência', match_value='000048', grid_number=1) '''self.oHelper.ClickGridCell("", row=2, grid_number=1)''' self.oHelper.ClickBox("", contents_list='', select_all=False, grid_number=1) self.oHelper.SetButton('Concluir') self.oHelper.SetButton('Fechar') self.oHelper.AssertTrue() @classmethod def tearDownClass(inst): inst.oHelper.TearDown() if __name__ == '__main__': unittest.main()

0a31df6f647d431831f887f61ef014c34b1a74e5

py

Python

code_tmpl/views.py

lovebirdegg/nnms-server

9fd4563ccca9f29add375d346cdd1c2dd636c512

code_tmpl/views.py

lovebirdegg/nnms-server

9fd4563ccca9f29add375d346cdd1c2dd636c512

code_tmpl/views.py

lovebirdegg/nnms-server

9fd4563ccca9f29add375d346cdd1c2dd636c512

# @Time : {time} # @Author : code_generator from rest_framework.viewsets import ModelViewSet from rest_framework.generics import ListAPIView from rest_framework.filters import SearchFilter, OrderingFilter from rest_framework.response import Response from rest_framework.decorators import api_view,authentication_classes,permission_classes,action from common.custom import CommonPagination, RbacPermission from django_filters.rest_framework import DjangoFilterBackend from django.http import HttpResponse,FileResponse,JsonResponse from rest_framework_jwt.authentication import JSONWebTokenAuthentication from rest_framework.permissions import IsAuthenticated from rest_xops.basic import XopsResponse from rest_xops.code import * from django.db.models import Q from django.apps import apps from ..models import {model_camel_case_name} from django.contrib.contenttypes.models import ContentType from ..serializers.{model_name}_serializers import * class {model_camel_case_name}View(ModelViewSet): queryset = {model_camel_case_name}.objects.all() serializer_class = {model_camel_case_name}Serializer filter_backends = (DjangoFilterBackend, SearchFilter,OrderingFilter) pagination_class = CommonPagination ordering_fields = ('id',) authentication_classes = (JSONWebTokenAuthentication,) permission_classes = (IsAuthenticated,) filter_fields = ({filter_fields}) search_fields = ({search_fields})

0a32bc170cadd36fc1306d343ea0e49f3379160d

py

Python

src/collectors/heartbeat/heartbeat.py

art19/netuitive-diamond

57f61f2444e6f3d3692b4ee989415939bfaa932e

2016-11-17T13:17:50.000Z

2017-03-28T19:42:04.000Z

src/collectors/heartbeat/heartbeat.py

art19/netuitive-diamond

57f61f2444e6f3d3692b4ee989415939bfaa932e

2016-09-30T14:04:52.000Z

2021-04-22T21:22:28.000Z

src/collectors/heartbeat/heartbeat.py

art19/netuitive-diamond

57f61f2444e6f3d3692b4ee989415939bfaa932e

2017-01-24T14:44:56.000Z

2021-03-03T17:14:19.000Z

# coding=utf-8 """ Send a value of 1 as a heartbeat every time this collector is invoked. #### Dependencies None #### Usage Add the collector config as : enabled = True path = netuitive Metrics are collected as : - metrics.heartbeat Netuitive Change History ======================== DVG 2016/11/14 Initial version. """ import diamond.collector from diamond.utils.config import load_config as load_server_config try: import netuitive except ImportError: netuitive = None class HeartbeatCollector(diamond.collector.Collector): def __init__(self, *args, **kwargs): super(HeartbeatCollector, self).__init__(*args, **kwargs) self.hostname = self.get_hostname() self.ttl = self.config['ttl'] self.connection_timeout = 5 if not netuitive: self.log.error('netuitive import failed. Heartbeat collector disabled') self.enabled = False return try: self.version = self._get_version() if 'netuitive_connection_timeout' in self.config: self.connection_timeout = int(self.config['netuitive_connection_timeout']) self.api = netuitive.Client(url=self.config['netuitive_url'], api_key=self.config['netuitive_api_key'], agent=self.version, connection_timeout=self.connection_timeout) except Exception as e: self.log.debug(e) def collect(self): check = netuitive.Check('heartbeat', self.hostname, self.ttl) self.api.post_check(check)

0a33b4fb181d675d2537be4a920a504933aa3c82

py

Python

process_script/stat.py

vitorebatista/AVEMH

1c0bea3ae6c35729b80ba49b9663ce83ea43922d

2020-11-11T14:02:53.000Z

2020-12-10T00:10:50.000Z

process_script/stat.py

vitorebatista/AVEMH

1c0bea3ae6c35729b80ba49b9663ce83ea43922d

process_script/stat.py

vitorebatista/AVEMH

1c0bea3ae6c35729b80ba49b9663ce83ea43922d

import numpy as np import pandas as pd import sys markets = ["hangseng", "dax", "ftse", "sp", "nikkei"] market = markets[int(sys.argv[1])-1] # read GD data file dat = pd.read_csv("./num_res/{}.GD.csv".format(market)) # split into two experiments exp1_GD = dat[dat.columns[:5]] exp2_GD = dat[dat.columns[5:]] # calculate statistics stat1_GD = pd.DataFrame([exp1_GD.min(), exp1_GD.median(), exp1_GD.std()]) stat1_GD.index = ["Best", "Median", "Std."] stat2_GD = pd.DataFrame([exp2_GD.min(), exp2_GD.median(), exp2_GD.std()]) stat2_GD.index = ["Best", "Median", "Std."] # find best and second best algorithm meds1_GD = stat1_GD.loc["Median"].sort_values() best1_GD = list(meds1_GD.index[:2]) meds2_GD = stat2_GD.loc["Median"].sort_values() best2_GD = list(meds2_GD.index[:2]) print("{}.GD:".format(market), best1_GD[0], best1_GD[1]) # print("{}.GD:".format(market), best2_GD[0], best2_GD[1]) # TODO: check error # read Spacing data file dat = pd.read_csv("./num_res/{}.Spacing.csv".format(market)) # split into two experiments exp1_Spacing = dat[dat.columns[:5]] exp2_Spacing = dat[dat.columns[5:]] # calculate statistics stat1_Spacing = pd.DataFrame( [exp1_Spacing.min(), exp1_Spacing.median(), exp1_Spacing.std()]) stat1_Spacing.index = ["Best", "Median", "Std."] stat2_Spacing = pd.DataFrame( [exp2_Spacing.min(), exp2_Spacing.median(), exp2_Spacing.std()]) stat2_Spacing.index = ["Best", "Median", "Std."] # find best and second best algorithm meds1_Spacing = stat1_Spacing.loc["Median"].sort_values() best1_Spacing = list(meds1_Spacing.index[:2]) meds2_Spacing = stat2_Spacing.loc["Median"].sort_values() best2_Spacing = list(meds2_Spacing.index[:2]) print("{}.Spacing:".format(market), best1_Spacing[0], best1_Spacing[1]) # print("{}.Spacing:".format(market), best2_Spacing[0], best2_Spacing[1]) # TODO: check error # read MaxSpread data file dat = pd.read_csv("./num_res/{}.MaxSpread.csv".format(market)) # split into two experiments exp1_MaxSpread = dat[dat.columns[:5]] exp2_MaxSpread = dat[dat.columns[5:]] # calculate statistics stat1_MaxSpread = pd.DataFrame( [exp1_MaxSpread.max(), exp1_MaxSpread.median(), exp1_MaxSpread.std()]) stat1_MaxSpread.index = ["Best", "Median", "Std."] stat2_MaxSpread = pd.DataFrame( [exp2_MaxSpread.max(), exp2_MaxSpread.median(), exp2_MaxSpread.std()]) stat2_MaxSpread.index = ["Best", "Median", "Std."] # find best and second best algorithm meds1_MaxSpread = stat1_MaxSpread.loc["Median"].sort_values(ascending=False) best1_MaxSpread = list(meds1_MaxSpread.index[:2]) meds2_MaxSpread = stat2_MaxSpread.loc["Median"].sort_values(ascending=False) best2_MaxSpread = list(meds2_MaxSpread.index[:2]) print("{}.MaxSpread:".format(market), best1_MaxSpread[0], best1_MaxSpread[1]) # print("{}.MaxSpread:".format(market), best2_MaxSpread[0], best2_MaxSpread[1]) # TODO: check error # read Delta data file dat = pd.read_csv("./num_res/{}.Delta.csv".format(market)) # split into two experiments exp1_Delta = dat[dat.columns[:5]] exp2_Delta = dat[dat.columns[5:]] # calculate statistics stat1_Delta = pd.DataFrame( [exp1_Delta.min(), exp1_Delta.median(), exp1_Delta.std()]) stat1_Delta.index = ["Best", "Median", "Std."] stat2_Delta = pd.DataFrame( [exp2_Delta.min(), exp2_Delta.median(), exp2_Delta.std()]) stat2_Delta.index = ["Best", "Median", "Std."] # find best and second best algorithm meds1_Delta = stat1_Delta.loc["Median"].sort_values() best1_Delta = list(meds1_Delta.index[:2]) meds2_Delta = stat2_Delta.loc["Median"].sort_values() best2_Delta = list(meds2_Delta.index[:2]) print("{}.Delta:".format(market), best1_Delta[0], best1_Delta[1]) # print("{}.Delta:".format(market), best2_Delta[0], best2_Delta[1]) # TODO: check error # read IGD data file dat = pd.read_csv("./num_res/{}.IGD.csv".format(market)) # split into two experiments exp1_IGD = dat[dat.columns[:5]] exp2_IGD = dat[dat.columns[5:]] # calculate statistics stat1_IGD = pd.DataFrame([exp1_IGD.min(), exp1_IGD.median(), exp1_IGD.std()]) stat1_IGD.index = ["Best", "Median", "Std."] stat2_IGD = pd.DataFrame([exp2_IGD.min(), exp2_IGD.median(), exp2_IGD.std()]) stat2_IGD.index = ["Best", "Median", "Std."] # find best and second best algorithm meds1_IGD = stat1_IGD.loc["Median"].sort_values() best1_IGD = list(meds1_IGD.index[:2]) meds2_IGD = stat2_IGD.loc["Median"].sort_values() best2_IGD = list(meds2_IGD.index[:2]) print("{}.IGD:".format(market), best1_IGD[0], best1_IGD[1]) # print("{}.IGD:".format(market), best2_IGD[0], best2_IGD[1]) # TODO: check error # read Hypervolume data file dat = pd.read_csv("./num_res/{}.Hypervolume.csv".format(market)) # split into two experiments exp1_Hypervolume = dat[dat.columns[:5]] exp2_Hypervolume = dat[dat.columns[5:]] # calculate statistics stat1_Hypervolume = pd.DataFrame( [exp1_Hypervolume.max(), exp1_Hypervolume.median(), exp1_Hypervolume.std()]) stat1_Hypervolume.index = ["Best", "Median", "Std."] stat2_Hypervolume = pd.DataFrame( [exp2_Hypervolume.max(), exp2_Hypervolume.median(), exp2_Hypervolume.std()]) stat2_Hypervolume.index = ["Best", "Median", "Std."] # find best and second best algorithm meds1_Hypervolume = stat1_Hypervolume.loc["Median"].sort_values( ascending=False) best1_Hypervolume = list(meds1_Hypervolume.index[:2]) meds2_Hypervolume = stat2_Hypervolume.loc["Median"].sort_values( ascending=False) best2_Hypervolume = list(meds2_Hypervolume.index[:2]) print("{}.Hypervolume:".format(market), best1_Hypervolume[0], best1_Hypervolume[1]) # print("{}.Hypervolume:".format(market), # best2_Hypervolume[0], best2_Hypervolume[1]) # TODO: check error print("{}\n----------------------------------------------".format(market)) pd.options.display.float_format = '{:.2e}'.format stat1_overall = pd.concat( [stat1_GD, stat1_Spacing, stat1_MaxSpread, stat1_Delta, stat1_IGD, stat1_Hypervolume]) stat2_overall = pd.concat( [stat2_GD, stat2_Spacing, stat2_MaxSpread, stat2_Delta, stat2_IGD, stat2_Hypervolume]) arrays = [["GD", "GD", "GD", "Spacing", "Spacing", "Spacing", "MaxSpread", "MaxSpread", "MaxSpread", "Delta", "Delta", "Delta", "IGD", "IGD", "IGD", "Hypervolume", "Hypervolume", "Hypervolume"], stat1_overall.index ] index = pd.MultiIndex.from_arrays(arrays, names=["Metric", ""]) stat1_overall.index = index stat2_overall.index = index print(stat1_overall) print("----------------------------------------------") print(stat2_overall)

0a33cb634cfe076d601a3145a01487981499f068

py

Python

Scripts/calc_Utilities.py

zmlabe/ThicknessSensitivity

6defdd897a61d7d1a02f34a9f4ec92b2b17b3075

2017-10-22T02:22:14.000Z

2017-10-22T02:22:14.000Z

Scripts/calc_Utilities.py

zmlabe/ThicknessSensitivity

6defdd897a61d7d1a02f34a9f4ec92b2b17b3075

Scripts/calc_Utilities.py

zmlabe/ThicknessSensitivity

6defdd897a61d7d1a02f34a9f4ec92b2b17b3075

2018-04-05T17:55:36.000Z

2022-03-31T07:05:01.000Z

""" Functions are useful untilities for SITperturb experiments Notes ----- Author : Zachary Labe Date : 13 August 2017 Usage ----- [1] calcDecJan(varx,vary,lat,lon,level,levsq) [2] calcDecJanFeb(varx,vary,lat,lon,level,levsq) [3] calc_indttest(varx,vary) [4] calc_weightedAve(var,lats) [5] calc_spatialCorr(varx,vary,lats,lons,weight) [6] calc_RMSE(varx,vary,lats,lons,weight) [7] calc_spatialCorrHeight(varx,vary,lats,lons,weight) [8] calc_spatialCorrHeightLev(varx,vary,lats,lons,weight,levelq) """ def calcDecJan(varx,vary,lat,lon,level,levsq): """ Function calculates average for December-January Parameters ---------- varx : 4d array or 5d array [year,month,lat,lon] or [year,month,lev,lat,lon] vary : 4d array or 5d array [year,month,lat,lon] or [year,month,lev,lat,lon] lat : 1d numpy array latitudes lon : 1d numpy array longitudes level : string Height of variable (surface or profile) levsq : integer number of levels Returns ------- varx_dj : 3d array or 4d array [year,lat,lon] or [year,lev,lat,lon] vary_dj : 3d array [year,lat,lon] or [year,lev,lat,lon] Usage ----- varx_dj,vary_dj = calcDecJan(varx,vary,lat,lon,level,levsq) """ print('\n>>> Using calcDecJan function!') ### Import modules import numpy as np ### Reshape for 3d variables if level == 'surface': varxravel = np.reshape(varx.copy(), (int(varx.shape[0]*12), int(lat.shape[0]),int(lon.shape[0]))) varyravel = np.reshape(vary.copy(), (int(vary.shape[0]*12), int(lat.shape[0]),int(lon.shape[0]))) varx_dj = np.empty((varx.shape[0]-1,lat.shape[0],lon.shape[0])) vary_dj = np.empty((vary.shape[0]-1,lat.shape[0],lon.shape[0]) ) for i in range(0,varxravel.shape[0]-12,12): counter = 0 if i >= 12: counter = i//12 djappendh = np.append(varxravel[11+i,:,:],varxravel[12+i,:,:]) djappendf = np.append(varyravel[11+i,:,:],varyravel[12+i,:,:]) varx_dj[counter,:,:] = np.nanmean(np.reshape(djappendh, (2,int(lat.shape[0]),int(lon.shape[0]))), axis=0) vary_dj[counter,:,:] = np.nanmean(np.reshape(djappendf, (2,int(lat.shape[0]),int(lon.shape[0]))), axis=0) ### Reshape for 4d variables elif level == 'profile': varxravel = np.reshape(varx.copy(), (int(varx.shape[0]*12.),levsq, int(lat.shape[0]),int(lon.shape[0]))) varyravel = np.reshape(vary.copy(), (int(vary.shape[0]*12.),levsq, int(lat.shape[0]),int(lon.shape[0]))) varx_dj = np.empty((int(varx.shape[0]-1),levsq, int(lat.shape[0]),int(lon.shape[0]))) vary_dj = np.empty((int(vary.shape[0]-1),levsq, int(lat.shape[0]),int(lon.shape[0])) ) for i in range(0,varxravel.shape[0]-12,12): counter = 0 if i >= 12: counter = i//12 djappendh = np.append(varxravel[11+i,:,:,:], varxravel[12+i,:,:,:]) djappendf = np.append(varyravel[11+i,:,:,:], varyravel[12+i,:,:,:]) varx_dj[counter,:,:] = np.nanmean(np.reshape(djappendh, (2,levsq,int(lat.shape[0]), int(lon.shape[0]))),axis=0) vary_dj[counter,:,:] = np.nanmean(np.reshape(djappendf, (2,levsq,int(lat.shape[0]), int(lon.shape[0]))),axis=0) else: print(ValueError('Selected wrong height - (surface or profile!)!')) print('Completed: Organized data by months (ON,DJ,FM)!') print('*Completed: Finished calcDecJan function!') return varx_dj,vary_dj ############################################################################### ############################################################################### ############################################################################### def calcDecJanFeb(varx,vary,lat,lon,level,levsq): """ Function calculates average for December-January-February Parameters ---------- varx : 4d array or 5d array [year,month,lat,lon] or [year,month,lev,lat,lon] vary : 4d array or 5d array [year,month,lat,lon] or [year,month,lev,lat,lon] lat : 1d numpy array latitudes lon : 1d numpy array longitudes level : string Height of variable (surface or profile) levsq : integer number of levels Returns ------- varx_djf : 3d array or 4d array [year,lat,lon] or [year,lev,lat,lon] vary_djf : 3d array [year,lat,lon] or [year,lev,lat,lon] Usage ----- varx_djf,vary_djf = calcDecJanFeb(varx,vary,lat,lon,level,levsq) """ print('\n>>> Using calcDecJan function!') ### Import modules import numpy as np ### Reshape for 3d variables if level == 'surface': varxravel = np.reshape(varx.copy(), (int(varx.shape[0]*12), int(lat.shape[0]),int(lon.shape[0]))) varyravel = np.reshape(vary.copy(), (int(vary.shape[0]*12), int(lat.shape[0]),int(lon.shape[0]))) varx_djf = np.empty((varx.shape[0]-1,lat.shape[0],lon.shape[0])) vary_djf = np.empty((vary.shape[0]-1,lat.shape[0],lon.shape[0]) ) for i in range(0,varxravel.shape[0]-12,12): counter = 0 if i >= 12: counter = i//12 djfappendh1 = np.append(varxravel[11+i,:,:],varxravel[12+i,:,:]) djfappendf1 = np.append(varyravel[11+i,:,:],varyravel[12+i,:,:]) djfappendh = np.append(djfappendh1,varxravel[13+i,:,:]) djfappendf = np.append(djfappendf1,varyravel[13+i,:,:]) varx_djf[counter,:,:] = np.nanmean(np.reshape(djfappendh, (3,int(lat.shape[0]),int(lon.shape[0]))), axis=0) vary_djf[counter,:,:] = np.nanmean(np.reshape(djfappendf, (3,int(lat.shape[0]),int(lon.shape[0]))), axis=0) ### Reshape for 4d variables elif level == 'profile': varxravel = np.reshape(varx.copy(), (int(varx.shape[0]*12.),levsq, int(lat.shape[0]),int(lon.shape[0]))) varyravel = np.reshape(vary.copy(), (int(vary.shape[0]*12.),levsq, int(lat.shape[0]),int(lon.shape[0]))) varx_djf = np.empty((int(varx.shape[0]-1),levsq, int(lat.shape[0]),int(lon.shape[0]))) vary_djf = np.empty((int(vary.shape[0]-1),levsq, int(lat.shape[0]),int(lon.shape[0])) ) for i in range(0,varxravel.shape[0]-12,12): counter = 0 if i >= 12: counter = i//12 djfappendh1 = np.append(varxravel[11+i,:,:,:], varxravel[12+i,:,:,:]) djfappendf1 = np.append(varyravel[11+i,:,:,:], varyravel[12+i,:,:,:]) djfappendh = np.append(djfappendh1, varxravel[13+i,:,:,:]) djfappendf = np.append(djfappendf1, varyravel[13+i,:,:,:]) varx_djf[counter,:,:] = np.nanmean(np.reshape(djfappendh, (3,levsq,int(lat.shape[0]), int(lon.shape[0]))),axis=0) vary_djf[counter,:,:] = np.nanmean(np.reshape(djfappendf, (3,levsq,int(lat.shape[0]), int(lon.shape[0]))),axis=0) else: print(ValueError('Selected wrong height - (surface or profile!)!')) print('Completed: Organized data by months (DJF)!') print('*Completed: Finished calcDecJanFeb function!') return varx_djf,vary_djf ############################################################################### ############################################################################### ############################################################################### def calc_indttest(varx,vary): """ Function calculates statistical difference for 2 independent sample t-test Parameters ---------- varx : 3d array vary : 3d array Returns ------- stat = calculated t-statistic pvalue = two-tailed p-value Usage ----- stat,pvalue = calc_ttest(varx,vary) """ print('\n>>> Using calc_ttest function!') ### Import modules import numpy as np import scipy.stats as sts ### 2-independent sample t-test stat,pvalue = sts.ttest_ind(varx,vary,nan_policy='omit') ### Significant at 95% confidence level pvalue[np.where(pvalue >= 0.05)] = np.nan pvalue[np.where(pvalue < 0.05)] = 1. print('*Completed: Finished calc_ttest function!') return stat,pvalue ############################################################################### ############################################################################### ############################################################################### def calc_weightedAve(var,lats): """ Area weights sit array 5d [ens,year,month,lat,lon] into [ens,year,month] Parameters ---------- var : 5d,4d,3d array of a gridded variable lats : 2d array of latitudes Returns ------- meanvar : weighted average for 3d,2d,1d array Usage ----- meanvar = calc_weightedAve(var,lats) """ print('\n>>> Using calc_weightedAve function!') ### Import modules import numpy as np ### Calculate weighted average for various dimensional arrays if var.ndim == 5: meanvar = np.empty((var.shape[0],var.shape[1],var.shape[2])) for ens in range(var.shape[0]): for i in range(var.shape[1]): for j in range(var.shape[2]): varq = var[ens,i,j,:,:] mask = np.isfinite(varq) & np.isfinite(lats) varmask = varq[mask] areamask = np.cos(np.deg2rad(lats[mask])) meanvar[ens,i,j] = np.nansum(varmask*areamask) \ /np.sum(areamask) elif var.ndim == 4: meanvar = np.empty((var.shape[0],var.shape[1])) for i in range(var.shape[0]): for j in range(var.shape[1]): varq = var[i,j,:,:] mask = np.isfinite(varq) & np.isfinite(lats) varmask = varq[mask] areamask = np.cos(np.deg2rad(lats[mask])) meanvar[i,j] = np.nansum(varmask*areamask)/np.sum(areamask) elif var.ndim == 3: meanvar = np.empty((var.shape[0])) for i in range(var.shape[0]): varq = var[i,:,:] mask = np.isfinite(varq) & np.isfinite(lats) varmask = varq[mask] areamask = np.cos(np.deg2rad(lats[mask])) meanvar[i] = np.nansum(varmask*areamask)/np.sum(areamask) elif var.ndim == 2: meanvar = np.empty((var.shape[0])) varq = var[:,:] mask = np.isfinite(varq) & np.isfinite(lats) varmask = varq[mask] areamask = np.cos(np.deg2rad(lats[mask])) meanvar = np.nansum(varmask*areamask)/np.sum(areamask) else: print(ValueError('Variable has the wrong dimensions!')) print('Completed: Weighted variable average!') print('*Completed: Finished calc_weightedAve function!') return meanvar ############################################################################### ############################################################################### ############################################################################### def calc_spatialCorr(varx,vary,lats,lons,weight): """ Calculates spatial correlation from pearson correlation coefficient Parameters ---------- varx : 2d array vary : 2d array lats : 1d array lons : 1d array of latitude weight : string (yes or no) Returns ------- corrcoef : 1d array of correlation coefficient (pearson r) Usage ----- corrcoef = calc_spatialCorr(varx,vary,lats,lons) """ print('\n>>> Using calc_spatialCorr function!') ### Import modules import numpy as np if weight == 'yes': # Computed weighted correlation coefficient ### mask mask = 'yes' if mask == 'yes': latq = np.where(lats > 40)[0] lats = lats[latq] varx = varx[latq,:] vary = vary[latq,:] print('MASKING LATITUDES!') ### Create 2d meshgrid for weights lon2,lat2 = np.meshgrid(lons,lats) ### Create 2d array of weights based on latitude gw = np.cos(np.deg2rad(lat2)) def m(x, w): """Weighted Mean""" wave = np.sum(x * w) / np.sum(w) print('Completed: Computed weighted average!') return wave def cov(x, y, w): """Weighted Covariance""" wcov = np.sum(w * (x - m(x, w)) * (y - m(y, w))) / np.sum(w) print('Completed: Computed weighted covariance!') return wcov def corr(x, y, w): """Weighted Correlation""" wcor = cov(x, y, w) / np.sqrt(cov(x, x, w) * cov(y, y, w)) print('Completed: Computed weighted correlation!') return wcor corrcoef = corr(varx,vary,gw) elif weight == 'no': ### Correlation coefficient from numpy function (not weighted) corrcoef= np.corrcoef(varx.ravel(),vary.ravel())[0][1] print('Completed: Computed NON-weighted correlation!') else: ValueError('Wrong weighted arguement in function!') print('*Completed: Finished calc_SpatialCorr function!') return corrcoef ############################################################################### ############################################################################### ############################################################################### def calc_RMSE(varx,vary,lats,lons,weight): """ Calculates root mean square weighted average Parameters ---------- varx : 2d array vary : 2d array lons : 1d array of latitude weight : string (yes or no) Returns ------- rmse : 1d array Usage ----- rmse = calc_RMSE(varx,vary,lats,lons) """ print('\n>>> Using calc_RMSE function!') ### Import modules import numpy as np from sklearn.metrics import mean_squared_error if weight == 'yes': # Computed weighted correlation coefficient ### mask mask = 'yes' if mask == 'yes': latq = np.where(lats > 40)[0] lats = lats[latq] varx = varx[latq,:] vary = vary[latq,:] print('MASKING LATITUDES!') ### Create 2d meshgrid for weights lon2,lat2 = np.meshgrid(lons,lats) ### Create 2d array of weights based on latitude gw = np.cos(np.deg2rad(lat2)) ### Calculate rmse sq_err = (varx - vary)**2 rmse = np.sqrt((np.sum(sq_err*gw))/np.sum(gw)) elif weight == 'no': ### Root mean square error from sklearn (not weighted) rmse = np.sqrt(mean_squared_error(varx.ravel(),vary.ravel())) print('Completed: Computed NON-weighted correlation!') else: ValueError('Wrong weighted arguement in function!') print('*Completed: Finished calc_RMSE function!') return rmse ############################################################################### ############################################################################### ############################################################################### def calc_spatialCorrHeight(varx,vary,levs,lons,weight): """ Calculates spatial correlation from pearson correlation coefficient for grids over vertical height (17 pressure coordinate levels) Parameters ---------- varx : 2d array vary : 2d array levs : 1d array of levels lons : 1d array of latitude weight : string (yes or no) Returns ------- corrcoef : 1d array of correlation coefficient (pearson r) Usage ----- corrcoef = calc_spatialCorrHeight(varx,vary,lats,lons) """ print('\n>>> Using calc_spatialCorrHeight function!') ### Import modules import numpy as np if weight == 'yes': # Computed weighted correlation coefficient ### Create 2d meshgrid for weights lon2,lev2 = np.meshgrid(lons,levs) ### Create 2d array of weights based on latitude gwq = np.array([0.25,0.25,0.25,0.25,0.25,0.25,0.4,0.5,0.5,0.5, 0.5,0.5,0.5,0.7,0.7,0.7,1.]) gw,gw2 = np.meshgrid(lons,gwq) def m(x, w): """Weighted Mean""" wave = np.sum(x * w) / np.sum(w) print('Completed: Computed weighted average (17 P Levels)!') return wave def cov(x, y, w): """Weighted Covariance""" wcov = np.sum(w * (x - m(x, w)) * (y - m(y, w))) / np.sum(w) print('Completed: Computed weighted covariance (17 P Levels)!') return wcov def corr(x, y, w): """Weighted Correlation""" wcor = cov(x, y, w) / np.sqrt(cov(x, x, w) * cov(y, y, w)) print('Completed: Computed weighted correlation (17 P Levels)!') return wcor corrcoef = corr(varx,vary,gw) elif weight == 'no': ### Correlation coefficient from numpy function (not weighted) corrcoef= np.corrcoef(varx.ravel(),vary.ravel())[0][1] print('Completed: Computed NON-weighted correlation!') else: ValueError('Wrong weighted argument in function!') print('*Completed: Finished calc_SpatialCorrHeight function!') return corrcoef ############################################################################### ############################################################################### ############################################################################### def calc_spatialCorrHeightLev(varx,vary,levs,lons,weight,levelq): """ Calculates spatial correlation from pearson correlation coefficient for grids over vertical height (17 pressure coordinate levels). Change the weighting for different level correlations Parameters ---------- varx : 2d array vary : 2d array levs : 1d array of levels lons : 1d array of latitude weight : string (yes or no) levelq : string (all, tropo, strato) Returns ------- corrcoef : 1d array of correlation coefficient (pearson r) Usage ----- corrcoef = calc_spatialCorrHeight(varx,vary,lats,lons,levels) """ print('\n>>> Using calc_spatialCorrHeightLev function!') ### Import modules import numpy as np if weight == 'yes': # Computed weighted correlation coefficient ### Create 2d meshgrid for weights lon2,lev2 = np.meshgrid(lons,levs) if levelq == 'all': ### Create 2d array of weights based on latitude gwq = np.array([0.25,0.25,0.25,0.25,0.25,0.25,0.4,0.5,0.5,0.5, 0.5,0.5,0.5,0.7,0.7,0.7,1.]) gw,gw2 = np.meshgrid(lons,gwq) elif levelq == 'tropo': gwq = np.array([1.0,1.0,1.0,1.0,0.5,0.5,0.5,0.2,0.2,0.,0.,0., 0.,0.,0.,0.,0.]) gw,gw2 = np.meshgrid(lons,gwq) elif levelq == 'strato': gwq = np.array([0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.5,1.,1.,1.,1. ,1.,1.]) gw,gw2 = np.meshgrid(lons,gwq) def m(x, w): """Weighted Mean""" wave = np.sum(x * w) / np.sum(w) print('Completed: Computed weighted average (17 P Levels)!') return wave def cov(x, y, w): """Weighted Covariance""" wcov = np.sum(w * (x - m(x, w)) * (y - m(y, w))) / np.sum(w) print('Completed: Computed weighted covariance (17 P Levels)!') return wcov def corr(x, y, w): """Weighted Correlation""" wcor = cov(x, y, w) / np.sqrt(cov(x, x, w) * cov(y, y, w)) print('Completed: Computed weighted correlation (17 P Levels)!') return wcor corrcoef = corr(varx,vary,gw) elif weight == 'no': ### Correlation coefficient from numpy function (not weighted) corrcoef= np.corrcoef(varx.ravel(),vary.ravel())[0][1] print('Completed: Computed NON-weighted correlation!') else: ValueError('Wrong weighted argument in function!') print('*Completed: Finished calc_SpatialCorrHeightLev function!') return corrcoef

0a33db09aef1c74c5ffed0995a5bf7a3bfec7f84

py

Python

tests/python/unittest/test_tir_schedule_compute_inline.py

xiebaiyuan/tvm

726239d788e3b90cbe4818271ca5361c46d8d246

tests/python/unittest/test_tir_schedule_compute_inline.py

xiebaiyuan/tvm

726239d788e3b90cbe4818271ca5361c46d8d246

tests/python/unittest/test_tir_schedule_compute_inline.py

xiebaiyuan/tvm

726239d788e3b90cbe4818271ca5361c46d8d246

# Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. # pylint: disable=missing-function-docstring,missing-module-docstring import pytest import tvm from tvm import tir from tvm.script import ty # pylint: disable=no-member,invalid-name,unused-variable @tvm.script.tir def elementwise(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 with tir.block([128, 128], "C") as [vi, vj]: C[vi, vj] = B[vi, vj] + 1.0 @tvm.script.tir def elementwise_multi_producer_consumer(a: ty.handle, c: ty.handle, d: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.match_buffer(c, (128, 128)) D = tir.match_buffer(d, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 # B has two consumers with tir.block([128, 128], "C") as [vi, vj]: C[vi, vj] = B[vi, vj] + 1.0 with tir.block([128, 128], "D") as [vi, vj]: D[vi, vj] = B[vi, vj] + 2.0 + C[vi, vj] # D has two producers @tvm.script.tir def elementwise_multi_consumer_inlined(a: ty.handle, c: ty.handle, d: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) C = tir.match_buffer(c, (128, 128)) D = tir.match_buffer(d, (128, 128)) with tir.block([128, 128], "C") as [vi, vj]: C[vi, vj] = A[vi, vj] * 2.0 + 1.0 with tir.block([128, 128], "D") as [vi, vj]: D[vi, vj] = A[vi, vj] * 2.0 + 2.0 + C[vi, vj] @tvm.script.tir def elementwise_standalone(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 with tir.block([128, 128], "C") as [vi, vj]: C[vi, vj] = A[vi, vj] + 1.0 @tvm.script.tir def elementwise_standalone_dce(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "C") as [vi, vj]: C[vi, vj] = A[vi, vj] + 1.0 @tvm.script.tir def elementwise_under_loop(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) C = tir.match_buffer(c, (128, 128)) B = tir.alloc_buffer((128, 128)) for i in tir.serial(0, 128): for j in tir.serial(0, 128): with tir.block([128, 128], "B") as [vi, vj]: tir.bind(vi, i) tir.bind(vj, j) B[vi, vj] = A[vi, vj] * 2.0 for j in tir.serial(0, 128): with tir.block([128, 128], "C") as [vi, vj]: tir.bind(vi, i) tir.bind(vj, j) C[vi, vj] = B[vi, vj] + 1.0 @tvm.script.tir def elementwise_inlined(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "C") as [vi, vj]: C[vi, vj] = A[vi, vj] * 2.0 + 1.0 @tvm.script.tir def fail_multi_reader_writer(a: ty.handle, d: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.alloc_buffer((128, 128)) D = tir.match_buffer(d, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 C[vi, vj] = A[vi, vj] + 2.0 with tir.block([128, 128], "C") as [vi, vj]: D[vi, vj] = B[vi, vj] + C[vi, vj] @tvm.script.tir def elementwise_multi_reverse_loads(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 with tir.block([128, 128], "C") as [vi, vj]: C[vi, vj] = (B[vi, vj] + 1.0) * (B[vi, vj] * 2.0) + 3.0 @tvm.script.tir def elementwise_multi_reverse_loads_inlined(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: C[vi, vj] = (A[vi, vj] * 2.0 + 1.0) * (A[vi, vj] * 2.0 * 2.0) + 3.0 @tvm.script.tir def opaque_access_load(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 with tir.block([128, 128], "C") as [vi, vj]: tir.reads(B[0:128, 0:128]) tir.writes(C[0:128, 0:128]) C[vi, vj] = tir.load("float32", B.data, vi * 128 + vj) + 1.0 @tvm.script.tir def opaque_access_store(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 with tir.block([128, 128], "C") as [vi, vj]: tir.reads(B[0:128, 0:128]) tir.writes(C[0:128, 0:128]) tir.store(C.data, vi * 128 + vj, B[vi, vj] + 1.0) C[vi, vj] = tir.load("float32", B.data, vi * 16 + vj) + 1.0 @tvm.script.tir def buffer_matched(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 with tir.block([128, 128], "C") as [vi, vj]: Bb = tir.match_buffer(B[vi : vi + 1, vj], (1, 1)) C[vi, vj] = Bb[0, 0] + 1.0 @tvm.script.tir def elementwise_predicate(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 for i, j in tir.grid(128, 128): with tir.block([128, 128], "C") as [vi, vj]: tir.where(B[i, j] < 10.0) C[vi, vj] = B[vi, vj] + 1.0 @tvm.script.tir def elementwise_predicate_inlined(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) C = tir.match_buffer(c, (128, 128)) for i, j in tir.grid(128, 128): with tir.block([128, 128], "C") as [vi, vj]: tir.where(A[i, j] * 2.0 < 10.0) C[vi, vj] = A[vi, vj] * 2.0 + 1.0 @tvm.script.tir def elementwise_multi_loads(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) B = tir.alloc_buffer((128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 128], "B") as [vi, vj]: B[vi, vj] = A[vi, vj] * 2.0 with tir.block([128, 126], "C") as [vi, vj]: C[vi, vj] = B[vi, vj] + B[vi, vj + 1] + B[vi, vj + 2] @tvm.script.tir def elementwise_multi_loads_inlined(a: ty.handle, c: ty.handle) -> None: A = tir.match_buffer(a, (128, 128)) C = tir.match_buffer(c, (128, 128)) with tir.block([128, 126], "C") as [vi, vj]: C[vi, vj] = A[vi, vj] * 2.0 + A[vi, vj + 1] * 2.0 + A[vi, vj + 2] * 2.0 # pylint: enable=no-member,invalid-name,unused-variable def test_compute_inline_elementwise(): sch = tir.Schedule(elementwise, debug_mode=True) block_b = sch.get_block("B") block_c = sch.get_block("C") sch.compute_inline(block_b) tvm.ir.assert_structural_equal(elementwise_inlined, sch.mod["main"]) assert sch.get(block_c).name_hint == "C" def test_compute_inline_under_loop(): sch = tir.Schedule(elementwise_under_loop, debug_mode=True) block_b = sch.get_block("B") block_c = sch.get_block("C") sch.compute_inline(block_b) tvm.ir.assert_structural_equal(elementwise_inlined, sch.mod["main"]) assert sch.get(block_c).name_hint == "C" def test_compute_inline_as_dce(): sch = tir.Schedule(elementwise_standalone, debug_mode=True) block_b = sch.get_block("B") block_c = sch.get_block("C") sch.compute_inline(block_b) tvm.ir.assert_structural_equal(elementwise_standalone_dce, sch.mod["main"]) assert sch.get(block_c).name_hint == "C" def test_compute_inline_multi_consumer(): sch = tir.Schedule(elementwise_multi_producer_consumer, debug_mode=True) block_b = sch.get_block("B") block_c = sch.get_block("C") block_d = sch.get_block("D") sch.compute_inline(block_b) tvm.ir.assert_structural_equal(elementwise_multi_consumer_inlined, sch.mod["main"]) assert sch.get(block_c).name_hint == "C" assert sch.get(block_d).name_hint == "D" def test_compute_inline_fail_multi_writer(): sch = tir.Schedule(fail_multi_reader_writer, debug_mode=True, error_render_level="detail") block_b = sch.get_block("B") with pytest.raises(tvm.tir.ScheduleError): sch.compute_inline(block_b) def test_reverse_compute_inline_elementwise(): sch = tir.Schedule(elementwise, debug_mode=True) block_b = sch.get_block("B") block_c = sch.get_block("C") sch.reverse_compute_inline(block_c) tvm.ir.assert_structural_equal(elementwise_inlined, sch.mod["main"]) assert sch.get(block_b).name_hint == "B" def test_reverse_compute_inline_under_loop(): sch = tir.Schedule(elementwise_under_loop, debug_mode=True) block_b = sch.get_block("B") block_c = sch.get_block("C") sch.reverse_compute_inline(block_c) tvm.ir.assert_structural_equal(elementwise_inlined, sch.mod["main"]) assert sch.get(block_b).name_hint == "B" def test_reverse_compute_inline_fail_as_dce(): sch = tir.Schedule(elementwise_standalone, debug_mode=True) block_b = sch.get_block("B") with pytest.raises(tvm.tir.ScheduleError): sch.reverse_compute_inline(block_b) def test_reverse_compute_inline_fail_multi_producer(): sch = tir.Schedule(elementwise_multi_producer_consumer, debug_mode=True) block_d = sch.get_block("D") with pytest.raises(tvm.tir.ScheduleError): sch.reverse_compute_inline(block_d) def test_reverse_compute_inline_fail_multi_reader(): sch = tir.Schedule(fail_multi_reader_writer, debug_mode=True) block_c = sch.get_block("C") with pytest.raises(tvm.tir.ScheduleError): sch.reverse_compute_inline(block_c) def test_reverse_compute_multi_reverse_loads(): sch = tir.Schedule(elementwise_multi_reverse_loads, debug_mode=True) block_c = sch.get_block("C") sch.reverse_compute_inline(block_c) tvm.ir.assert_structural_equal(elementwise_multi_reverse_loads_inlined, sch.mod["main"]) def test_reverse_compute_fail_multi_reverse_loads(): sch = tir.Schedule(elementwise_multi_loads, debug_mode=True) block_c = sch.get_block("C") with pytest.raises(tvm.tir.ScheduleError): sch.reverse_compute_inline(block_c) def test_opaque_access_load(): sch = tir.Schedule(opaque_access_load, debug_mode=True) block_b = sch.get_block("B") with pytest.raises(tvm.tir.ScheduleError): sch.compute_inline(block_b) def test_opaque_access_store(): sch = tir.Schedule(opaque_access_store, debug_mode=True) block_b = sch.get_block("B") with pytest.raises(tvm.tir.ScheduleError): sch.compute_inline(block_b) def test_buffer_matched(): sch = tir.Schedule(buffer_matched, debug_mode=True) block_b = sch.get_block("B") with pytest.raises(tvm.tir.ScheduleError): sch.compute_inline(block_b) def test_compute_inline_predicate(): sch = tir.Schedule(elementwise_predicate, debug_mode=True) block_b = sch.get_block("B") sch.compute_inline(block_b) tvm.ir.assert_structural_equal(elementwise_predicate_inlined, sch.mod["main"]) def test_compute_inline_multi_loads(): sch = tir.Schedule(elementwise_multi_loads, debug_mode=True) block_b = sch.get_block("B") sch.compute_inline(block_b) tvm.ir.assert_structural_equal(elementwise_multi_loads_inlined, sch.mod["main"]) if __name__ == "__main__": test_compute_inline_elementwise() test_compute_inline_under_loop() test_compute_inline_as_dce() test_compute_inline_multi_consumer() test_compute_inline_fail_multi_writer() test_reverse_compute_inline_elementwise() test_reverse_compute_inline_under_loop() test_reverse_compute_inline_fail_as_dce() test_reverse_compute_inline_fail_multi_producer() test_reverse_compute_inline_fail_multi_reader() test_reverse_compute_multi_reverse_loads() test_reverse_compute_fail_multi_reverse_loads() test_opaque_access_load() test_opaque_access_store() test_buffer_matched() test_compute_inline_predicate() test_compute_inline_multi_loads()

0a3465198ac8a54def9b1ff02f89cdbec3079889

py

Python

cwl_flask.py

Sage-Bionetworks/workflow-service

8b5dc0afe9ea0972014cdf48a693ee6f893cfe5e

2019-11-14T23:46:23.000Z

2019-11-14T23:46:23.000Z

cwl_flask.py

Sage-Bionetworks/workflow-service

8b5dc0afe9ea0972014cdf48a693ee6f893cfe5e

cwl_flask.py

Sage-Bionetworks/workflow-service

8b5dc0afe9ea0972014cdf48a693ee6f893cfe5e

from flask import Flask, Response, request, redirect import subprocess import tempfile import json import yaml import signal import threading import time import copy app = Flask(__name__) jobs_lock = threading.Lock() jobs = [] class Job(threading.Thread): def __init__(self, jobid, path, inputobj): super(Job, self).__init__() self.jobid = jobid self.path = path self.inputobj = inputobj self.updatelock = threading.Lock() self.begin() def begin(self): loghandle, self.logname = tempfile.mkstemp() with self.updatelock: self.outdir = tempfile.mkdtemp() self.proc = subprocess.Popen(["cwl-runner", self.path, "-"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=loghandle, close_fds=True, cwd=self.outdir) self.status = { "id": "%sjobs/%i" % (request.url_root, self.jobid), "log": "%sjobs/%i/log" % (request.url_root, self.jobid), "run": self.path, "state": "Running", "input": json.loads(self.inputobj), "output": None} def run(self): self.stdoutdata, self.stderrdata = self.proc.communicate(self.inputobj) if self.proc.returncode == 0: outobj = yaml.load(self.stdoutdata, Loader=yaml.FullLoader) with self.updatelock: self.status["state"] = "Success" self.status["output"] = outobj else: with self.updatelock: self.status["state"] = "Failed" def getstatus(self): with self.updatelock: return self.status.copy() def cancel(self): if self.status["state"] == "Running": self.proc.send_signal(signal.SIGQUIT) with self.updatelock: self.status["state"] = "Canceled" def pause(self): if self.status["state"] == "Running": self.proc.send_signal(signal.SIGTSTP) with self.updatelock: self.status["state"] = "Paused" def resume(self): if self.status["state"] == "Paused": self.proc.send_signal(signal.SIGCONT) with self.updatelock: self.status["state"] = "Running" @app.route("/run", methods=['POST']) def runworkflow(): path = request.args["wf"] with jobs_lock: jobid = len(jobs) job = Job(jobid, path, request.stream.read()) job.start() jobs.append(job) return redirect("/jobs/%i" % jobid, code=303) @app.route("/jobs/<int:jobid>", methods=['GET', 'POST']) def jobcontrol(jobid): with jobs_lock: job = jobs[jobid] if request.method == 'POST': action = request.args.get("action") if action: if action == "cancel": job.cancel() elif action == "pause": job.pause() elif action == "resume": job.resume() status = job.getstatus() return json.dumps(status, indent=4), 200, "" def logspooler(job): with open(job.logname, "r") as f: while True: r = f.read(4096) if r: yield r else: with job.updatelock: if job.status["state"] != "Running": break time.sleep(1) @app.route("/jobs/<int:jobid>/log", methods=['GET']) def getlog(jobid): with jobs_lock: job = jobs[jobid] return Response(logspooler(job)) @app.route("/jobs", methods=['GET']) def getjobs(): with jobs_lock: jobscopy = copy.copy(jobs) def spool(jc): yield "[" first = True for j in jc: if first: yield json.dumps(j.getstatus(), indent=4) first = False else: yield ", " + json.dumps(j.getstatus(), indent=4) yield "]" return Response(spool(jobscopy)) if __name__ == "__main__": # app.debug = True app.run()

0a3472688b742e51fb849821bffb5408a0c299f0

py

Python

cs15211/ReverseBits.py

JulyKikuAkita/PythonPrac

0ba027d9b8bc7c80bc89ce2da3543ce7a49a403c

2021-07-05T01:53:30.000Z

2021-07-05T01:53:30.000Z

cs15211/ReverseBits.py

JulyKikuAkita/PythonPrac

0ba027d9b8bc7c80bc89ce2da3543ce7a49a403c

cs15211/ReverseBits.py

JulyKikuAkita/PythonPrac

0ba027d9b8bc7c80bc89ce2da3543ce7a49a403c

2018-01-08T07:14:08.000Z

2018-01-08T07:14:08.000Z

__source__ = 'https://leetcode.com/problems/reverse-bits/description/' # https://github.com/kamyu104/LeetCode/blob/master/Python/reverse-bits.py # Time : O(n) # Space: O(1) # Bit Manipulation # # Description: Leetcode # 190. Reverse Bits # # Reverse bits of a given 32 bits unsigned integer. # # For example, given input 43261596 (represented in binary as 00000010100101000001111010011100), # return 964176192 (represented in binary as 00111001011110000010100101000000). # # Follow up: # If this function is called many times, how would you optimize it? # # Companies # Apple Airbnb # Related Topics # Bit Manipulation # Similar Questions # Number of 1 Bits # import unittest class Solution: # @param n, an integer # @return an integer def reverseBits(self, n): result = 0 for i in xrange(32): result <<= 1 result |= n & 1 n >>= 1 return result class TestMethods(unittest.TestCase): def test_Local(self): self.assertEqual(1, 1) print Solution().reverseBits(1) if __name__ == '__main__': unittest.main() Java = ''' # Thought: # 1ms 100% class Solution { // you need treat n as an unsigned value public int reverseBits(int n) { int ret = 0; for (int i = 0; i < 32; i++) { if ((n & 1) != 0) { ret |= 1; //same as // res += n & 1 } n >>>= 1; // padding 0 on the left side if (i < 31) { // CATCH: for last digit, don't shift! ret <<= 1; } } return ret; } } We first intitialize result to 0. We then iterate from 0 to 31 (an integer has 32 bits). In each iteration: We first shift result to the left by 1 bit. Then, if the last digit of input n is 1, we add 1 to result. To find the last digit of n, we just do: (n & 1) Example, if n=5 (101), n&1 = 101 & 001 = 001 = 1; however, if n = 2 (10), n&1 = 10 & 01 = 0). Finally, we update n by shifting it to the right by 1 (n >>= 1) At the end of the iteration, we return result. Example, if input n = 13 (represented in binary as 0000_0000_0000_0000_0000_0000_0000_1101, the "_" is for readability), calling reverseBits(13) should return: 1011_0000_0000_0000_0000_0000_0000_0000 Here is how our algorithm would work for input n = 13: Initially, result = 0 = 0000_0000_0000_0000_0000_0000_0000_0000, n = 13 = 0000_0000_0000_0000_0000_0000_0000_1101 Starting for loop: i = 0: result = result << 1 = 0000_0000_0000_0000_0000_0000_0000_0000. n&1 = 0000_0000_0000_0000_0000_0000_0000_1101 & 0000_0000_0000_0000_0000_0000_0000_0001 = 0000_0000_0000_0000_0000_0000_0000_0001 = 1 therefore result = result + 1 = 0000_0000_0000_0000_0000_0000_0000_0000 + 0000_0000_0000_0000_0000_0000_0000_0001 = 0000_0000_0000_0000_0000_0000_0000_0001 = 1 We right shift n by 1 (n >>= 1) to get: n = 0000_0000_0000_0000_0000_0000_0000_0110. We then go to the next iteration. i = 1: result = result << 1 = 0000_0000_0000_0000_0000_0000_0000_0010; n&1 = 0000_0000_0000_0000_0000_0000_0000_0110 & 0000_0000_0000_0000_0000_0000_0000_0001 = 0000_0000_0000_0000_0000_0000_0000_0000 = 0; therefore we don't increment result. We right shift n by 1 (n >>= 1) to get: n = 0000_0000_0000_0000_0000_0000_0000_0011. We then go to the next iteration. i = 2: result = result << 1 = 0000_0000_0000_0000_0000_0000_0000_0100. n&1 = 0000_0000_0000_0000_0000_0000_0000_0011 & 0000_0000_0000_0000_0000_0000_0000_0001 = 0000_0000_0000_0000_0000_0000_0000_0001 = 1 therefore result = result + 1 = 0000_0000_0000_0000_0000_0000_0000_0100 + 0000_0000_0000_0000_0000_0000_0000_0001 = result = 0000_0000_0000_0000_0000_0000_0000_0101 We right shift n by 1 to get: n = 0000_0000_0000_0000_0000_0000_0000_0001. We then go to the next iteration. i = 3: result = result << 1 = 0000_0000_0000_0000_0000_0000_0000_1010. n&1 = 0000_0000_0000_0000_0000_0000_0000_0001 & 0000_0000_0000_0000_0000_0000_0000_0001 = 0000_0000_0000_0000_0000_0000_0000_0001 = 1 therefore result = result + 1 = = 0000_0000_0000_0000_0000_0000_0000_1011 We right shift n by 1 to get: n = 0000_0000_0000_0000_0000_0000_0000_0000 = 0. Now, from here to the end of the iteration, n is 0, so (n&1) will always be 0 and n >>=1 will not change n. The only change will be for result <<=1, i.e. shifting result to the left by 1 digit. Since there we have i=4 to i = 31 iterations left, this will result in padding 28 0's to the right of result. i.e at the end, we get result = 1011_0000_0000_0000_0000_0000_0000_0000 This is exactly what we expected to get # 1ms 100% class Solution { // you need treat n as an unsigned value public int reverseBits(int n) { if (n == 0) return 0; int result = 0; for (int i = 0; i < 32; i++) { result <<= 1; if ((n & 1) == 1) result++; n >>= 1; } return result; } } # 1ms 100% class Solution { // you need treat n as an unsigned value public int reverseBits(int n) { n = ((n & 0x55555555) << 1) | ((n & 0xAAAAAAAA) >>> 1); n = ((n & 0x33333333) << 2) | ((n & 0xCCCCCCCC) >>> 2); n = ((n & 0x0F0F0F0F) << 4) | ((n & 0xF0F0F0F0) >>> 4); n = ((n & 0x00FF00FF) << 8) | ((n & 0xFF00FF00) >>> 8); return (n >>> 16) | (n << 16); } } '''

0a34f204369f984c96ff6e5a370ca5dd3ef2cd5a

py

Python

tibanna/_version.py

freezecoder/tibanna

89b02e95d04b9c630a9786f4d1eb8157c40098e0

tibanna/_version.py

freezecoder/tibanna

89b02e95d04b9c630a9786f4d1eb8157c40098e0

tibanna/_version.py

freezecoder/tibanna

89b02e95d04b9c630a9786f4d1eb8157c40098e0

"""Version information.""" # The following line *must* be the last in the module, exactly as formatted: __version__ = "0.16.1"

0a35e9528722fb698d7d9b2d769ceed182b29b73

py

Python

selective_merge_pdf.py

vs-slavchev/selective_merge_pdf

b24b4dbcaf1ffb8dc0924dafec56f94e452c1ebd

selective_merge_pdf.py

vs-slavchev/selective_merge_pdf

b24b4dbcaf1ffb8dc0924dafec56f94e452c1ebd

selective_merge_pdf.py

vs-slavchev/selective_merge_pdf

b24b4dbcaf1ffb8dc0924dafec56f94e452c1ebd

from sys import argv from PyPDF2 import PdfFileReader, PdfFileWriter import re range_pattern = re.compile(r'(\d+)(\.\.|-)(\d+)') comma_pattern = re.compile('\d+(,\d+)*') def pages_args_to_array(pages_str): groups = range_pattern.search(pages_str) if groups: start = int(groups.group(1)) end = int(groups.group(3)) return list(range(start, end + 1)) elif comma_pattern.search(pages_str): return [int(d) for d in pages_str.split(',')] else: raise Exception('pages should be like 1,2,3 or 1-3, but was {}' .format(pages_str)) if __name__ == '__main__': assert(len(argv) > 1), "usage examle:\npython3 selective_merge_pdf.py file1.pdf 1-3 file2.pdf 3,4,10 file1.pdf 50" assert(len(argv) % 2 == 1), "invalid arguments; supply page numbers after each pdf name" files_names = argv[1::2] pages_args = argv[2::2] pdf_writer = PdfFileWriter() for file_name, pages in zip(files_names, pages_args): pdf_reader = PdfFileReader(file_name) last_page_index = pdf_reader.getNumPages() pages = pages_args_to_array(pages) pages_to_add = list(filter(lambda i: i >= 0 and i <= last_page_index, pages)) for page in pages_to_add: pdf_writer.addPage(pdf_reader.getPage(page - 1)) with open("merged.pdf", 'wb') as out: pdf_writer.write(out)

0a366dc7ea5c7f093418a07f29237983fc6bf2d7

py

Python

vp/scoring.py

romack77/vp-toolbox

2677b78b80d0b4794735f3ee9bd70403c6b884e6

2019-08-03T06:29:47.000Z

2022-02-05T03:08:15.000Z

vp/scoring.py

romack77/vp-toolbox

2677b78b80d0b4794735f3ee9bd70403c6b884e6

vp/scoring.py

romack77/vp-toolbox

2677b78b80d0b4794735f3ee9bd70403c6b884e6

2019-01-22T12:19:05.000Z

2021-02-25T16:58:59.000Z

import math from vp import geom_tools def horizon_error(ground_truth_horizon, detected_horizon, image_dims): """Calculates error in a detected horizon. This measures the max distance between the detected horizon line and the ground truth horizon line, within the image's x-axis, and normalized by image height. Args: ground_truth_horizon: Tuple with (slope, intercept) for the GT horizon line. detected_horizon: Tuple with (slope, intercept) for the detected horizon line. image_dims: Tuple of integers, (width, height) of the image, in pixels. Returns: Float, or None if a horizon is missing altogether. """ if ground_truth_horizon is None or detected_horizon is None: return None def gt(x): return ground_truth_horizon[0] * x + ground_truth_horizon[1] def dt(x): return detected_horizon[0] * x + detected_horizon[1] width, height = image_dims return max(abs(gt(0) - dt(0)), abs(gt(width) - dt(width))) / height def vp_direction_error(ground_truth_vps, detected_vps, image_dims): """Measures error in direction from center of detected vanishing points. Each detected VP is matched with its closest unclaimed ground truth VP. Args: ground_truth_vps: List of ground truth VP point tuples. detected_vps: List of detected VP point tuples. image_dims: Tuple of integers, (width, height) of the image, in pixels. Returns: List with float degrees of error for each ground truth VP. Error is None for missing VPs. """ principal_point = (image_dims[0] // 2, image_dims[1] // 2) point_pair_dists = [] for gt_vp in ground_truth_vps: for dt_vp in detected_vps: gt_angle = geom_tools.get_line_angle(( principal_point[0], principal_point[1], gt_vp[0], gt_vp[1])) dt_angle = geom_tools.get_line_angle(( principal_point[0], principal_point[1], dt_vp[0], dt_vp[1])) angle_diff = 180 - abs(abs(gt_angle - dt_angle) - 180) point_pair_dists.append((angle_diff, gt_vp, dt_vp)) point_pair_dists = sorted(point_pair_dists, key=lambda k: k[0]) gt_vp_to_error = {} seen_dt_vps = set() for distance, gt_vp, dt_vp in point_pair_dists: if gt_vp in gt_vp_to_error or dt_vp in seen_dt_vps: continue gt_vp_to_error[gt_vp] = distance seen_dt_vps.add(dt_vp) return [gt_vp_to_error.get(gt, None) for gt in ground_truth_vps] def location_accuracy_error(ground_truth_vps, detected_vps): """Measures average error in the location of detected vanishing points. "Missed" or "extra" VPs do not count against the score. Based on log distance of detected vp from ground truth vp. Args: ground_truth_vps: List of ground truth VP point tuples. detected_vps: List of detected VP point tuples. Returns: Float, error. """ if len(ground_truth_vps) == 0 or len(detected_vps) == 0: return 0 point_pair_dists = [] for gt_vp in ground_truth_vps: for dt_vp in detected_vps: distance = geom_tools.point_to_point_dist(gt_vp, dt_vp) point_pair_dists.append((distance, gt_vp, dt_vp)) sorted(point_pair_dists, key=lambda k: k[0]) seen_gt_vps = set() seen_dt_vps = set() total_error = 0 for distance, gt_vp, dt_vp in point_pair_dists: if gt_vp in seen_gt_vps or dt_vp in seen_dt_vps: continue seen_gt_vps.add(gt_vp) seen_dt_vps.add(dt_vp) if distance > 0: total_error += math.log(distance) return total_error / min(len(detected_vps), len(ground_truth_vps)) def num_model_detection_error(ground_truth_vps, detected_vps): """Measures error in the number of detected vanishing points. Returns: Integer, positive when there are too many VPs, negative when there are too few. """ return len(detected_vps) - len(ground_truth_vps)

0a36be6ff9e65c7b1ffad1c7ff8f47b4ee0f6df3

py

Python

compositional-rl-benchmark/composition/spinningup_training/train_mtl_ppo.py

collassubmission91/CompoSuite-Code

ac544efb68a11ed8a483b0932975c4949f0cec90

compositional-rl-benchmark/composition/spinningup_training/train_mtl_ppo.py

collassubmission91/CompoSuite-Code

ac544efb68a11ed8a483b0932975c4949f0cec90

compositional-rl-benchmark/composition/spinningup_training/train_mtl_ppo.py

collassubmission91/CompoSuite-Code

ac544efb68a11ed8a483b0932975c4949f0cec90

import numpy as np import argparse import composition import os import json import torch from spinup.algos.pytorch.ppo.core import MLPActorCritic from spinup.algos.pytorch.ppo.ppo import ppo from spinup.utils.run_utils import setup_logger_kwargs from spinup.utils.mpi_tools import proc_id, num_procs def parse_args(): parser = argparse.ArgumentParser() parser.add_argument('--data-dir', default='spinningup_training/logs') parser.add_argument('--load-dir', default=None) parser.add_argument('--gridsearch-id', type=int, default=-1) parser.add_argument('--task-id', type=int, default=-1) parser.add_argument('--hid', type=int, default=256) parser.add_argument('--l', type=int, default=2) parser.add_argument('--gamma', type=float, default=0.99) parser.add_argument('--seed', '-s', type=int, default=4) parser.add_argument('--cpu', type=int, default=4) parser.add_argument('--steps', type=int, default=16000) parser.add_argument('--epochs', type=int, default=625) parser.add_argument('--exp-name', type=str, default='ppo') parser.add_argument('--clip', type=float, default=0.2) parser.add_argument('--pi-lr', type=float, default=1e-4) parser.add_argument('--vf-lr', type=float, default=1e-4) parser.add_argument('--pi-iters', type=int, default=128) parser.add_argument('--vf-iters', type=int, default=128) parser.add_argument('--target-kl', type=float, default=0.02) parser.add_argument('--ent-coef', type=float, default=0.02) parser.add_argument('--log-std-init', type=float, default=0.) parser.add_argument('--controller', type=str, default="joint") parser.add_argument('--robot', type=str, default="IIWA") parser.add_argument('--object', type=str, default="Hollowbox") parser.add_argument('--obstacle', type=str, default=None) parser.add_argument('--task', type=str, default="PickPlace") parser.add_argument('--horizon', type=int, default=500) args = parser.parse_args() np.random.seed(args.seed) task_list = np.random.choice(256, num_procs(), replace=False) args.task_id = int(task_list[proc_id()]) _robots = ["IIWA", "Jaco", "Kinova3", "Panda"] _objects = ["Box", "Dumbbell", "Plate", "Hollowbox"] _objectives = ["PickPlace", "Push", "Shelf", "Trashcan"] _obstacles = ["None", "GoalWall", "ObjectDoor", "ObjectWall"] idx = np.unravel_index(args.task_id, (len(_robots), len(_objects), len(_objectives), len(_obstacles))) args.robot = _robots[idx[0]] args.object = _objects[idx[1]] args.task = _objectives[idx[2]] args.obstacle = _obstacles[idx[3]] # args.exp_name = "t:" + str(args.task_id) + "_name:" + args.exp_name + "_robot:" + str(args.robot) + "_task:" + str(args.task) + "_object:" + str(args.object) + "_obstacle:" + str(args.obstacle) args.exp_name = 'MTL_{}'.format(len(task_list)) return args def main(): torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False torch.set_num_threads(1) args = parse_args() os.makedirs(os.path.join(args.data_dir, args.exp_name), exist_ok=True) with open(os.path.join(args.data_dir, args.exp_name, 'args_{}.json'.format(proc_id())), 'w') as f: json.dump(args.__dict__, f, indent=2) logger_kwargs = setup_logger_kwargs( args.exp_name, data_dir=args.data_dir) checkpoint = None if args.load_dir is not None: checkpoint = torch.load(os.path.join(args.load_dir, 'pyt_save', 'state_dicts.pt')) ppo(lambda: composition.make( args.robot, args.object, args.obstacle, args.task, args.controller, args.horizon, use_task_id_obs=True), actor_critic=MLPActorCritic, ac_kwargs=dict(hidden_sizes=[args.hid]*args.l, log_std_init=args.log_std_init), seed=args.seed, gamma=args.gamma, steps_per_epoch=args.steps, epochs=args.epochs, clip_ratio=args.clip, pi_lr=args.pi_lr, vf_lr=args.vf_lr, train_pi_iters=args.pi_iters, train_v_iters=args.vf_iters, target_kl=args.target_kl, logger_kwargs=logger_kwargs, max_ep_len=args.horizon, ent_coef=args.ent_coef, log_per_proc=True, checkpoint=checkpoint) if __name__ == '__main__': main()

0a36ce830d4011a6336f73093bb61b54abdb2cbd

py

Python

pypy/interpreter/test/test_generator.py

m4sterchain/mesapy

ed546d59a21b36feb93e2309d5c6b75aa0ad95c9

2018-08-18T03:37:22.000Z

2022-02-06T23:57:36.000Z

pypy/interpreter/test/test_generator.py

m4sterchain/mesapy

ed546d59a21b36feb93e2309d5c6b75aa0ad95c9

2018-09-22T18:12:47.000Z

2022-02-22T20:03:59.000Z

pypy/interpreter/test/test_generator.py

m4sterchain/mesapy

ed546d59a21b36feb93e2309d5c6b75aa0ad95c9

2018-08-20T03:16:34.000Z

2022-01-12T17:39:22.000Z

class AppTestGenerator: def test_generator(self): def f(): yield 1 assert f().next() == 1 def test_generator2(self): def f(): yield 1 g = f() assert g.next() == 1 raises(StopIteration, g.next) def test_attributes(self): def f(): yield 1 assert g.gi_running g = f() assert g.gi_code is f.__code__ assert g.__name__ == 'f' assert g.gi_frame is not None assert not g.gi_running g.next() assert not g.gi_running raises(StopIteration, g.next) assert not g.gi_running assert g.gi_frame is None assert g.gi_code is f.__code__ assert g.__name__ == 'f' def test_generator3(self): def f(): yield 1 g = f() assert list(g) == [1] def test_generator4(self): def f(): yield 1 g = f() assert [x for x in g] == [1] def test_generator5(self): d = {} exec """if 1: def f(): v = (yield ) yield v g = f() g.next() """ in d g = d['g'] assert g.send(42) == 42 def test_throw1(self): def f(): yield 2 g = f() # two arguments version raises(NameError, g.throw, NameError, "Error") def test_throw2(self): def f(): yield 2 g = f() # single argument version raises(NameError, g.throw, NameError("Error")) def test_throw3(self): def f(): try: yield 1 yield 2 except: yield 3 g = f() assert g.next() == 1 assert g.throw(NameError("Error")) == 3 raises(StopIteration, g.next) def test_throw4(self): d = {} exec """if 1: def f(): try: yield 1 v = (yield 2) except: yield 3 g = f() """ in d g = d['g'] assert g.next() == 1 assert g.next() == 2 assert g.throw(NameError("Error")) == 3 raises(StopIteration, g.next) def test_throw5(self): def f(): try: yield 1 except: x = 3 try: yield x except: pass g = f() g.next() # String exceptions are not allowed anymore raises(TypeError, g.throw, "Error") assert g.throw(Exception) == 3 raises(StopIteration, g.throw, Exception) def test_throw6(self): def f(): yield 2 g = f() raises(NameError, g.throw, NameError, "Error", None) def test_throw_fail(self): def f(): yield 1 g = f() raises(TypeError, g.throw, NameError("Error"), "error") def test_throw_fail2(self): def f(): yield 1 g = f() raises(TypeError, g.throw, list()) def test_throw_fail3(self): def f(): yield 1 g = f() raises(TypeError, g.throw, NameError("Error"), None, "not tb object") def test_throw_finishes_generator(self): def f(): yield 1 g = f() assert g.gi_frame is not None raises(ValueError, g.throw, ValueError) assert g.gi_frame is None def test_throw_bug(self): def f(): try: x.throw(IndexError) # => "generator already executing" except ValueError: yield 1 x = f() res = list(x) assert res == [1] def test_throw_on_finished_generator(self): def f(): yield 1 g = f() res = g.next() assert res == 1 raises(StopIteration, g.next) raises(NameError, g.throw, NameError) def test_close(self): def f(): yield 1 g = f() assert g.close() is None def test_close2(self): def f(): try: yield 1 except GeneratorExit: raise StopIteration g = f() g.next() assert g.close() is None def test_close3(self): def f(): try: yield 1 except GeneratorExit: raise NameError g = f() g.next() raises(NameError, g.close) def test_close_fail(self): def f(): try: yield 1 except GeneratorExit: yield 2 g = f() g.next() raises(RuntimeError, g.close) def test_close_on_collect(self): ## we need to exec it, else it won't run on python2.4 d = {} exec """ def f(): try: yield finally: f.x = 42 """.strip() in d g = d['f']() g.next() del g import gc gc.collect() assert d['f'].x == 42 def test_generator_raises_typeerror(self): def f(): yield 1 g = f() raises(TypeError, g.send) # one argument required raises(TypeError, g.send, 1) # not started, must send None def test_generator_explicit_stopiteration(self): def f(): yield 1 raise StopIteration g = f() assert [x for x in g] == [1] def test_generator_propagate_stopiteration(self): def f(): it = iter([1]) while 1: yield it.next() g = f() assert [x for x in g] == [1] def test_generator_restart(self): def g(): i = me.next() yield i me = g() raises(ValueError, me.next) def test_generator_expression(self): exec "res = sum(i*i for i in range(5))" assert res == 30 def test_generator_expression_2(self): d = {} exec """ def f(): total = sum(i for i in [x for x in z]) return total, x z = [1, 2, 7] res = f() """ in d assert d['res'] == (10, 7) def test_repr(self): def myFunc(): yield 1 g = myFunc() r = repr(g) assert r.startswith("<generator object myFunc at 0x") assert list(g) == [1] assert repr(g) == r def test_unpackiterable_gen(self): g = (i*i for i in range(-5, 3)) assert set(g) == set([0, 1, 4, 9, 16, 25]) assert set(g) == set() assert set(i for i in range(0)) == set() def test_explicit_stop_iteration_unpackiterable(self): def f(): yield 1 raise StopIteration assert tuple(f()) == (1,) def test_exception_is_cleared_by_yield(self): def f(): try: foobar except NameError: yield 5 raise # should raise "no active exception to re-raise" gen = f() next(gen) # --> 5 try: next(gen) except TypeError: pass def test_multiple_invalid_sends(self): def mygen(): yield 42 g = mygen() raises(TypeError, g.send, 2) raises(TypeError, g.send, 2) def test_should_not_inline(space): from pypy.interpreter.generator import should_not_inline w_co = space.appexec([], '''(): def g(x): yield x + 5 return g.__code__ ''') assert should_not_inline(w_co) == False w_co = space.appexec([], '''(): def g(x): yield x + 5 yield x + 6 return g.__code__ ''') assert should_not_inline(w_co) == True

0a3711b515419fb6ad721023cf62fe24b0ba8280

py

Python

igvm/cli.py

innogames/igvm

6c4bd98d61ebaf6280698e74d560ea5b3d70cd9e

2018-02-15T14:09:54.000Z

2021-07-19T01:55:58.000Z

igvm/cli.py

innogames/igvm

6c4bd98d61ebaf6280698e74d560ea5b3d70cd9e

2018-02-19T09:47:18.000Z

2022-03-02T14:08:10.000Z

igvm/cli.py

innogames/igvm

6c4bd98d61ebaf6280698e74d560ea5b3d70cd9e

2018-02-16T15:56:59.000Z

2021-05-14T23:31:31.000Z

"""igvm - The command line interface Copyright (c) 2017 InnoGames GmbH """ from __future__ import print_function from argparse import ArgumentParser, _SubParsersAction from logging import StreamHandler, root as root_logger import time from fabric.network import disconnect_all from igvm.commands import ( change_address, disk_set, evacuate, host_info, mem_set, vcpu_set, vm_build, vm_delete, vm_migrate, vm_rename, vm_restart, vm_start, vm_stop, vm_sync, vm_define, ) from igvm.libvirt import close_virtconns class ColorFormatters(): BOLD = '\033[1m{}\033[0m' WARNING = '\033[1;33m{}\033[0m' ERROR = '\033[1;31m{}\033[0m' CRITICAL = '\033[1;41m{}\033[0m' class IGVMArgumentParser(ArgumentParser): def format_help(self): if not any(isinstance(a, _SubParsersAction) for a in self._actions): return super(IGVMArgumentParser, self).format_help() out = [] out.append(ColorFormatters.BOLD.format(__doc__)) out.append('Available commands:\n') subparsers_actions = [ action for action in self._actions if isinstance(action, _SubParsersAction) ] # There will probably only be one subparser_action, but better safe # than sorry. for subparsers_action in subparsers_actions: # Get all subparsers and print help for choice, subparser in subparsers_action.choices.items(): out.append(ColorFormatters.BOLD.format(choice)) if subparser.get_default('func').__doc__: out.append('\n'.join( '\t{}'.format(l.strip()) for l in subparser .get_default('func').__doc__.strip().splitlines() )) out.append('\n\t{}'.format(subparser.format_usage())) return '\n'.join(out) class IGVMLogHandler(StreamHandler): """Extend StreamHandler to format messages short-cutting Formatters""" def __init__(self, *args, **kwargs): super(IGVMLogHandler, self).__init__(*args, **kwargs) self.isatty = self.stream.isatty() def format(self, record): level = record.levelname msg = '{}: {}: {}'.format(level, record.name, record.getMessage()) if self.isatty and level in vars(ColorFormatters): msg = getattr(ColorFormatters, level).format(msg) return msg def parse_args(): top_parser = IGVMArgumentParser('igvm') top_parser.add_argument('--silent', '-s', action='count', default=0) top_parser.add_argument('--verbose', '-v', action='count', default=0) subparsers = top_parser.add_subparsers(help='Actions') subparser = subparsers.add_parser( 'build', description=vm_build.__doc__, ) subparser.set_defaults(func=vm_build) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( '--postboot', metavar='postboot_script', help='Run postboot_script on the guest after first boot', ) subparser.add_argument( '--skip-puppet', action='store_false', dest='run_puppet', help='Skip running puppet in chroot before powering up', ) subparser.add_argument( '--debug-puppet', action='store_true', help='Run puppet in debug mode', ) subparser.add_argument( '--ignore-reserved', dest='allow_reserved_hv', action='store_true', help='Allow building on a Host which has the state online_reserved', ) subparser.add_argument( '--rebuild', dest='rebuild', action='store_true', help='Rebuild already defined VM or build it if not defined', ) subparser.add_argument( '--soft-preferences', dest='soft_preferences', action='store_true', help='Overrules all preferences so that Hypervisors are not excluded. ' 'Use this if igvm fails to find a matching Hypervisor, but you ' 'are in urgent need to do it anyway. Hint: If igvm fails to find ' 'a matching Hypervisor something might be really wrong. Run igvm ' 'with --verbose to check why it fails finding a Hypervisor.', ) subparser = subparsers.add_parser( 'migrate', description=vm_migrate.__doc__, ) subparser.set_defaults(func=vm_migrate) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( 'hypervisor_hostname', nargs='?', default=None, help='Hostname of destination hypervisor', ) subparser.add_argument( '--run-puppet', action='store_true', help='Run puppet in chroot before powering up', ) subparser.add_argument( '--debug-puppet', action='store_true', help='Run puppet in debug mode', ) subparser.add_argument( '--offline', action='store_true', help='Force offline migration', ) subparser.add_argument( '--ignore-reserved', dest='allow_reserved_hv', action='store_true', help='Allow migration to a Host which has the state online_reserved', ) subparser.add_argument( '--offline-transport', default='drbd', choices=('drbd', 'netcat', 'xfs'), help=( 'Specify drbd (default), netcat or xfs transport to migrate ' 'disk image' ), ) subparser.add_argument( '--no-shutdown', action='store_true', help=( 'Don\'t shutdown VM during offline migration, igvm will wait for' ' operator to shut down VM for 24h.' ), ) subparser.add_argument( '--enforce-vm-env', dest='enforce_vm_env', action='store_true', help='Build or migrate VM only to a HV with the same environment of VM' ) subparser.add_argument( '--disk-size', dest='disk_size', type=int, help='Resize disk of migrated VM. Expects new size in GiB. ' 'Works only with --offline --offline-transport=xfs', ) subparser.add_argument( '--soft-preferences', dest='soft_preferences', action='store_true', help='Overrules all preferences so that Hypervisors are not excluded. ' 'Use this if igvm fails to find a matching Hypervisor, but you ' 'are in urgent need to do it anyway. Hint: If igvm fails to find ' 'a matching Hypervisor something might be really wrong. Run igvm ' 'with --verbose to check why it fails finding a Hypervisor.', ) subparser = subparsers.add_parser( 'change-address', description=disk_set.__doc__, ) subparser.set_defaults(func=change_address) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( 'new_address', help=( 'New IPv4 address of VM' ) ) subparser.add_argument( '--offline', action='store_true', help='Perform IP address change offline', ) subparser.add_argument( '--migrate', action='store_true', help='Migrate VM to new HV while changing IP address', ) subparser.add_argument( '--ignore-reserved', dest='allow_reserved_hv', action='store_true', help='Allow migration to a Host which has the state online_reserved', ) subparser.add_argument( '--offline-transport', default='drbd', help=( 'Specify drbd (default) or netcat transport to migrate disk image' ), ) subparser = subparsers.add_parser( 'disk-set', description=disk_set.__doc__, ) subparser.set_defaults(func=disk_set) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( 'size', help=( 'New disk size with an optional unit (default GiB). ' 'Can be specified relative with "+". Only integers are allowed' ) ) subparser = subparsers.add_parser( 'mem-set', description=mem_set.__doc__, ) subparser.set_defaults(func=mem_set) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( 'size', help=( 'New memory size with optional unit (default is MiB).' 'Only integers are allowed.' ), ) subparser.add_argument( '--offline', action='store_true', help='Shutdown VM, change memory, and restart VM', ) subparser = subparsers.add_parser( 'vcpu-set', description=vcpu_set.__doc__, ) subparser.set_defaults(func=vcpu_set) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( 'count', type=int, help='New number of CPUs', ) subparser.add_argument( '--offline', action='store_true', help='Shutdown VM, change CPUs, and restart VM', ) subparser = subparsers.add_parser( 'start', description=vm_start.__doc__, ) subparser.set_defaults(func=vm_start) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( '--unretire', nargs='?', const='maintenance', help='Unretire a VM, set it to given state, maintenance by default', ) subparser = subparsers.add_parser( 'stop', description=vm_stop.__doc__, ) subparser.set_defaults(func=vm_stop) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( '--force', action='store_true', help='Do not wait for guest to shutdown gracefully', ) subparser.add_argument( '--retire', action='store_true', help='Retire VM after stopping it', ) subparser = subparsers.add_parser( 'restart', description=vm_restart.__doc__, ) subparser.set_defaults(func=vm_restart) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( '--force', action='store_true', help='Do not wait for guest to shutdown gracefully', ) subparser.add_argument( '--no-redefine', action='store_true', help='Do not redefine the domain to use latest hypervisor settings', ) subparser = subparsers.add_parser( 'delete', description=vm_delete.__doc__, ) subparser.set_defaults(func=vm_delete) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( '--retire', action='store_true', help='Set VM state to "retired" on Serveradmin instead of deleting', ) subparser = subparsers.add_parser( 'info', description=host_info.__doc__, ) subparser.set_defaults(func=host_info) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser = subparsers.add_parser( 'sync', description=vm_sync.__doc__, ) subparser.set_defaults(func=vm_sync) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser = subparsers.add_parser( 'rename', description=vm_rename.__doc__, ) subparser.set_defaults(func=vm_rename) subparser.add_argument( 'vm_hostname', help='Hostname of the guest system', ) subparser.add_argument( 'new_hostname', help='New hostname', ) subparser.add_argument( '--offline', action='store_true', help='Shutdown VM, if running', ) subparser = subparsers.add_parser( 'evacuate', description=evacuate.__doc__, ) subparser.set_defaults(func=evacuate) subparser.add_argument( 'hv_hostname', help='Hostname of the hypervisor', ) subparser.add_argument( 'dst_hv_hostname', nargs='?', default=None, help='Hostname of destination hypervisor', ) subparser.add_argument( '--dry-run', action='store_true', help='Do not migrate but just print what would be done' ) subparser.add_argument( '--offline', nargs='*', help='Migrate VMs matching the given serveradmin function offline', ) subparser.add_argument( '--ignore-reserved', dest='allow_reserved_hv', action='store_true', help='Allow migrating to a host which has the state online_reserved', ) subparser.add_argument( '--soft-preferences', dest='soft_preferences', action='store_true', help='Overrules all preferences so that Hypervisors are not excluded. ' 'Use this if igvm fails to find a matching Hypervisor, but you ' 'are in urgent need to do it anyway. Hint: If igvm fails to find ' 'a matching Hypervisor something might be really wrong. Run igvm ' 'with --verbose to check why it fails finding a Hypervisor.', ) subparser = subparsers.add_parser( 'define', description=vm_define.__doc__, ) subparser.set_defaults(func=vm_define) subparser.add_argument('vm_hostname', help='Hostname of the guest system') return vars(top_parser.parse_args()) def main(): args = parse_args() configure_root_logger(args.pop('silent'), args.pop('verbose')) try: args.pop('func')(**args) finally: # Fabric requires the disconnect function to be called after every # use. We are also taking our chance to disconnect from # the hypervisors. disconnect_all() close_virtconns() # The underlying library of Fabric, Paramiko, raises an error, on # destruction right after the disconnect function is called. We are # sleeping for a little while to avoid this. time.sleep(0.1) def configure_root_logger(silent, verbose): root_logger.addHandler(IGVMLogHandler()) # We are summing up the silent and verbose arguments in here. It # is not really meaningful to use them both, but giving an error is not # better. See Python logging library documentation [1] for the levels. # Paramiko is overly verbose. We configure it for one level higher. # # [1] https://docs.python.org/library/logging.html#logging-levels level = 20 + (silent - verbose) * 10 root_logger.setLevel(level) root_logger.getChild('paramiko').setLevel(level + 10)

0a390498151447698302dd1d056f6ca3842fd3c6

py

Python

test/test_data_processor/test_condition_generation_dataset.py

puraminy/OpenPrompt

49f0ed9719bb6285e94c746de4511991c848492c

2021-09-30T15:32:58.000Z

2022-03-31T11:23:03.000Z

test/test_data_processor/test_condition_generation_dataset.py

Spritebai/OpenPrompt

bd9ea544ab144d94af32d245101ba35c9d5a5a65

2021-10-01T07:56:33.000Z

2022-03-31T14:39:09.000Z

test/test_data_processor/test_condition_generation_dataset.py

Spritebai/OpenPrompt

bd9ea544ab144d94af32d245101ba35c9d5a5a65

2021-09-30T16:09:53.000Z

2022-03-31T09:39:34.000Z

import os, sys from os.path import dirname as d from os.path import abspath, join root_dir = d(d(d(abspath(__file__)))) sys.path.append(root_dir) from openprompt.data_utils.conditional_generation_dataset import PROCESSORS base_path = os.path.join(root_dir, "datasets/CondGen") def test_WebNLGProcessor(): dataset_name = "webnlg_2017" dataset_path = os.path.join(base_path, dataset_name) processor = PROCESSORS[dataset_name.lower()]() train_dataset = processor.get_train_examples(dataset_path) valid_dataset = processor.get_train_examples(dataset_path) test_dataset = processor.get_test_examples(dataset_path) assert len(train_dataset) == 18025 assert len(valid_dataset) == 18025 assert len(test_dataset) == 4928 assert test_dataset[0].text_a == " | Abilene_Regional_Airport : cityServed : Abilene,_Texas" assert test_dataset[0].text_b == "" assert test_dataset[0].tgt_text == "Abilene, Texas is served by the Abilene regional airport."

0a393fec60ca724f475a9fdf13a20c1df07768c4

py

Python

BaseTools/Source/Python/Common/BuildToolError.py

JayLeeCompal/EDKII_Git

de4800d50e1f357002bf77235d3bebabd0c00007

2022-01-20T04:51:29.000Z

2022-01-20T04:51:29.000Z

BaseTools/Source/Python/Common/BuildToolError.py

JayLeeCompal/EDKII_Git

de4800d50e1f357002bf77235d3bebabd0c00007

2022-01-21T06:19:02.000Z

2022-01-21T06:19:02.000Z

BaseTools/Source/Python/Common/BuildToolError.py

JayLeeCompal/EDKII_Git

de4800d50e1f357002bf77235d3bebabd0c00007

## @file # Standardized Error Hanlding infrastructures. # # Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR> # This program and the accompanying materials # are licensed and made available under the terms and conditions of the BSD License # which accompanies this distribution. The full text of the license may be found at # http://opensource.org/licenses/bsd-license.php # # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. # FILE_OPEN_FAILURE = 1 FILE_WRITE_FAILURE = 2 FILE_PARSE_FAILURE = 3 FILE_READ_FAILURE = 4 FILE_CREATE_FAILURE = 5 FILE_CHECKSUM_FAILURE = 6 FILE_COMPRESS_FAILURE = 7 FILE_DECOMPRESS_FAILURE = 8 FILE_MOVE_FAILURE = 9 FILE_DELETE_FAILURE = 10 FILE_COPY_FAILURE = 11 FILE_POSITIONING_FAILURE = 12 FILE_ALREADY_EXIST = 13 FILE_NOT_FOUND = 14 FILE_TYPE_MISMATCH = 15 FILE_CASE_MISMATCH = 16 FILE_DUPLICATED = 17 FILE_UNKNOWN_ERROR = 0x0FFF OPTION_UNKNOWN = 0x1000 OPTION_MISSING = 0x1001 OPTION_CONFLICT = 0x1002 OPTION_VALUE_INVALID = 0x1003 OPTION_DEPRECATED = 0x1004 OPTION_NOT_SUPPORTED = 0x1005 OPTION_UNKNOWN_ERROR = 0x1FFF PARAMETER_INVALID = 0x2000 PARAMETER_MISSING = 0x2001 PARAMETER_UNKNOWN_ERROR =0x2FFF FORMAT_INVALID = 0x3000 FORMAT_NOT_SUPPORTED = 0x3001 FORMAT_UNKNOWN = 0x3002 FORMAT_UNKNOWN_ERROR = 0x3FFF RESOURCE_NOT_AVAILABLE = 0x4000 RESOURCE_ALLOCATE_FAILURE = 0x4001 RESOURCE_FULL = 0x4002 RESOURCE_OVERFLOW = 0x4003 RESOURCE_UNDERRUN = 0x4004 RESOURCE_UNKNOWN_ERROR = 0x4FFF ATTRIBUTE_NOT_AVAILABLE = 0x5000 ATTRIBUTE_GET_FAILURE = 0x5001 ATTRIBUTE_SET_FAILURE = 0x5002 ATTRIBUTE_UPDATE_FAILURE = 0x5003 ATTRIBUTE_ACCESS_DENIED = 0x5004 ATTRIBUTE_UNKNOWN_ERROR = 0x5FFF IO_NOT_READY = 0x6000 IO_BUSY = 0x6001 IO_TIMEOUT = 0x6002 IO_UNKNOWN_ERROR = 0x6FFF COMMAND_FAILURE = 0x7000 PERMISSION_FAILURE = 0x8000 CODE_ERROR = 0xC0DE AUTOGEN_ERROR = 0xF000 PARSER_ERROR = 0xF001 BUILD_ERROR = 0xF002 GENFDS_ERROR = 0xF003 ECC_ERROR = 0xF004 EOT_ERROR = 0xF005 DDC_ERROR = 0xF009 WARNING_AS_ERROR = 0xF006 MIGRATION_ERROR = 0xF010 PCD_VALIDATION_INFO_ERROR = 0xF011 PCD_VARIABLE_ATTRIBUTES_ERROR = 0xF012 PCD_VARIABLE_ATTRIBUTES_CONFLICT_ERROR = 0xF013 ABORT_ERROR = 0xFFFE UNKNOWN_ERROR = 0xFFFF ## Error message of each error code gErrorMessage = { FILE_NOT_FOUND : "File/directory not found in workspace", FILE_OPEN_FAILURE : "File open failure", FILE_WRITE_FAILURE : "File write failure", FILE_PARSE_FAILURE : "File parse failure", FILE_READ_FAILURE : "File read failure", FILE_CREATE_FAILURE : "File create failure", FILE_CHECKSUM_FAILURE : "Invalid checksum of file", FILE_COMPRESS_FAILURE : "File compress failure", FILE_DECOMPRESS_FAILURE : "File decompress failure", FILE_MOVE_FAILURE : "File move failure", FILE_DELETE_FAILURE : "File delete failure", FILE_COPY_FAILURE : "File copy failure", FILE_POSITIONING_FAILURE: "Failed to seeking position", FILE_ALREADY_EXIST : "File or directory already exists", FILE_TYPE_MISMATCH : "Incorrect file type", FILE_CASE_MISMATCH : "File name case mismatch", FILE_DUPLICATED : "Duplicated file found", FILE_UNKNOWN_ERROR : "Unknown error encountered on file", OPTION_UNKNOWN : "Unknown option", OPTION_MISSING : "Missing option", OPTION_CONFLICT : "Conflict options", OPTION_VALUE_INVALID : "Invalid value of option", OPTION_DEPRECATED : "Deprecated option", OPTION_NOT_SUPPORTED : "Unsupported option", OPTION_UNKNOWN_ERROR : "Unknown error when processing options", PARAMETER_INVALID : "Invalid parameter", PARAMETER_MISSING : "Missing parameter", PARAMETER_UNKNOWN_ERROR : "Unknown error in parameters", FORMAT_INVALID : "Invalid syntax/format", FORMAT_NOT_SUPPORTED : "Not supported syntax/format", FORMAT_UNKNOWN : "Unknown format", FORMAT_UNKNOWN_ERROR : "Unknown error in syntax/format ", RESOURCE_NOT_AVAILABLE : "Not available", RESOURCE_ALLOCATE_FAILURE : "Allocate failure", RESOURCE_FULL : "Full", RESOURCE_OVERFLOW : "Overflow", RESOURCE_UNDERRUN : "Underrun", RESOURCE_UNKNOWN_ERROR : "Unknown error", ATTRIBUTE_NOT_AVAILABLE : "Not available", ATTRIBUTE_GET_FAILURE : "Failed to retrieve", ATTRIBUTE_SET_FAILURE : "Failed to set", ATTRIBUTE_UPDATE_FAILURE: "Failed to update", ATTRIBUTE_ACCESS_DENIED : "Access denied", ATTRIBUTE_UNKNOWN_ERROR : "Unknown error when accessing", COMMAND_FAILURE : "Failed to execute command", IO_NOT_READY : "Not ready", IO_BUSY : "Busy", IO_TIMEOUT : "Timeout", IO_UNKNOWN_ERROR : "Unknown error in IO operation", UNKNOWN_ERROR : "Unknown error", } ## Exception indicating a fatal error class FatalError(Exception): pass if __name__ == "__main__": pass

0a3943aef4b92eda2997e8228a72ccdd4b255c3d

py

Python

datasets/SUN397EncodbleDataset.py

allenai/ViRB

fbe1c42571ce0994b1e41bc4bdf88cf9658ae48b

2021-05-19T13:49:53.000Z

2022-02-10T16:33:47.000Z

datasets/SUN397EncodbleDataset.py

allenai/ViRB

fbe1c42571ce0994b1e41bc4bdf88cf9658ae48b

datasets/SUN397EncodbleDataset.py

allenai/ViRB

fbe1c42571ce0994b1e41bc4bdf88cf9658ae48b

2021-06-07T02:55:30.000Z

2021-06-07T02:55:30.000Z

import torch import torchvision.transforms as transforms from torch.utils.data import Dataset import glob from PIL import Image import random class SUN397EncodableDataset(Dataset): """SUN397 encodable dataset class""" def __init__(self, train=True): super().__init__() path = 'data/SUN397/train/*/*.jpg' if train else 'data/SUN397/test/*/*.jpg' self.data = list(glob.glob(path)) random.shuffle(self.data) cats = list(set([path.split("/")[3] for path in self.data])) cats.sort() self.labels = torch.LongTensor([cats.index(path.split("/")[3]) for path in self.data]) self.preprocessor = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") def __getitem__(self, idx): if torch.is_tensor(idx): idx = idx.tolist() if len(self.encoded_data) == 0: return self.preprocessor(Image.open(self.data[idx]).convert('RGB')), self.labels[idx] return self.encoded_data[idx], self.labels[idx] def __len__(self): return len(self.labels) def num_classes(self): return int(max(self.labels) + 1)

0a3a46f51a8f874a867b535822da740830faf6e6

py

Python

cybox/common/location.py

tirkarthi/python-cybox

a378deb68b3ac56360c5cc35ff5aad1cd3dcab83

2015-03-05T18:22:51.000Z

2022-03-06T07:29:25.000Z

cybox/common/location.py

tirkarthi/python-cybox

a378deb68b3ac56360c5cc35ff5aad1cd3dcab83

2015-01-12T18:52:20.000Z

2021-04-25T22:57:52.000Z

cybox/common/location.py

tirkarthi/python-cybox

a378deb68b3ac56360c5cc35ff5aad1cd3dcab83

2015-03-25T07:24:40.000Z

2021-07-23T17:10:11.000Z

# Copyright (c) 2017, The MITRE Corporation. All rights reserved. # See LICENSE.txt for complete terms. from mixbox import entities, fields import cybox import cybox.bindings.cybox_common as common_binding class LocationFactory(entities.EntityFactory): @classmethod def entity_class(cls, key): return cybox.lookup_extension(key, default=Location) class Location(entities.Entity): _binding = common_binding _binding_class = common_binding.LocationType _namespace = 'http://cybox.mitre.org/common-2' _XSI_TYPE = None # overridden by subclasses id_ = fields.IdrefField("id") idref = fields.IdrefField("idref") name = fields.TypedField("Name") def to_dict(self): d = super(Location, self).to_dict() if self._XSI_TYPE: d["xsi:type"] = self._XSI_TYPE return d @staticmethod def lookup_class(xsi_type): return cybox.lookup_extension(xsi_type, default=Location)

0a3be6996ac9517d3022400855065d32ff7ed3c0

py

Python

scripts/bam-stats.py

varlociraptor/prosic-evaluation

f4f1950ba5c10bda0f41df2a8f519d98f779d736

2020-04-29T00:56:09.000Z

2021-03-07T19:59:06.000Z

scripts/bam-stats.py

varlociraptor/prosic-evaluation

f4f1950ba5c10bda0f41df2a8f519d98f779d736

scripts/bam-stats.py

varlociraptor/prosic-evaluation

f4f1950ba5c10bda0f41df2a8f519d98f779d736

2022-03-15T12:23:03.000Z

2022-03-15T12:23:03.000Z

#!/usr/bin/env python import sys import numpy as np import pandas as pd import pysam import matplotlib matplotlib.use("agg") import matplotlib.pyplot as plt import seaborn as sns from functools import partial tumor = pysam.AlignmentFile(snakemake.input[0], "rb") normal = pysam.AlignmentFile(snakemake.input[1], "rb") softclips = [] for i, rec in enumerate(normal): if rec.is_supplementary or rec.is_unmapped: continue is_first_read = rec.pos < rec.mpos get_clip = lambda c: c[1] if c[0] == 4 else None clip_left = get_clip(rec.cigartuples[0]) if clip_left is not None: softclips.append([clip_left, True, is_first_read]) clip_right = get_clip(rec.cigartuples[-1]) if clip_right is not None: softclips.append([clip_right, False, is_first_read]) if i == 10000000: break softclips = pd.DataFrame(softclips, columns=["len", "left", "first_in_pair"]) def plot(*args, **kwargs): softclips = args[0] plt.hist(softclips, normed=True) q95 = np.percentile(softclips, 99) plt.plot([q95, q95], [0, 1.0], "--k") m = max(softclips) plt.plot([m, m], [0, 1.0], ":k") plt.text(m, 1, "max={}".format(m), horizontalalignment="right", verticalalignment="top") g = sns.FacetGrid(softclips, col="left", row="first_in_pair") g = g.map(plot, "len") plt.savefig(snakemake.output[0])

0a3bec6c960ec5a80b8e4e32d4669b80255b605f

py

Python

app/rss_feeder_api/migrations/0003_auto_20200813_1623.py

RSaab/rss-scraper

9bf608878e7d08fea6508ae90b27f1c226b313f1

app/rss_feeder_api/migrations/0003_auto_20200813_1623.py

RSaab/rss-scraper

9bf608878e7d08fea6508ae90b27f1c226b313f1

app/rss_feeder_api/migrations/0003_auto_20200813_1623.py

RSaab/rss-scraper

9bf608878e7d08fea6508ae90b27f1c226b313f1

# Generated by Django 3.1 on 2020-08-13 16:23 from django.db import migrations, models import django.utils.timezone class Migration(migrations.Migration): dependencies = [ ('rss_feeder_api', '0002_feed_subtitle'), ] operations = [ migrations.AlterModelOptions( name='entry', options={'ordering': ('-updated_at',), 'verbose_name_plural': 'entries'}, ), migrations.AlterModelOptions( name='feed', options={'ordering': ('-updated_at',), 'verbose_name': 'Feed', 'verbose_name_plural': 'Feeds'}, ), migrations.AddField( model_name='entry', name='created_at', field=models.DateTimeField(auto_now_add=True, default=django.utils.timezone.now), preserve_default=False, ), migrations.AddField( model_name='entry', name='updated_at', field=models.DateTimeField(auto_now=True), ), migrations.AlterUniqueTogether( name='entry', unique_together={('guid',)}, ), ]

0a3c1af48960fabf760e667011b0450023e75e10

py

Python

AdversarialSampleGeneratorV11/AdversarialSampleGeneratorV11/ResNetConstructor.py

MetaMain/BewareAdvML

52d489b565b0df36cb588b5709c29c2e8e4d3f49

2022-03-25T07:53:13.000Z

2022-03-25T07:53:13.000Z

AdversarialSampleGeneratorV11/AdversarialSampleGeneratorV11/ResNetConstructor.py

MetaMain/BewareAdvML

52d489b565b0df36cb588b5709c29c2e8e4d3f49

AdversarialSampleGeneratorV11/AdversarialSampleGeneratorV11/ResNetConstructor.py

MetaMain/BewareAdvML

52d489b565b0df36cb588b5709c29c2e8e4d3f49

import tensorflow from tensorflow import keras Model = keras.models.Model Dense = keras.layers.Dense Activation = keras.layers.Activation Flatten = keras.layers.Flatten BatchNormalization= keras.layers.BatchNormalization Conv2D = tensorflow.keras.layers.Conv2D AveragePooling2D = keras.layers.AveragePooling2D Input=keras.layers.Input l2=keras.regularizers.l2 from tensorflow.keras import backend def resnet_layer(inputs, num_filters=16, kernel_size=3, strides=1, activation='relu', batch_normalization=True, conv_first=True): """2D Convolution-Batch Normalization-Activation stack builder # Arguments inputs (tensor): input tensor from input image or previous layer num_filters (int): Conv2D number of filters kernel_size (int): Conv2D square kernel dimensions strides (int): Conv2D square stride dimensions activation (string): activation name batch_normalization (bool): whether to include batch normalization conv_first (bool): conv-bn-activation (True) or bn-activation-conv (False) # Returns x (tensor): tensor as input to the next layer """ conv = Conv2D( num_filters, kernel_size=kernel_size, strides=strides, padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4)) x = inputs if conv_first: x = conv(x) if batch_normalization: x = BatchNormalization()(x) if activation is not None: x = Activation(activation)(x) else: if batch_normalization: x = BatchNormalization()(x) if activation is not None: x = Activation(activation)(x) x = conv(x) return x def resnet_v2(input, complexityParameter, num_classes=10, dataset='cifar10'): depth = complexityParameter * 9 + 2 if (depth - 2) % 9 != 0: raise ValueError('depth should be 9n+2 (eg 56 or 110 in [b])') # Start model definition. num_filters_in = 16 num_res_blocks = int((depth - 2) / 9) inputs = input x = resnet_layer(inputs=inputs, num_filters=num_filters_in, conv_first=True) # Instantiate the stack of residual units for stage in range(3): for res_block in range(num_res_blocks): activation = 'relu' batch_normalization = True strides = 1 if stage == 0: num_filters_out = num_filters_in * 4 if res_block == 0: # first layer and first stage activation = None batch_normalization = False else: num_filters_out = num_filters_in * 2 if res_block == 0: # first layer but not first stage strides = 2 # downsample # bottleneck residual unit y = resnet_layer(inputs=x, num_filters=num_filters_in, kernel_size=1, strides=strides, activation=activation, batch_normalization=batch_normalization, conv_first=False) y = resnet_layer(inputs=y, num_filters=num_filters_in, conv_first=False) y = resnet_layer(inputs=y, num_filters=num_filters_out, kernel_size=1, conv_first=False) if res_block == 0: # linear projection residual shortcut connection to match # changed dims x = resnet_layer(inputs=x, num_filters=num_filters_out, kernel_size=1, strides=strides, activation=None, batch_normalization=False) x = tensorflow.keras.layers.add([x, y]) num_filters_in = num_filters_out # Add classifier on top. # v2 has BN-ReLU before Pooling x = BatchNormalization()(x) x = Activation('relu')(x) x = AveragePooling2D(pool_size=8)(x) final_features = Flatten()(x) logits = Dense(num_classes, kernel_initializer='he_normal')(final_features) outputs = Activation('softmax')(logits) # Instantiate model. model = Model(inputs=inputs, outputs=outputs) return model, inputs, outputs, logits, final_features

0a3cda3b610042fefd30969a702f9d925c74876f

py

Python

ttl2json.py

the-norman-sicily-project/genealogical-trees

32fa4f25861ae34543b0a6b95e54842c0018331b

2021-05-18T20:39:30.000Z

2021-05-18T20:39:30.000Z

ttl2json.py

the-norman-sicily-project/genealogical-trees

32fa4f25861ae34543b0a6b95e54842c0018331b

ttl2json.py

the-norman-sicily-project/genealogical-trees

32fa4f25861ae34543b0a6b95e54842c0018331b

#!/usr/bin/env python3 import sys import json import rdflib import rdflib.plugins.sparql as sparql RELS_TO_DRAW = ['isWifeOf', 'isMotherOf', 'isFatherOf', 'isHusbandOf', 'isSpouseOf'] RELS_TO_INFER = ['hasGrandParent', 'isGrandParentOf', 'hasGreatGrandParent', 'isGreatGrandParentOf', 'isUncleOf', 'hasUncle', 'isGreatUncleOf', 'hasGreatUncle', 'isAuntOf', 'hasAunt', 'isGreatAuntOf', 'hasGreatAunt', 'isBrotherOf', 'isSisterOf', 'isSiblingOf', 'isFirstCousinOf', 'isSecondCousinOf', 'isThirdCousinOf'] RELS_OF_INTEREST = RELS_TO_DRAW + RELS_TO_INFER try: workpath = sys.argv[1] except IndexError: sys.exit("No path defined!") try: recursion_limit = int(sys.argv[2]) except IndexError: recursion_limit = 0 if recursion_limit > 0: sys.setrecursionlimit(recursion_limit) g = rdflib.Graph() g.parse(workpath, format="turtle") fhkb_str = "http://www.example.com/genealogy.owl#" schema_str = "https://schema.org/" FHKB = rdflib.Namespace(fhkb_str) SCHEMA_ORG = rdflib.Namespace(schema_str) def dump(uriref): if uriref.__contains__('#'): return uriref.split('#')[-1] return uriref.split('/')[-1] graph = {} graph['nodes'] = [] graph['edges'] = [] nodes = {} q = sparql.prepareQuery( """PREFIX fhkb:<http://www.example.com/genealogy.owl#> SELECT ?person ?pred ?obj WHERE { ?person a fhkb:Person ; ?pred ?obj . } ORDER BY ?person""") for rel in RELS_OF_INTEREST: pred = rdflib.URIRef("{}{}".format(fhkb_str, rel)) relation_query_results = g.query(q, initBindings={'pred': pred}) for (subj, pred, obj) in relation_query_results: graph['edges'].append( { 'data': { 'group': 'edges', 'id': f'{dump(subj)}-{dump(pred)}-{dump(obj)}', 'source': dump(subj), 'target': dump(obj), 'type': dump(pred) } }) q_details = sparql.prepareQuery( """PREFIX fhkb:<http://www.example.com/genealogy.owl#> SELECT ?person ?pred ?obj WHERE { ?person a fhkb:Person ; ?pred ?obj . FILTER NOT EXISTS { ?person ?testPred ?obj . VALUES ?testPred { fhkb:isWifeOf fhkb:isMotherOf fhkb:isFatherOf fhkb:isHusbandOf fhkb:isSpouseOf fhkb:hasGrandParent fhkb:isGrandParentOf fhkb:hasGreatGrandParent fhkb:isGreatGrandParentOf fhkb:isUncleOf fhkb:hasUncle fhkb:isGreatUncleOf fhkb:hasGreatUncle fhkb:isAuntOf fhkb:hasAunt fhkb:isGreatAuntOf fhkb:hasGreatAunt fhkb:isBrotherOf fhkb:isSisterOf fhkb:isSiblingOf fhkb:isFirstCousinOf fhkb:isSecondCousinOf fhkb:isThirdCousinOf fhkb:hasRelation fhkb:isPartnerIn fhkb:isMalePartnerIn fhkb:isFemalePartnerIn fhkb:isBloodrelationOf } } } ORDER BY ?person""" ) person_query_results = g.query(q_details) for (subj, pred, obj) in person_query_results: node = nodes.get(dump(subj), { 'data': { 'label': '', 'degree': 0, 'size': 10, 'alternateNames': [], 'honorificPrefixes': [], 'honorificSuffixes': [], 'images': [], 'id': dump(subj), }}) if pred == FHKB.Sex: node['data'][dump(pred)] = dump(obj) elif pred.startswith(SCHEMA_ORG): if dump(pred) == 'honorificSuffix': node['data']['honorificSuffixes'].append(obj) elif dump(pred) == 'honorificPrefix': node['data']['honorificPrefixes'].append(obj) elif dump(pred) == 'alternateName': node['data']['alternateNames'].append(obj) elif dump(pred) == 'image': node['data']['images'].append(obj) else: node['data'][dump(pred)] = obj elif pred == rdflib.RDFS.label: node['data']['label'] = obj else: continue nodes[dump(subj)] = node graph['nodes'] = list(nodes.values()) print(json.dumps(graph, indent=0)) sys.exit(0)

0a3d017dc9b9c85df909d024333ec6af657c45e5

py

Python

tests/rest/client/test_login.py

BearerPipelineTest/synapse-1

78b99de7c206b106340e12cdee0af9aa246bd5ad

tests/rest/client/test_login.py

BearerPipelineTest/synapse-1

78b99de7c206b106340e12cdee0af9aa246bd5ad

tests/rest/client/test_login.py

BearerPipelineTest/synapse-1

78b99de7c206b106340e12cdee0af9aa246bd5ad

# Copyright 2019-2021 The Matrix.org Foundation C.I.C. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import json import time import urllib.parse from typing import Any, Dict, List, Optional, Union from unittest.mock import Mock from urllib.parse import urlencode import pymacaroons from twisted.test.proto_helpers import MemoryReactor from twisted.web.resource import Resource import synapse.rest.admin from synapse.appservice import ApplicationService from synapse.rest.client import devices, login, logout, register from synapse.rest.client.account import WhoamiRestServlet from synapse.rest.synapse.client import build_synapse_client_resource_tree from synapse.server import HomeServer from synapse.types import create_requester from synapse.util import Clock from tests import unittest from tests.handlers.test_oidc import HAS_OIDC from tests.handlers.test_saml import has_saml2 from tests.rest.client.utils import TEST_OIDC_AUTH_ENDPOINT, TEST_OIDC_CONFIG from tests.server import FakeChannel from tests.test_utils.html_parsers import TestHtmlParser from tests.unittest import HomeserverTestCase, override_config, skip_unless try: import jwt HAS_JWT = True except ImportError: HAS_JWT = False # synapse server name: used to populate public_baseurl in some tests SYNAPSE_SERVER_PUBLIC_HOSTNAME = "synapse" # public_baseurl for some tests. It uses an http:// scheme because # FakeChannel.isSecure() returns False, so synapse will see the requested uri as # http://..., so using http in the public_baseurl stops Synapse trying to redirect to # https://.... BASE_URL = "http://%s/" % (SYNAPSE_SERVER_PUBLIC_HOSTNAME,) # CAS server used in some tests CAS_SERVER = "https://fake.test" # just enough to tell pysaml2 where to redirect to SAML_SERVER = "https://test.saml.server/idp/sso" TEST_SAML_METADATA = """ <md:EntityDescriptor xmlns:md="urn:oasis:names:tc:SAML:2.0:metadata"> <md:IDPSSODescriptor protocolSupportEnumeration="urn:oasis:names:tc:SAML:2.0:protocol"> <md:SingleSignOnService Binding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect" Location="%(SAML_SERVER)s"/> </md:IDPSSODescriptor> </md:EntityDescriptor> """ % { "SAML_SERVER": SAML_SERVER, } LOGIN_URL = b"/_matrix/client/r0/login" TEST_URL = b"/_matrix/client/r0/account/whoami" # a (valid) url with some annoying characters in. %3D is =, %26 is &, %2B is + TEST_CLIENT_REDIRECT_URL = 'https://x?<ab c>&q"+%3D%2B"="fö%26=o"' # the query params in TEST_CLIENT_REDIRECT_URL EXPECTED_CLIENT_REDIRECT_URL_PARAMS = [("<ab c>", ""), ('q" =+"', '"fö&=o"')] # (possibly experimental) login flows we expect to appear in the list after the normal # ones ADDITIONAL_LOGIN_FLOWS = [ {"type": "m.login.application_service"}, {"type": "uk.half-shot.msc2778.login.application_service"}, ] class LoginRestServletTestCase(unittest.HomeserverTestCase): servlets = [ synapse.rest.admin.register_servlets_for_client_rest_resource, login.register_servlets, logout.register_servlets, devices.register_servlets, lambda hs, http_server: WhoamiRestServlet(hs).register(http_server), ] def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: self.hs = self.setup_test_homeserver() self.hs.config.registration.enable_registration = True self.hs.config.registration.registrations_require_3pid = [] self.hs.config.registration.auto_join_rooms = [] self.hs.config.captcha.enable_registration_captcha = False return self.hs @override_config( { "rc_login": { "address": {"per_second": 0.17, "burst_count": 5}, # Prevent the account login ratelimiter from raising first # # This is normally covered by the default test homeserver config # which sets these values to 10000, but as we're overriding the entire # rc_login dict here, we need to set this manually as well "account": {"per_second": 10000, "burst_count": 10000}, } } ) def test_POST_ratelimiting_per_address(self) -> None: # Create different users so we're sure not to be bothered by the per-user # ratelimiter. for i in range(0, 6): self.register_user("kermit" + str(i), "monkey") for i in range(0, 6): params = { "type": "m.login.password", "identifier": {"type": "m.id.user", "user": "kermit" + str(i)}, "password": "monkey", } channel = self.make_request(b"POST", LOGIN_URL, params) if i == 5: self.assertEqual(channel.result["code"], b"429", channel.result) retry_after_ms = int(channel.json_body["retry_after_ms"]) else: self.assertEqual(channel.result["code"], b"200", channel.result) # Since we're ratelimiting at 1 request/min, retry_after_ms should be lower # than 1min. self.assertTrue(retry_after_ms < 6000) self.reactor.advance(retry_after_ms / 1000.0 + 1.0) params = { "type": "m.login.password", "identifier": {"type": "m.id.user", "user": "kermit" + str(i)}, "password": "monkey", } channel = self.make_request(b"POST", LOGIN_URL, params) self.assertEqual(channel.result["code"], b"200", channel.result) @override_config( { "rc_login": { "account": {"per_second": 0.17, "burst_count": 5}, # Prevent the address login ratelimiter from raising first # # This is normally covered by the default test homeserver config # which sets these values to 10000, but as we're overriding the entire # rc_login dict here, we need to set this manually as well "address": {"per_second": 10000, "burst_count": 10000}, } } ) def test_POST_ratelimiting_per_account(self) -> None: self.register_user("kermit", "monkey") for i in range(0, 6): params = { "type": "m.login.password", "identifier": {"type": "m.id.user", "user": "kermit"}, "password": "monkey", } channel = self.make_request(b"POST", LOGIN_URL, params) if i == 5: self.assertEqual(channel.result["code"], b"429", channel.result) retry_after_ms = int(channel.json_body["retry_after_ms"]) else: self.assertEqual(channel.result["code"], b"200", channel.result) # Since we're ratelimiting at 1 request/min, retry_after_ms should be lower # than 1min. self.assertTrue(retry_after_ms < 6000) self.reactor.advance(retry_after_ms / 1000.0) params = { "type": "m.login.password", "identifier": {"type": "m.id.user", "user": "kermit"}, "password": "monkey", } channel = self.make_request(b"POST", LOGIN_URL, params) self.assertEqual(channel.result["code"], b"200", channel.result) @override_config( { "rc_login": { # Prevent the address login ratelimiter from raising first # # This is normally covered by the default test homeserver config # which sets these values to 10000, but as we're overriding the entire # rc_login dict here, we need to set this manually as well "address": {"per_second": 10000, "burst_count": 10000}, "failed_attempts": {"per_second": 0.17, "burst_count": 5}, } } ) def test_POST_ratelimiting_per_account_failed_attempts(self) -> None: self.register_user("kermit", "monkey") for i in range(0, 6): params = { "type": "m.login.password", "identifier": {"type": "m.id.user", "user": "kermit"}, "password": "notamonkey", } channel = self.make_request(b"POST", LOGIN_URL, params) if i == 5: self.assertEqual(channel.result["code"], b"429", channel.result) retry_after_ms = int(channel.json_body["retry_after_ms"]) else: self.assertEqual(channel.result["code"], b"403", channel.result) # Since we're ratelimiting at 1 request/min, retry_after_ms should be lower # than 1min. self.assertTrue(retry_after_ms < 6000) self.reactor.advance(retry_after_ms / 1000.0 + 1.0) params = { "type": "m.login.password", "identifier": {"type": "m.id.user", "user": "kermit"}, "password": "notamonkey", } channel = self.make_request(b"POST", LOGIN_URL, params) self.assertEqual(channel.result["code"], b"403", channel.result) @override_config({"session_lifetime": "24h"}) def test_soft_logout(self) -> None: self.register_user("kermit", "monkey") # we shouldn't be able to make requests without an access token channel = self.make_request(b"GET", TEST_URL) self.assertEqual(channel.result["code"], b"401", channel.result) self.assertEqual(channel.json_body["errcode"], "M_MISSING_TOKEN") # log in as normal params = { "type": "m.login.password", "identifier": {"type": "m.id.user", "user": "kermit"}, "password": "monkey", } channel = self.make_request(b"POST", LOGIN_URL, params) self.assertEqual(channel.code, 200, channel.result) access_token = channel.json_body["access_token"] device_id = channel.json_body["device_id"] # we should now be able to make requests with the access token channel = self.make_request(b"GET", TEST_URL, access_token=access_token) self.assertEqual(channel.code, 200, channel.result) # time passes self.reactor.advance(24 * 3600) # ... and we should be soft-logouted channel = self.make_request(b"GET", TEST_URL, access_token=access_token) self.assertEqual(channel.code, 401, channel.result) self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN") self.assertEqual(channel.json_body["soft_logout"], True) # # test behaviour after deleting the expired device # # we now log in as a different device access_token_2 = self.login("kermit", "monkey") # more requests with the expired token should still return a soft-logout self.reactor.advance(3600) channel = self.make_request(b"GET", TEST_URL, access_token=access_token) self.assertEqual(channel.code, 401, channel.result) self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN") self.assertEqual(channel.json_body["soft_logout"], True) # ... but if we delete that device, it will be a proper logout self._delete_device(access_token_2, "kermit", "monkey", device_id) channel = self.make_request(b"GET", TEST_URL, access_token=access_token) self.assertEqual(channel.code, 401, channel.result) self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN") self.assertEqual(channel.json_body["soft_logout"], False) def _delete_device( self, access_token: str, user_id: str, password: str, device_id: str ) -> None: """Perform the UI-Auth to delete a device""" channel = self.make_request( b"DELETE", "devices/" + device_id, access_token=access_token ) self.assertEqual(channel.code, 401, channel.result) # check it's a UI-Auth fail self.assertEqual( set(channel.json_body.keys()), {"flows", "params", "session"}, channel.result, ) auth = { "type": "m.login.password", # https://github.com/matrix-org/synapse/issues/5665 # "identifier": {"type": "m.id.user", "user": user_id}, "user": user_id, "password": password, "session": channel.json_body["session"], } channel = self.make_request( b"DELETE", "devices/" + device_id, access_token=access_token, content={"auth": auth}, ) self.assertEqual(channel.code, 200, channel.result) @override_config({"session_lifetime": "24h"}) def test_session_can_hard_logout_after_being_soft_logged_out(self) -> None: self.register_user("kermit", "monkey") # log in as normal access_token = self.login("kermit", "monkey") # we should now be able to make requests with the access token channel = self.make_request(b"GET", TEST_URL, access_token=access_token) self.assertEqual(channel.code, 200, channel.result) # time passes self.reactor.advance(24 * 3600) # ... and we should be soft-logouted channel = self.make_request(b"GET", TEST_URL, access_token=access_token) self.assertEqual(channel.code, 401, channel.result) self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN") self.assertEqual(channel.json_body["soft_logout"], True) # Now try to hard logout this session channel = self.make_request(b"POST", "/logout", access_token=access_token) self.assertEqual(channel.result["code"], b"200", channel.result) @override_config({"session_lifetime": "24h"}) def test_session_can_hard_logout_all_sessions_after_being_soft_logged_out( self, ) -> None: self.register_user("kermit", "monkey") # log in as normal access_token = self.login("kermit", "monkey") # we should now be able to make requests with the access token channel = self.make_request(b"GET", TEST_URL, access_token=access_token) self.assertEqual(channel.code, 200, channel.result) # time passes self.reactor.advance(24 * 3600) # ... and we should be soft-logouted channel = self.make_request(b"GET", TEST_URL, access_token=access_token) self.assertEqual(channel.code, 401, channel.result) self.assertEqual(channel.json_body["errcode"], "M_UNKNOWN_TOKEN") self.assertEqual(channel.json_body["soft_logout"], True) # Now try to hard log out all of the user's sessions channel = self.make_request(b"POST", "/logout/all", access_token=access_token) self.assertEqual(channel.result["code"], b"200", channel.result) def test_login_with_overly_long_device_id_fails(self) -> None: self.register_user("mickey", "cheese") # create a device_id longer than 512 characters device_id = "yolo" * 512 body = { "type": "m.login.password", "user": "mickey", "password": "cheese", "device_id": device_id, } # make a login request with the bad device_id channel = self.make_request( "POST", "/_matrix/client/v3/login", json.dumps(body).encode("utf8"), custom_headers=None, ) # test that the login fails with the correct error code self.assertEqual(channel.code, 400) self.assertEqual(channel.json_body["errcode"], "M_INVALID_PARAM") @skip_unless(has_saml2 and HAS_OIDC, "Requires SAML2 and OIDC") class MultiSSOTestCase(unittest.HomeserverTestCase): """Tests for homeservers with multiple SSO providers enabled""" servlets = [ login.register_servlets, ] def default_config(self) -> Dict[str, Any]: config = super().default_config() config["public_baseurl"] = BASE_URL config["cas_config"] = { "enabled": True, "server_url": CAS_SERVER, "service_url": "https://matrix.goodserver.com:8448", } config["saml2_config"] = { "sp_config": { "metadata": {"inline": [TEST_SAML_METADATA]}, # use the XMLSecurity backend to avoid relying on xmlsec1 "crypto_backend": "XMLSecurity", }, } # default OIDC provider config["oidc_config"] = TEST_OIDC_CONFIG # additional OIDC providers config["oidc_providers"] = [ { "idp_id": "idp1", "idp_name": "IDP1", "discover": False, "issuer": "https://issuer1", "client_id": "test-client-id", "client_secret": "test-client-secret", "scopes": ["profile"], "authorization_endpoint": "https://issuer1/auth", "token_endpoint": "https://issuer1/token", "userinfo_endpoint": "https://issuer1/userinfo", "user_mapping_provider": { "config": {"localpart_template": "{{ user.sub }}"} }, } ] return config def create_resource_dict(self) -> Dict[str, Resource]: d = super().create_resource_dict() d.update(build_synapse_client_resource_tree(self.hs)) return d def test_get_login_flows(self) -> None: """GET /login should return password and SSO flows""" channel = self.make_request("GET", "/_matrix/client/r0/login") self.assertEqual(channel.code, 200, channel.result) expected_flow_types = [ "m.login.cas", "m.login.sso", "m.login.token", "m.login.password", ] + [f["type"] for f in ADDITIONAL_LOGIN_FLOWS] self.assertCountEqual( [f["type"] for f in channel.json_body["flows"]], expected_flow_types ) flows = {flow["type"]: flow for flow in channel.json_body["flows"]} self.assertCountEqual( flows["m.login.sso"]["identity_providers"], [ {"id": "cas", "name": "CAS"}, {"id": "saml", "name": "SAML"}, {"id": "oidc-idp1", "name": "IDP1"}, {"id": "oidc", "name": "OIDC"}, ], ) def test_multi_sso_redirect(self) -> None: """/login/sso/redirect should redirect to an identity picker""" # first hit the redirect url, which should redirect to our idp picker channel = self._make_sso_redirect_request(None) self.assertEqual(channel.code, 302, channel.result) location_headers = channel.headers.getRawHeaders("Location") assert location_headers uri = location_headers[0] # hitting that picker should give us some HTML channel = self.make_request("GET", uri) self.assertEqual(channel.code, 200, channel.result) # parse the form to check it has fields assumed elsewhere in this class html = channel.result["body"].decode("utf-8") p = TestHtmlParser() p.feed(html) p.close() # there should be a link for each href returned_idps: List[str] = [] for link in p.links: path, query = link.split("?", 1) self.assertEqual(path, "pick_idp") params = urllib.parse.parse_qs(query) self.assertEqual(params["redirectUrl"], [TEST_CLIENT_REDIRECT_URL]) returned_idps.append(params["idp"][0]) self.assertCountEqual(returned_idps, ["cas", "oidc", "oidc-idp1", "saml"]) def test_multi_sso_redirect_to_cas(self) -> None: """If CAS is chosen, should redirect to the CAS server""" channel = self.make_request( "GET", "/_synapse/client/pick_idp?redirectUrl=" + urllib.parse.quote_plus(TEST_CLIENT_REDIRECT_URL) + "&idp=cas", shorthand=False, ) self.assertEqual(channel.code, 302, channel.result) location_headers = channel.headers.getRawHeaders("Location") assert location_headers cas_uri = location_headers[0] cas_uri_path, cas_uri_query = cas_uri.split("?", 1) # it should redirect us to the login page of the cas server self.assertEqual(cas_uri_path, CAS_SERVER + "/login") # check that the redirectUrl is correctly encoded in the service param - ie, the # place that CAS will redirect to cas_uri_params = urllib.parse.parse_qs(cas_uri_query) service_uri = cas_uri_params["service"][0] _, service_uri_query = service_uri.split("?", 1) service_uri_params = urllib.parse.parse_qs(service_uri_query) self.assertEqual(service_uri_params["redirectUrl"][0], TEST_CLIENT_REDIRECT_URL) def test_multi_sso_redirect_to_saml(self) -> None: """If SAML is chosen, should redirect to the SAML server""" channel = self.make_request( "GET", "/_synapse/client/pick_idp?redirectUrl=" + urllib.parse.quote_plus(TEST_CLIENT_REDIRECT_URL) + "&idp=saml", ) self.assertEqual(channel.code, 302, channel.result) location_headers = channel.headers.getRawHeaders("Location") assert location_headers saml_uri = location_headers[0] saml_uri_path, saml_uri_query = saml_uri.split("?", 1) # it should redirect us to the login page of the SAML server self.assertEqual(saml_uri_path, SAML_SERVER) # the RelayState is used to carry the client redirect url saml_uri_params = urllib.parse.parse_qs(saml_uri_query) relay_state_param = saml_uri_params["RelayState"][0] self.assertEqual(relay_state_param, TEST_CLIENT_REDIRECT_URL) def test_login_via_oidc(self) -> None: """If OIDC is chosen, should redirect to the OIDC auth endpoint""" # pick the default OIDC provider channel = self.make_request( "GET", "/_synapse/client/pick_idp?redirectUrl=" + urllib.parse.quote_plus(TEST_CLIENT_REDIRECT_URL) + "&idp=oidc", ) self.assertEqual(channel.code, 302, channel.result) location_headers = channel.headers.getRawHeaders("Location") assert location_headers oidc_uri = location_headers[0] oidc_uri_path, oidc_uri_query = oidc_uri.split("?", 1) # it should redirect us to the auth page of the OIDC server self.assertEqual(oidc_uri_path, TEST_OIDC_AUTH_ENDPOINT) # ... and should have set a cookie including the redirect url cookie_headers = channel.headers.getRawHeaders("Set-Cookie") assert cookie_headers cookies: Dict[str, str] = {} for h in cookie_headers: key, value = h.split(";")[0].split("=", maxsplit=1) cookies[key] = value oidc_session_cookie = cookies["oidc_session"] macaroon = pymacaroons.Macaroon.deserialize(oidc_session_cookie) self.assertEqual( self._get_value_from_macaroon(macaroon, "client_redirect_url"), TEST_CLIENT_REDIRECT_URL, ) channel = self.helper.complete_oidc_auth(oidc_uri, cookies, {"sub": "user1"}) # that should serve a confirmation page self.assertEqual(channel.code, 200, channel.result) content_type_headers = channel.headers.getRawHeaders("Content-Type") assert content_type_headers self.assertTrue(content_type_headers[-1].startswith("text/html")) p = TestHtmlParser() p.feed(channel.text_body) p.close() # ... which should contain our redirect link self.assertEqual(len(p.links), 1) path, query = p.links[0].split("?", 1) self.assertEqual(path, "https://x") # it will have url-encoded the params properly, so we'll have to parse them params = urllib.parse.parse_qsl( query, keep_blank_values=True, strict_parsing=True, errors="strict" ) self.assertEqual(params[0:2], EXPECTED_CLIENT_REDIRECT_URL_PARAMS) self.assertEqual(params[2][0], "loginToken") # finally, submit the matrix login token to the login API, which gives us our # matrix access token, mxid, and device id. login_token = params[2][1] chan = self.make_request( "POST", "/login", content={"type": "m.login.token", "token": login_token}, ) self.assertEqual(chan.code, 200, chan.result) self.assertEqual(chan.json_body["user_id"], "@user1:test") def test_multi_sso_redirect_to_unknown(self) -> None: """An unknown IdP should cause a 400""" channel = self.make_request( "GET", "/_synapse/client/pick_idp?redirectUrl=http://x&idp=xyz", ) self.assertEqual(channel.code, 400, channel.result) def test_client_idp_redirect_to_unknown(self) -> None: """If the client tries to pick an unknown IdP, return a 404""" channel = self._make_sso_redirect_request("xxx") self.assertEqual(channel.code, 404, channel.result) self.assertEqual(channel.json_body["errcode"], "M_NOT_FOUND") def test_client_idp_redirect_to_oidc(self) -> None: """If the client pick a known IdP, redirect to it""" channel = self._make_sso_redirect_request("oidc") self.assertEqual(channel.code, 302, channel.result) location_headers = channel.headers.getRawHeaders("Location") assert location_headers oidc_uri = location_headers[0] oidc_uri_path, oidc_uri_query = oidc_uri.split("?", 1) # it should redirect us to the auth page of the OIDC server self.assertEqual(oidc_uri_path, TEST_OIDC_AUTH_ENDPOINT) def _make_sso_redirect_request(self, idp_prov: Optional[str] = None) -> FakeChannel: """Send a request to /_matrix/client/r0/login/sso/redirect ... possibly specifying an IDP provider """ endpoint = "/_matrix/client/r0/login/sso/redirect" if idp_prov is not None: endpoint += "/" + idp_prov endpoint += "?redirectUrl=" + urllib.parse.quote_plus(TEST_CLIENT_REDIRECT_URL) return self.make_request( "GET", endpoint, custom_headers=[("Host", SYNAPSE_SERVER_PUBLIC_HOSTNAME)], ) @staticmethod def _get_value_from_macaroon(macaroon: pymacaroons.Macaroon, key: str) -> str: prefix = key + " = " for caveat in macaroon.caveats: if caveat.caveat_id.startswith(prefix): return caveat.caveat_id[len(prefix) :] raise ValueError("No %s caveat in macaroon" % (key,)) class CASTestCase(unittest.HomeserverTestCase): servlets = [ login.register_servlets, ] def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: self.base_url = "https://matrix.goodserver.com/" self.redirect_path = "_synapse/client/login/sso/redirect/confirm" config = self.default_config() config["public_baseurl"] = ( config.get("public_baseurl") or "https://matrix.goodserver.com:8448" ) config["cas_config"] = { "enabled": True, "server_url": CAS_SERVER, } cas_user_id = "username" self.user_id = "@%s:test" % cas_user_id async def get_raw(uri: str, args: Any) -> bytes: """Return an example response payload from a call to the `/proxyValidate` endpoint of a CAS server, copied from https://apereo.github.io/cas/5.0.x/protocol/CAS-Protocol-V2-Specification.html#26-proxyvalidate-cas-20 This needs to be returned by an async function (as opposed to set as the mock's return value) because the corresponding Synapse code awaits on it. """ return ( """ <cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'> <cas:authenticationSuccess> <cas:user>%s</cas:user> <cas:proxyGrantingTicket>PGTIOU-84678-8a9d...</cas:proxyGrantingTicket> <cas:proxies> <cas:proxy>https://proxy2/pgtUrl</cas:proxy> <cas:proxy>https://proxy1/pgtUrl</cas:proxy> </cas:proxies> </cas:authenticationSuccess> </cas:serviceResponse> """ % cas_user_id ).encode("utf-8") mocked_http_client = Mock(spec=["get_raw"]) mocked_http_client.get_raw.side_effect = get_raw self.hs = self.setup_test_homeserver( config=config, proxied_http_client=mocked_http_client, ) return self.hs def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.deactivate_account_handler = hs.get_deactivate_account_handler() def test_cas_redirect_confirm(self) -> None: """Tests that the SSO login flow serves a confirmation page before redirecting a user to the redirect URL. """ base_url = "/_matrix/client/r0/login/cas/ticket?redirectUrl" redirect_url = "https://dodgy-site.com/" url_parts = list(urllib.parse.urlparse(base_url)) query = dict(urllib.parse.parse_qsl(url_parts[4])) query.update({"redirectUrl": redirect_url}) query.update({"ticket": "ticket"}) url_parts[4] = urllib.parse.urlencode(query) cas_ticket_url = urllib.parse.urlunparse(url_parts) # Get Synapse to call the fake CAS and serve the template. channel = self.make_request("GET", cas_ticket_url) # Test that the response is HTML. self.assertEqual(channel.code, 200, channel.result) content_type_header_value = "" for header in channel.result.get("headers", []): if header[0] == b"Content-Type": content_type_header_value = header[1].decode("utf8") self.assertTrue(content_type_header_value.startswith("text/html")) # Test that the body isn't empty. self.assertTrue(len(channel.result["body"]) > 0) # And that it contains our redirect link self.assertIn(redirect_url, channel.result["body"].decode("UTF-8")) @override_config( { "sso": { "client_whitelist": [ "https://legit-site.com/", "https://other-site.com/", ] } } ) def test_cas_redirect_whitelisted(self) -> None: """Tests that the SSO login flow serves a redirect to a whitelisted url""" self._test_redirect("https://legit-site.com/") @override_config({"public_baseurl": "https://example.com"}) def test_cas_redirect_login_fallback(self) -> None: self._test_redirect("https://example.com/_matrix/static/client/login") def _test_redirect(self, redirect_url: str) -> None: """Tests that the SSO login flow serves a redirect for the given redirect URL.""" cas_ticket_url = ( "/_matrix/client/r0/login/cas/ticket?redirectUrl=%s&ticket=ticket" % (urllib.parse.quote(redirect_url)) ) # Get Synapse to call the fake CAS and serve the template. channel = self.make_request("GET", cas_ticket_url) self.assertEqual(channel.code, 302) location_headers = channel.headers.getRawHeaders("Location") assert location_headers self.assertEqual(location_headers[0][: len(redirect_url)], redirect_url) @override_config({"sso": {"client_whitelist": ["https://legit-site.com/"]}}) def test_deactivated_user(self) -> None: """Logging in as a deactivated account should error.""" redirect_url = "https://legit-site.com/" # First login (to create the user). self._test_redirect(redirect_url) # Deactivate the account. self.get_success( self.deactivate_account_handler.deactivate_account( self.user_id, False, create_requester(self.user_id) ) ) # Request the CAS ticket. cas_ticket_url = ( "/_matrix/client/r0/login/cas/ticket?redirectUrl=%s&ticket=ticket" % (urllib.parse.quote(redirect_url)) ) # Get Synapse to call the fake CAS and serve the template. channel = self.make_request("GET", cas_ticket_url) # Because the user is deactivated they are served an error template. self.assertEqual(channel.code, 403) self.assertIn(b"SSO account deactivated", channel.result["body"]) @skip_unless(HAS_JWT, "requires jwt") class JWTTestCase(unittest.HomeserverTestCase): servlets = [ synapse.rest.admin.register_servlets_for_client_rest_resource, login.register_servlets, ] jwt_secret = "secret" jwt_algorithm = "HS256" base_config = { "enabled": True, "secret": jwt_secret, "algorithm": jwt_algorithm, } def default_config(self) -> Dict[str, Any]: config = super().default_config() # If jwt_config has been defined (eg via @override_config), don't replace it. if config.get("jwt_config") is None: config["jwt_config"] = self.base_config return config def jwt_encode(self, payload: Dict[str, Any], secret: str = jwt_secret) -> str: # PyJWT 2.0.0 changed the return type of jwt.encode from bytes to str. result: Union[str, bytes] = jwt.encode(payload, secret, self.jwt_algorithm) if isinstance(result, bytes): return result.decode("ascii") return result def jwt_login(self, *args: Any) -> FakeChannel: params = {"type": "org.matrix.login.jwt", "token": self.jwt_encode(*args)} channel = self.make_request(b"POST", LOGIN_URL, params) return channel def test_login_jwt_valid_registered(self) -> None: self.register_user("kermit", "monkey") channel = self.jwt_login({"sub": "kermit"}) self.assertEqual(channel.result["code"], b"200", channel.result) self.assertEqual(channel.json_body["user_id"], "@kermit:test") def test_login_jwt_valid_unregistered(self) -> None: channel = self.jwt_login({"sub": "frog"}) self.assertEqual(channel.result["code"], b"200", channel.result) self.assertEqual(channel.json_body["user_id"], "@frog:test") def test_login_jwt_invalid_signature(self) -> None: channel = self.jwt_login({"sub": "frog"}, "notsecret") self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual( channel.json_body["error"], "JWT validation failed: Signature verification failed", ) def test_login_jwt_expired(self) -> None: channel = self.jwt_login({"sub": "frog", "exp": 864000}) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual( channel.json_body["error"], "JWT validation failed: Signature has expired" ) def test_login_jwt_not_before(self) -> None: now = int(time.time()) channel = self.jwt_login({"sub": "frog", "nbf": now + 3600}) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual( channel.json_body["error"], "JWT validation failed: The token is not yet valid (nbf)", ) def test_login_no_sub(self) -> None: channel = self.jwt_login({"username": "root"}) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual(channel.json_body["error"], "Invalid JWT") @override_config({"jwt_config": {**base_config, "issuer": "test-issuer"}}) def test_login_iss(self) -> None: """Test validating the issuer claim.""" # A valid issuer. channel = self.jwt_login({"sub": "kermit", "iss": "test-issuer"}) self.assertEqual(channel.result["code"], b"200", channel.result) self.assertEqual(channel.json_body["user_id"], "@kermit:test") # An invalid issuer. channel = self.jwt_login({"sub": "kermit", "iss": "invalid"}) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual( channel.json_body["error"], "JWT validation failed: Invalid issuer" ) # Not providing an issuer. channel = self.jwt_login({"sub": "kermit"}) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual( channel.json_body["error"], 'JWT validation failed: Token is missing the "iss" claim', ) def test_login_iss_no_config(self) -> None: """Test providing an issuer claim without requiring it in the configuration.""" channel = self.jwt_login({"sub": "kermit", "iss": "invalid"}) self.assertEqual(channel.result["code"], b"200", channel.result) self.assertEqual(channel.json_body["user_id"], "@kermit:test") @override_config({"jwt_config": {**base_config, "audiences": ["test-audience"]}}) def test_login_aud(self) -> None: """Test validating the audience claim.""" # A valid audience. channel = self.jwt_login({"sub": "kermit", "aud": "test-audience"}) self.assertEqual(channel.result["code"], b"200", channel.result) self.assertEqual(channel.json_body["user_id"], "@kermit:test") # An invalid audience. channel = self.jwt_login({"sub": "kermit", "aud": "invalid"}) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual( channel.json_body["error"], "JWT validation failed: Invalid audience" ) # Not providing an audience. channel = self.jwt_login({"sub": "kermit"}) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual( channel.json_body["error"], 'JWT validation failed: Token is missing the "aud" claim', ) def test_login_aud_no_config(self) -> None: """Test providing an audience without requiring it in the configuration.""" channel = self.jwt_login({"sub": "kermit", "aud": "invalid"}) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual( channel.json_body["error"], "JWT validation failed: Invalid audience" ) def test_login_default_sub(self) -> None: """Test reading user ID from the default subject claim.""" channel = self.jwt_login({"sub": "kermit"}) self.assertEqual(channel.result["code"], b"200", channel.result) self.assertEqual(channel.json_body["user_id"], "@kermit:test") @override_config({"jwt_config": {**base_config, "subject_claim": "username"}}) def test_login_custom_sub(self) -> None: """Test reading user ID from a custom subject claim.""" channel = self.jwt_login({"username": "frog"}) self.assertEqual(channel.result["code"], b"200", channel.result) self.assertEqual(channel.json_body["user_id"], "@frog:test") def test_login_no_token(self) -> None: params = {"type": "org.matrix.login.jwt"} channel = self.make_request(b"POST", LOGIN_URL, params) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual(channel.json_body["error"], "Token field for JWT is missing") # The JWTPubKeyTestCase is a complement to JWTTestCase where we instead use # RSS256, with a public key configured in synapse as "jwt_secret", and tokens # signed by the private key. @skip_unless(HAS_JWT, "requires jwt") class JWTPubKeyTestCase(unittest.HomeserverTestCase): servlets = [ login.register_servlets, ] # This key's pubkey is used as the jwt_secret setting of synapse. Valid # tokens are signed by this and validated using the pubkey. It is generated # with `openssl genrsa 512` (not a secure way to generate real keys, but # good enough for tests!) jwt_privatekey = "\n".join( [ "-----BEGIN RSA PRIVATE KEY-----", "MIIBPAIBAAJBAM50f1Q5gsdmzifLstzLHb5NhfajiOt7TKO1vSEWdq7u9x8SMFiB", "492RM9W/XFoh8WUfL9uL6Now6tPRDsWv3xsCAwEAAQJAUv7OOSOtiU+wzJq82rnk", "yR4NHqt7XX8BvkZPM7/+EjBRanmZNSp5kYZzKVaZ/gTOM9+9MwlmhidrUOweKfB/", "kQIhAPZwHazbjo7dYlJs7wPQz1vd+aHSEH+3uQKIysebkmm3AiEA1nc6mDdmgiUq", "TpIN8A4MBKmfZMWTLq6z05y/qjKyxb0CIQDYJxCwTEenIaEa4PdoJl+qmXFasVDN", "ZU0+XtNV7yul0wIhAMI9IhiStIjS2EppBa6RSlk+t1oxh2gUWlIh+YVQfZGRAiEA", "tqBR7qLZGJ5CVKxWmNhJZGt1QHoUtOch8t9C4IdOZ2g=", "-----END RSA PRIVATE KEY-----", ] ) # Generated with `openssl rsa -in foo.key -pubout`, with the the above # private key placed in foo.key (jwt_privatekey). jwt_pubkey = "\n".join( [ "-----BEGIN PUBLIC KEY-----", "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAM50f1Q5gsdmzifLstzLHb5NhfajiOt7", "TKO1vSEWdq7u9x8SMFiB492RM9W/XFoh8WUfL9uL6Now6tPRDsWv3xsCAwEAAQ==", "-----END PUBLIC KEY-----", ] ) # This key is used to sign tokens that shouldn't be accepted by synapse. # Generated just like jwt_privatekey. bad_privatekey = "\n".join( [ "-----BEGIN RSA PRIVATE KEY-----", "MIIBOgIBAAJBAL//SQrKpKbjCCnv/FlasJCv+t3k/MPsZfniJe4DVFhsktF2lwQv", "gLjmQD3jBUTz+/FndLSBvr3F4OHtGL9O/osCAwEAAQJAJqH0jZJW7Smzo9ShP02L", "R6HRZcLExZuUrWI+5ZSP7TaZ1uwJzGFspDrunqaVoPobndw/8VsP8HFyKtceC7vY", "uQIhAPdYInDDSJ8rFKGiy3Ajv5KWISBicjevWHF9dbotmNO9AiEAxrdRJVU+EI9I", "eB4qRZpY6n4pnwyP0p8f/A3NBaQPG+cCIFlj08aW/PbxNdqYoBdeBA0xDrXKfmbb", "iwYxBkwL0JCtAiBYmsi94sJn09u2Y4zpuCbJeDPKzWkbuwQh+W1fhIWQJQIhAKR0", "KydN6cRLvphNQ9c/vBTdlzWxzcSxREpguC7F1J1m", "-----END RSA PRIVATE KEY-----", ] ) def default_config(self) -> Dict[str, Any]: config = super().default_config() config["jwt_config"] = { "enabled": True, "secret": self.jwt_pubkey, "algorithm": "RS256", } return config def jwt_encode(self, payload: Dict[str, Any], secret: str = jwt_privatekey) -> str: # PyJWT 2.0.0 changed the return type of jwt.encode from bytes to str. result: Union[bytes, str] = jwt.encode(payload, secret, "RS256") if isinstance(result, bytes): return result.decode("ascii") return result def jwt_login(self, *args: Any) -> FakeChannel: params = {"type": "org.matrix.login.jwt", "token": self.jwt_encode(*args)} channel = self.make_request(b"POST", LOGIN_URL, params) return channel def test_login_jwt_valid(self) -> None: channel = self.jwt_login({"sub": "kermit"}) self.assertEqual(channel.result["code"], b"200", channel.result) self.assertEqual(channel.json_body["user_id"], "@kermit:test") def test_login_jwt_invalid_signature(self) -> None: channel = self.jwt_login({"sub": "frog"}, self.bad_privatekey) self.assertEqual(channel.result["code"], b"403", channel.result) self.assertEqual(channel.json_body["errcode"], "M_FORBIDDEN") self.assertEqual( channel.json_body["error"], "JWT validation failed: Signature verification failed", ) AS_USER = "as_user_alice" class AppserviceLoginRestServletTestCase(unittest.HomeserverTestCase): servlets = [ login.register_servlets, register.register_servlets, ] def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer: self.hs = self.setup_test_homeserver() self.service = ApplicationService( id="unique_identifier", token="some_token", hostname="example.com", sender="@asbot:example.com", namespaces={ ApplicationService.NS_USERS: [ {"regex": r"@as_user.*", "exclusive": False} ], ApplicationService.NS_ROOMS: [], ApplicationService.NS_ALIASES: [], }, ) self.another_service = ApplicationService( id="another__identifier", token="another_token", hostname="example.com", sender="@as2bot:example.com", namespaces={ ApplicationService.NS_USERS: [ {"regex": r"@as2_user.*", "exclusive": False} ], ApplicationService.NS_ROOMS: [], ApplicationService.NS_ALIASES: [], }, ) self.hs.get_datastores().main.services_cache.append(self.service) self.hs.get_datastores().main.services_cache.append(self.another_service) return self.hs def test_login_appservice_user(self) -> None: """Test that an appservice user can use /login""" self.register_appservice_user(AS_USER, self.service.token) params = { "type": login.LoginRestServlet.APPSERVICE_TYPE, "identifier": {"type": "m.id.user", "user": AS_USER}, } channel = self.make_request( b"POST", LOGIN_URL, params, access_token=self.service.token ) self.assertEqual(channel.result["code"], b"200", channel.result) def test_login_appservice_user_bot(self) -> None: """Test that the appservice bot can use /login""" self.register_appservice_user(AS_USER, self.service.token) params = { "type": login.LoginRestServlet.APPSERVICE_TYPE, "identifier": {"type": "m.id.user", "user": self.service.sender}, } channel = self.make_request( b"POST", LOGIN_URL, params, access_token=self.service.token ) self.assertEqual(channel.result["code"], b"200", channel.result) def test_login_appservice_wrong_user(self) -> None: """Test that non-as users cannot login with the as token""" self.register_appservice_user(AS_USER, self.service.token) params = { "type": login.LoginRestServlet.APPSERVICE_TYPE, "identifier": {"type": "m.id.user", "user": "fibble_wibble"}, } channel = self.make_request( b"POST", LOGIN_URL, params, access_token=self.service.token ) self.assertEqual(channel.result["code"], b"403", channel.result) def test_login_appservice_wrong_as(self) -> None: """Test that as users cannot login with wrong as token""" self.register_appservice_user(AS_USER, self.service.token) params = { "type": login.LoginRestServlet.APPSERVICE_TYPE, "identifier": {"type": "m.id.user", "user": AS_USER}, } channel = self.make_request( b"POST", LOGIN_URL, params, access_token=self.another_service.token ) self.assertEqual(channel.result["code"], b"403", channel.result) def test_login_appservice_no_token(self) -> None: """Test that users must provide a token when using the appservice login method """ self.register_appservice_user(AS_USER, self.service.token) params = { "type": login.LoginRestServlet.APPSERVICE_TYPE, "identifier": {"type": "m.id.user", "user": AS_USER}, } channel = self.make_request(b"POST", LOGIN_URL, params) self.assertEqual(channel.result["code"], b"401", channel.result) @skip_unless(HAS_OIDC, "requires OIDC") class UsernamePickerTestCase(HomeserverTestCase): """Tests for the username picker flow of SSO login""" servlets = [login.register_servlets] def default_config(self) -> Dict[str, Any]: config = super().default_config() config["public_baseurl"] = BASE_URL config["oidc_config"] = {} config["oidc_config"].update(TEST_OIDC_CONFIG) config["oidc_config"]["user_mapping_provider"] = { "config": {"display_name_template": "{{ user.displayname }}"} } # whitelist this client URI so we redirect straight to it rather than # serving a confirmation page config["sso"] = {"client_whitelist": ["https://x"]} return config def create_resource_dict(self) -> Dict[str, Resource]: d = super().create_resource_dict() d.update(build_synapse_client_resource_tree(self.hs)) return d def test_username_picker(self) -> None: """Test the happy path of a username picker flow.""" # do the start of the login flow channel = self.helper.auth_via_oidc( {"sub": "tester", "displayname": "Jonny"}, TEST_CLIENT_REDIRECT_URL ) # that should redirect to the username picker self.assertEqual(channel.code, 302, channel.result) location_headers = channel.headers.getRawHeaders("Location") assert location_headers picker_url = location_headers[0] self.assertEqual(picker_url, "/_synapse/client/pick_username/account_details") # ... with a username_mapping_session cookie cookies: Dict[str, str] = {} channel.extract_cookies(cookies) self.assertIn("username_mapping_session", cookies) session_id = cookies["username_mapping_session"] # introspect the sso handler a bit to check that the username mapping session # looks ok. username_mapping_sessions = self.hs.get_sso_handler()._username_mapping_sessions self.assertIn( session_id, username_mapping_sessions, "session id not found in map", ) session = username_mapping_sessions[session_id] self.assertEqual(session.remote_user_id, "tester") self.assertEqual(session.display_name, "Jonny") self.assertEqual(session.client_redirect_url, TEST_CLIENT_REDIRECT_URL) # the expiry time should be about 15 minutes away expected_expiry = self.clock.time_msec() + (15 * 60 * 1000) self.assertApproximates(session.expiry_time_ms, expected_expiry, tolerance=1000) # Now, submit a username to the username picker, which should serve a redirect # to the completion page content = urlencode({b"username": b"bobby"}).encode("utf8") chan = self.make_request( "POST", path=picker_url, content=content, content_is_form=True, custom_headers=[ ("Cookie", "username_mapping_session=" + session_id), # old versions of twisted don't do form-parsing without a valid # content-length header. ("Content-Length", str(len(content))), ], ) self.assertEqual(chan.code, 302, chan.result) location_headers = chan.headers.getRawHeaders("Location") assert location_headers # send a request to the completion page, which should 302 to the client redirectUrl chan = self.make_request( "GET", path=location_headers[0], custom_headers=[("Cookie", "username_mapping_session=" + session_id)], ) self.assertEqual(chan.code, 302, chan.result) location_headers = chan.headers.getRawHeaders("Location") assert location_headers # ensure that the returned location matches the requested redirect URL path, query = location_headers[0].split("?", 1) self.assertEqual(path, "https://x") # it will have url-encoded the params properly, so we'll have to parse them params = urllib.parse.parse_qsl( query, keep_blank_values=True, strict_parsing=True, errors="strict" ) self.assertEqual(params[0:2], EXPECTED_CLIENT_REDIRECT_URL_PARAMS) self.assertEqual(params[2][0], "loginToken") # fish the login token out of the returned redirect uri login_token = params[2][1] # finally, submit the matrix login token to the login API, which gives us our # matrix access token, mxid, and device id. chan = self.make_request( "POST", "/login", content={"type": "m.login.token", "token": login_token}, ) self.assertEqual(chan.code, 200, chan.result) self.assertEqual(chan.json_body["user_id"], "@bobby:test")

0a3d26451658f18eb6e4d945d41095c7fba3dc44

py

Python

rmf_demo_tasks/rmf_demo_tasks/request_delivery.py

Kevinskwk/rmf_demos

2d7b9c7c75211b89b91977e5d1a66f440cc5df95

rmf_demo_tasks/rmf_demo_tasks/request_delivery.py

Kevinskwk/rmf_demos

2d7b9c7c75211b89b91977e5d1a66f440cc5df95

rmf_demo_tasks/rmf_demo_tasks/request_delivery.py

Kevinskwk/rmf_demos

2d7b9c7c75211b89b91977e5d1a66f440cc5df95

import argparse import sys from time import sleep import uuid import rclpy from rmf_task_msgs.msg import Delivery def main(argv = sys.argv): rclpy.init(args=argv) args_without_ros = rclpy.utilities.remove_ros_args(argv) ''' # Example request: task_id: randomid_001 items: [itemA, itemB....] pickup_place_name: cssd_room pickup_behavior: - name: dispenser - parameters: [request_guid: xxx, target_guid:cssdbot, transporter_type:mir] dropoff_place_name: ot_prep_room dropoff_behavior: - name: dispenser - parameters: [request_guid: yyy, target_guid:otbot, transporter_type:mir] ''' parser = argparse.ArgumentParser() parser.add_argument('-p', '--pickup', default='pantry', help='Start waypoint') parser.add_argument('-d', '--dropoff', default='hardware_2', help='Finish waypoint') parser.add_argument('-i', '--task-id', help='Task ID', default='', type=str) parser.add_argument('-r', '--robot-type', help='Type of robot', default='magni') args = parser.parse_args(args_without_ros[1:]) node = rclpy.create_node('loop_request_publisher') publisher = node.create_publisher(Delivery, 'delivery_requests', 10) sleep(0.5) request = Delivery() if args.task_id: request.task_id = args.task_id else: request.task_id = 'delivery#' + str(uuid.uuid1()) request.pickup_place_name = args.pickup request.dropoff_place_name = args.dropoff for _ in range(5): publisher.publish(request) sleep(0.5) rclpy.shutdown() print(f'Delivery request submitted to {args.robot_type}') if __name__ == '__main__': main(sys.argv)

0a3d8aa1a0610f6e6749b406310d289569ef5143

py

Python

dis_snek/api/http/http_client.py

BoredManCodes/Dis-Snek

662dbc3f86c133fd704c22d3d6d55af5ee1f6f5b

dis_snek/api/http/http_client.py

BoredManCodes/Dis-Snek

662dbc3f86c133fd704c22d3d6d55af5ee1f6f5b

dis_snek/api/http/http_client.py

BoredManCodes/Dis-Snek

662dbc3f86c133fd704c22d3d6d55af5ee1f6f5b

"""This file handles the interaction with discords http endpoints.""" import asyncio import logging from typing import Any, Dict, Optional, Union from urllib.parse import quote as _uriquote from weakref import WeakValueDictionary import aiohttp from aiohttp import BaseConnector, ClientSession, ClientWebSocketResponse, FormData from multidict import CIMultiDictProxy from dis_snek.api.http.http_requests import ( BotRequests, ChannelRequests, EmojiRequests, GuildRequests, InteractionRequests, MemberRequests, MessageRequests, ReactionRequests, StickerRequests, ThreadRequests, UserRequests, WebhookRequests, ScheduledEventsRequests, ) from dis_snek.client.const import __py_version__, __repo_url__, __version__, logger_name, MISSING, Absent from dis_snek.client.errors import DiscordError, Forbidden, GatewayNotFound, HTTPException, NotFound, LoginError from dis_snek.client.utils.input_utils import response_decode from dis_snek.client.utils.serializer import dict_filter_missing from dis_snek.models import CooldownSystem from .route import Route __all__ = ["HTTPClient"] log = logging.getLogger(logger_name) class GlobalLock: """Manages the global ratelimit""" def __init__(self) -> None: self.cooldown_system: CooldownSystem = CooldownSystem( 45, 1 ) # global rate-limit is 50 per second, conservatively we use 45 self._lock: asyncio.Lock = asyncio.Lock() async def rate_limit(self) -> None: async with self._lock: while not self.cooldown_system.acquire_token(): await asyncio.sleep(self.cooldown_system.get_cooldown_time()) async def lock(self, delta: float) -> None: """ Lock the global lock for a given duration. Args: delta: The time to keep the lock acquired """ await self._lock.acquire() await asyncio.sleep(delta) self._lock.release() class BucketLock: """Manages the ratelimit for each bucket""" def __init__(self) -> None: self._lock: asyncio.Lock = asyncio.Lock() self.unlock_on_exit: bool = True self.bucket_hash: Optional[str] = None self.limit: int = -1 self.remaining: int = -1 self.delta: float = 0.0 def __repr__(self) -> str: return f"<BucketLock: {self.bucket_hash or 'Generic'}>" @property def locked(self) -> bool: """Return True if lock is acquired.""" return self._lock.locked() def unlock(self) -> None: """Unlock this bucket.""" self._lock.release() def ingest_ratelimit_header(self, header: CIMultiDictProxy) -> None: """ Ingests a discord rate limit header to configure this bucket lock. Args: header: A header from a http response """ self.bucket_hash = header.get("x-ratelimit-bucket") self.limit = int(header.get("x-ratelimit-limit") or -1) self.remaining = int(header.get("x-ratelimit-remaining") or -1) self.delta = float(header.get("x-ratelimit-reset-after", 0.0)) async def blind_defer_unlock(self) -> None: """Unlocks the BucketLock but doesn't wait for completion.""" self.unlock_on_exit = False loop = asyncio.get_running_loop() loop.call_later(self.delta, self.unlock) async def defer_unlock(self) -> None: """Unlocks the BucketLock after a specified delay.""" self.unlock_on_exit = False await asyncio.sleep(self.delta) self.unlock() async def __aenter__(self) -> None: await self._lock.acquire() async def __aexit__(self, *args) -> None: if self.unlock_on_exit and self._lock.locked(): self.unlock() self.unlock_on_exit = True class HTTPClient( BotRequests, ChannelRequests, EmojiRequests, GuildRequests, InteractionRequests, MemberRequests, MessageRequests, ReactionRequests, StickerRequests, ThreadRequests, UserRequests, WebhookRequests, ScheduledEventsRequests, ): """A http client for sending requests to the Discord API.""" def __init__(self, connector: Optional[BaseConnector] = None, loop: Optional[asyncio.AbstractEventLoop] = None): self.connector: Optional[BaseConnector] = connector self.loop = asyncio.get_event_loop() if loop is None else loop self.__session: Absent[Optional[ClientSession]] = MISSING self.token: Optional[str] = None self.global_lock: GlobalLock = GlobalLock() self._max_attempts: int = 3 self.ratelimit_locks: WeakValueDictionary[str, BucketLock] = WeakValueDictionary() self._endpoints = {} self.user_agent: str = ( f"DiscordBot ({__repo_url__} {__version__} Python/{__py_version__}) aiohttp/{aiohttp.__version__}" ) def __del__(self): if self.__session and not self.__session.closed: self.loop.run_until_complete(self.__session.close()) def get_ratelimit(self, route: Route) -> BucketLock: """ Get a route's rate limit bucket. Args: route: The route to fetch the ratelimit bucket for Returns: The BucketLock object for this route """ if bucket_hash := self._endpoints.get(route.rl_bucket): # we have seen this route before, we know which bucket it is associated with lock = self.ratelimit_locks.get(bucket_hash) if lock: # if we have an active lock on this route, it'll still be in the cache # return that lock return lock # if no cached lock exists, return a new lock return BucketLock() def ingest_ratelimit(self, route: Route, header: CIMultiDictProxy, bucket_lock: BucketLock) -> None: """ Ingests a ratelimit header from discord to determine ratelimit. Args: route: The route we're ingesting ratelimit for header: The rate limit header in question bucket_lock: The rate limit bucket for this route """ bucket_lock.ingest_ratelimit_header(header) if bucket_lock.bucket_hash: # We only ever try and cache the bucket if the bucket hash has been set (ignores unlimited endpoints) log.debug(f"Caching ingested rate limit data for: {bucket_lock.bucket_hash}") self._endpoints[route.rl_bucket] = bucket_lock.bucket_hash self.ratelimit_locks[bucket_lock.bucket_hash] = bucket_lock async def request( self, route: Route, data: Absent[Union[dict, FormData]] = MISSING, reason: Absent[str] = MISSING, **kwargs: Dict[str, Any], ) -> Any: """ Make a request to discord. parameters: route: The route to take json: A json payload to send in the request reason: Attach a reason to this request, used for audit logs """ # Assemble headers kwargs["headers"] = {"User-Agent": self.user_agent} if self.token: kwargs["headers"]["Authorization"] = f"Bot {self.token}" if reason not in (None, MISSING): kwargs["headers"]["X-Audit-Log-Reason"] = _uriquote(reason, safe="/ ") if isinstance(data, (list, dict)): kwargs["headers"]["Content-Type"] = "application/json" # sanity check payload if isinstance(data, list): kwargs["json"] = [dict_filter_missing(x) if isinstance(x, dict) else x for x in data] elif isinstance(data, dict): kwargs["json"] = dict_filter_missing(data) elif isinstance(data, FormData): kwargs["data"] = data lock = self.get_ratelimit(route) # this gets a BucketLock for this route. # If this endpoint has been used before, it will get an existing ratelimit for the respective buckethash # otherwise a brand-new bucket lock will be returned for attempt in range(self._max_attempts): async with lock: try: await self.global_lock.rate_limit() # prevent us exceeding the global rate limit by throttling http requests if self.__session.closed: await self.login(self.token) async with self.__session.request(route.method, route.url, **kwargs) as response: result = await response_decode(response) self.ingest_ratelimit(route, response.headers, lock) if response.status == 429: # ratelimit exceeded if result.get("global", False): # if we get a global, that's pretty bad, this would usually happen if the user is hitting the api from 2 clients sharing a token log.error( f"Bot has exceeded global ratelimit, locking REST API for {result.get('retry_after')} seconds" ) await self.global_lock.lock(float(result.get("retry_after"))) continue else: # 429's are unfortunately unavoidable, but we can attempt to avoid them # so long as these are infrequent we're doing well log.warning( f"{route.endpoint} Has exceeded it's ratelimit ({lock.limit})! Reset in {lock.delta} seconds" ) await lock.defer_unlock() # lock this route and wait for unlock continue elif lock.remaining == 0: # Last call available in the bucket, lock until reset log.debug( f"{route.endpoint} Has exhausted its ratelimit ({lock.limit})! Locking route for {lock.delta} seconds" ) await lock.blind_defer_unlock() # lock this route, but continue processing the current response elif response.status in {500, 502, 504}: # Server issues, retry log.warning( f"{route.endpoint} Received {response.status}... retrying in {1 + attempt * 2} seconds" ) await asyncio.sleep(1 + attempt * 2) continue if not 300 > response.status >= 200: await self._raise_exception(response, route, result) log.debug( f"{route.endpoint} Received {response.status} :: [{lock.remaining}/{lock.limit} calls remaining]" ) return result except OSError as e: if attempt < self._max_attempts - 1 and e.errno in (54, 10054): await asyncio.sleep(1 + attempt * 2) continue raise async def _raise_exception(self, response, route, result): log.error(f"{route.method}::{route.url}: {response.status}") if response.status == 403: raise Forbidden(response, response_data=result, route=route) elif response.status == 404: raise NotFound(response, response_data=result, route=route) elif response.status >= 500: raise DiscordError(response, response_data=result, route=route) else: raise HTTPException(response, response_data=result, route=route) async def request_cdn(self, url, asset) -> bytes: log.debug(f"{asset} requests {url} from CDN") async with self.__session.get(url) as response: if response.status == 200: return await response.read() await self._raise_exception(response, asset, await response_decode(response)) async def login(self, token: str) -> dict: """ "Login" to the gateway, basically validates the token and grabs user data. parameters: token: the token to use returns: The currently logged in bot's data """ self.__session = ClientSession(connector=self.connector) self.token = token try: return await self.request(Route("GET", "/users/@me")) except HTTPException as e: if e.status == 401: raise LoginError("An improper token was passed") from e raise async def close(self) -> None: """Close the session.""" if self.__session: await self.__session.close() async def get_gateway(self) -> str: """Get the gateway url.""" try: data: dict = await self.request(Route("GET", "/gateway")) except HTTPException as exc: raise GatewayNotFound from exc return "{0}?encoding={1}&v=9&compress=zlib-stream".format(data["url"], "json") async def websocket_connect(self, url: str) -> ClientWebSocketResponse: """ Connect to the websocket. parameters: url: the url to connect to """ return await self.__session.ws_connect( url, timeout=30, max_msg_size=0, autoclose=False, headers={"User-Agent": self.user_agent}, compress=0 )

0a3e0181aa1152f21b25e174598bc71d6679ab76

py

Python

config.py

conradsuuna/uac-computer-competency

40f8b165e5432ca22ab97838f424e26650a3d300

config.py

conradsuuna/uac-computer-competency

40f8b165e5432ca22ab97838f424e26650a3d300

config.py

conradsuuna/uac-computer-competency

40f8b165e5432ca22ab97838f424e26650a3d300

from os import environ import psycopg2 from datetime import timedelta from dotenv import load_dotenv load_dotenv() class Config(object): """ app configuration class """ TESTING = False CSRF_ENABLED = True SECRET_KEY = environ.get('SECRET_KEY') USER = environ.get('DB_USER') PASSWORD = environ.get('DB_PASSWORD') DB_NAME = environ.get('DB_NAME') HOST = environ.get('DB_HOST') SQLALCHEMY_DATABASE_URI = f"postgresql://{USER}:{PASSWORD}@{HOST}/{DB_NAME}" SQLALCHEMY_TRACK_MODIFICATIONS = False # jwt configuarations for the user auth api JWT_SECRET_KEY = environ.get('SECRET_KEY') JWT_ACCESS_TOKEN_EXPIRES = timedelta(days=1) # pagination NUM_OF_ITEMS_PER_PAGE = 18 class DevelopmentConfig(Config): """ app development configuration class """ ENV = "development" DEBUG = True SQLALCHEMY_TRACK_MODIFICATIONS = True class ProductionConfig(Config): DEBUG = False SQLALCHEMY_TRACK_MODIFICATIONS = False

0a3e6de6fa0adef7035c5c9d0aedbcc9e7f13b79

py

Python

electrum/version.py

c4pt000/electrum-radiocoin

7cb5f618a9aa8cd03d60191624a0e57cc24646d2

electrum/version.py

c4pt000/electrum-radiocoin

7cb5f618a9aa8cd03d60191624a0e57cc24646d2

electrum/version.py

c4pt000/electrum-radiocoin

7cb5f618a9aa8cd03d60191624a0e57cc24646d2

ELECTRUM_VERSION = '4.1.5-radc' # version of the client package APK_VERSION = '4.1.5.0' # read by buildozer.spec PROTOCOL_VERSION = '1.4' # protocol version requested # The hash of the mnemonic seed must begin with this SEED_PREFIX = '01' # Standard wallet SEED_PREFIX_SW = '100' # Segwit wallet SEED_PREFIX_2FA = '101' # Two-factor authentication SEED_PREFIX_2FA_SW = '102' # Two-factor auth, using segwit def seed_prefix(seed_type): if seed_type == 'standard': return SEED_PREFIX elif seed_type == 'segwit': return SEED_PREFIX_SW elif seed_type == '2fa': return SEED_PREFIX_2FA elif seed_type == '2fa_segwit': return SEED_PREFIX_2FA_SW raise Exception(f"unknown seed_type: {seed_type}")

0a3ee6851d0a7ef05afcdf6a271167449fef0269

py

Python

lib/layers/functions/prior_box.py

arleyzhang/object-detection-pytorch

de96a507e6643a7019b94d92f77219439ccca29f

2018-10-10T03:06:38.000Z

2018-12-18T07:32:30.000Z

lib/layers/functions/prior_box.py

arleyzhang/object-detection-pytorch

de96a507e6643a7019b94d92f77219439ccca29f

lib/layers/functions/prior_box.py

arleyzhang/object-detection-pytorch

de96a507e6643a7019b94d92f77219439ccca29f

2018-10-10T03:06:39.000Z

2018-10-10T03:06:39.000Z

from __future__ import division from math import sqrt as sqrt from itertools import product as product import torch import numpy as np import cv2 from lib.utils.visualize_utils import TBWriter def vis(func): """tensorboard visualization if has writer as input""" def wrapper(*args, **kw): return func(*args, **kw) if kw['tb_writer'] is not None else None return wrapper class PriorBoxBase(object): """Compute priorbox coordinates in center-offset form for each source feature map. """ def __init__(self, cfg): super(PriorBoxBase, self).__init__() self.image_size = cfg.MODEL.IMAGE_SIZE self._steps = cfg.MODEL.STEPS self._cfg_list = [] self._prior_cfg = {} self._clip = cfg.MODEL.CLIP self._variance = cfg.MODEL.VARIANCE for v in self._variance: if v <= 0: raise ValueError('Variances must be greater than 0') def _setup(self, cfg): num_feat = len(self._steps) for item in self._cfg_list: if item not in cfg.MODEL: raise Exception("wrong anchor config!") if len(cfg.MODEL[item]) != num_feat and len(cfg.MODEL[item]) != 0: raise Exception("config {} length does not match step length!".format(item)) self._prior_cfg[item] = cfg.MODEL[item] @property def num_priors(self): """allow prior num calculation before knowing feature map size""" assert self._prior_cfg is not {} return [int(len(self._create_prior(0, 0, k)) / 4) for k in range(len(self._steps))] def _create_prior(self, cx, cy, k): raise NotImplementedError @vis def _image_proc(self, image=None, tb_writer=None): # TODO test with image if isinstance(image, type(None)): image = np.ones((self.image_size[1], self.image_size[0], 3)) elif isinstance(image, str): image = cv2.imread(image, -1) image = cv2.resize(image, (self.image_size[1], self.image_size[0])) return image @vis def _prior_vis(self, anchor, image_ori, feat_idx, tb_writer=None): # TODO add output path to the signature writer = tb_writer.writer prior_num = self.num_priors[feat_idx] # transform coordinates scale = [self.image_size[1], self.image_size[0], self.image_size[1], self.image_size[0]] bboxs = np.array(anchor).reshape((-1, 4)) box_centers = bboxs[:, :2] * scale[:2] # [x, y] # bboxs: [xmin, ymin, xmax, ymax] bboxs = np.hstack((bboxs[:, :2] - bboxs[:, 2:4] / 2, bboxs[:, :2] + bboxs[:, 2:4] / 2)) * scale box_centers = box_centers.astype(np.int32) bboxs = bboxs.astype(np.int32) # visualize each anchor box on a feature map for prior_idx in range(prior_num): image = image_ori.copy() bboxs_ = bboxs[prior_idx::prior_num, :] box_centers_ = box_centers[4 * prior_idx::prior_num, :] for archor, bbox in zip(box_centers_, bboxs_): cv2.circle(image, (archor[0], archor[1]), 1, (0, 0, 255), -1) if archor[0] == archor[1]: # only show diagnal anchors cv2.rectangle(image, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 1) image = image[..., ::-1] image = image.transpose((2,0,1)) writer.add_image('base/feature_map_{}_{}'.format(feat_idx, prior_idx), image, 2) def forward(self, layer_dims, tb_writer=None, image=None): priors = [] image = self._image_proc(image=image, tb_writer=tb_writer) for k in range(len(layer_dims)): prior = [] for i, j in product(range(layer_dims[k][0]), range(layer_dims[k][1])): steps_x = self.image_size[1] / self._steps[k] steps_y = self.image_size[0] / self._steps[k] cx = (j + 0.5) / steps_x # unit center x,y cy = (i + 0.5) / steps_y prior += self._create_prior(cx, cy, k) priors += prior self._prior_vis(prior, image, k, tb_writer=tb_writer) output = torch.Tensor(priors).view(-1, 4) # TODO this clip is meanless, should clip on [xmin, ymin, xmax, ymax] if self._clip: output.clamp_(max=1, min=0) return output class PriorBoxSSD(PriorBoxBase): def __init__(self, cfg): super(PriorBoxSSD, self).__init__(cfg) # self.image_size = cfg['image_size'] self._cfg_list = ['MIN_SIZES', 'MAX_SIZES', 'ASPECT_RATIOS'] self._flip = cfg.MODEL.FLIP self._setup(cfg) def _create_prior(self, cx, cy, k): # as the original paper do prior = [] min_sizes = self._prior_cfg['MIN_SIZES'][k] min_sizes = [min_sizes] if not isinstance(min_sizes, list) else min_sizes for ms in min_sizes: # min square s_i = ms / self.image_size[0] s_j = ms / self.image_size[1] prior += [cx, cy, s_j, s_i] # min max square if len(self._prior_cfg['MAX_SIZES']) != 0: assert type(self._prior_cfg['MAX_SIZES'][k]) is not list # one max size per layer s_i_prime = sqrt(s_i * (self._prior_cfg['MAX_SIZES'][k] / self.image_size[0])) s_j_prime = sqrt(s_j * (self._prior_cfg['MAX_SIZES'][k] / self.image_size[1])) prior += [cx, cy, s_j_prime, s_i_prime] # rectangles by min and aspect ratio for ar in self._prior_cfg['ASPECT_RATIOS'][k]: prior += [cx, cy, s_j * sqrt(ar), s_i / sqrt(ar)] # a vertical box if self._flip: prior += [cx, cy, s_j / sqrt(ar), s_i * sqrt(ar)] return prior # PriorBox = PriorBoxSSD def test_no_vis(cfg, tb_writer): cfg = copy.deepcopy(cfg) cfg['feature_maps'] = [38, 19, 10, 5, 3, 1] cfg['min_sizes'] = [[30], [60], 111, 162, 213, 264] cfg['flip'] = True feat_dim = [list(a) for a in zip(cfg['feature_maps'], cfg['feature_maps'])] p = PriorBoxSSD(cfg) print(p.num_priors) p1 = p.forward(feat_dim) print(p1) def test_filp(cfg, tb_writer): cfg = copy.deepcopy(cfg) cfg['feature_maps'] = [38, 19, 10, 5, 3, 1] cfg['flip'] = True feat_dim = [list(a) for a in zip(cfg['feature_maps'], cfg['feature_maps'])] p = PriorBoxSSD(cfg) p1 = p.forward(feat_dim, tb_writer=tb_writer) cfg['flip'] = False cfg['aspect_ratios'] = [[2, 1 / 2], [2, 1 / 2, 3, 1 / 3], [2, 1 / 2, 3, 1 / 3], [2, 1 / 2, 3, 1 / 3], [2, 1 / 2], [2, 1 / 2]] p = PriorBox(cfg) p2 = p.forward(feat_dim, tb_writer=tb_writer) # print(p2) assert (p2 - p1).sum() < 1e-8 def test_rectangle(cfg, tb_writer): cfg = copy.deepcopy(cfg) cfg['feature_maps'] = [38, 19, 10, 5, 3, 1] cfg['min_sizes'] = [30, 60, 111, 162, 213, 264] cfg['flip'] = True # feat_dim = [list(a) for a in zip(cfg['feature_maps'], cfg['feature_maps'])] # cfg['image_size'] = [300, 300] # feat_dim = [list(a) for a in zip(cfg['feature_maps'], [item * 2 for item in cfg['feature_maps']])] # cfg['image_size'] = [300, 600] feat_dim = [list(a) for a in zip([item * 2 for item in cfg['feature_maps']], cfg['feature_maps'])] cfg['image_size'] = [600, 300] p = PriorBoxSSD(cfg) p1 = p.forward(feat_dim, tb_writer=tb_writer) print(p1.shape) if __name__ == '__main__': import copy # from lib.datasets.config import ssd_voc_vgg as cfg # from lib.utils.visualize_utils import TBWriter # tb_writer = TBWriter(log_dir, {'epoch': 50}) # # test_no_vis(cfg, tb_writer) # test_filp(cfg, tb_writer) # test_rectangle(cfg, tb_writer) print('haha') from lib.utils.config import cfg print(cfg)

0a3fe7e6abe2393d5617b3058cbf7b54468e33ee

py

Python

python/Gaffer/SequencePath.py

cwmartin/gaffer

1f8a0f75522105c9d5efefac6d55cb61c1038909

python/Gaffer/SequencePath.py

cwmartin/gaffer

1f8a0f75522105c9d5efefac6d55cb61c1038909

python/Gaffer/SequencePath.py

cwmartin/gaffer

1f8a0f75522105c9d5efefac6d55cb61c1038909

########################################################################## # # Copyright (c) 2012-2013, Image Engine Design Inc. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above # copyright notice, this list of conditions and the following # disclaimer. # # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following # disclaimer in the documentation and/or other materials provided with # the distribution. # # * Neither the name of John Haddon nor the names of # any other contributors to this software may be used to endorse or # promote products derived from this software without specific prior # written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS # IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ########################################################################## import IECore import Gaffer class SequencePath( Gaffer.Path ) : def __init__( self, path, root="/", minSequenceSize=1, filter=None ) : if not isinstance( path, Gaffer.Path ) : path = Gaffer.FileSystemPath( path, root ) Gaffer.Path.__init__( self, path[:], path.root(), filter=filter ) # we use the seed for creating base paths whenever we need them self.__basePathSeed = path self.__minSequenceSize = minSequenceSize def isValid( self ) : for p in self.__basePaths() : if not p.isValid() : return False return True def isLeaf( self ) : for p in self.__basePaths() : if not p.isLeaf() : return False return True def info( self ) : result = Gaffer.Path.info( self ) if result is None : return None def average( values ) : return sum( values ) / len( values ) def mostCommon( values ) : counter = {} for value in values : if value in counter : counter[value] += 1 else : counter[value] = 1 maxCount = 0 mostCommonValue = None for value, count in counter.items() : if count > maxCount : mostCommonValue = value maxCount = count return mostCommonValue combiners = { "fileSystem:owner" : mostCommon, "fileSystem:group" : mostCommon, "fileSystem:modificationTime" : max, "fileSystem:accessTime" : max, "fileSystem:size" : sum, } infos = [ path.info() for path in self.__basePaths() ] if len( infos ) : for key, exampleValue in infos[0].items() : if key in result : continue combiner = combiners.get( key, None ) if combiner is None : if isinstance( exampleValue, ( int, float ) ) : combiner = average elif isinstance( exampleValue, basestring ) : combiner = mostCommon if combiner is not None : values = [ i[key] for i in infos ] result[key] = combiner( values ) return result def _children( self ) : p = self.__basePath( self ) children = p.children() nonLeafPaths = [] leafPathStrings = [] for child in children : if child.isLeaf() : leafPathStrings.append( str( child ) ) else : nonLeafPaths.append( child ) sequences = IECore.findSequences( leafPathStrings, self.__minSequenceSize ) result = [] for path in sequences + nonLeafPaths : result.append( SequencePath( self.__basePath( str( path ) ), minSequenceSize=self.__minSequenceSize, filter = self.getFilter() ) ) return result def copy( self ) : result = SequencePath( self.__basePathSeed, minSequenceSize = self.__minSequenceSize, filter = self.getFilter() ) result.setFromPath( self ) return result def __basePath( self, path ) : result = self.__basePathSeed.copy() if isinstance( path, basestring ) : result.setFromString( path ) else : result.setFromPath( path ) return result def __basePaths( self ) : sequence = None with IECore.IgnoredExceptions( Exception ) : sequence = IECore.FileSequence( str( self ) ) result = [] if sequence : for f in sequence.fileNames() : result.append( self.__basePath( f ) ) else : result.append( self.__basePath( self ) ) return result def __isSequence( self ) : s = str( self ) if IECore.FileSequence.fileNameValidator().match( s ) : return True return False

0a4049bea9cce33edfb9f0362df0cd2e91b7aa1a

py

Python

reo/migrations/0121_merge_20211001_1841.py

NREL/REopt_API

fbc70f3b0cdeec9ee220266d6b3b0c5d64f257a6

2022-01-29T12:10:10.000Z

2022-03-28T13:45:20.000Z

reo/migrations/0121_merge_20211001_1841.py

NREL/reopt_api

fbc70f3b0cdeec9ee220266d6b3b0c5d64f257a6

2022-02-01T18:23:18.000Z

2022-03-31T17:22:17.000Z

reo/migrations/0121_merge_20211001_1841.py

NREL/REopt_API

fbc70f3b0cdeec9ee220266d6b3b0c5d64f257a6

2022-02-08T19:44:40.000Z

2022-03-12T11:05:36.000Z

# Generated by Django 3.1.13 on 2021-10-01 18:41 from django.db import migrations class Migration(migrations.Migration): dependencies = [ ('reo', '0117_financialmodel_generator_fuel_escalation_pct'), ('reo', '0120_auto_20210927_2046'), ('reo', '0121_auto_20211012_0305') ] operations = [ ]

0a42c30234b3cb9b1bf3706f896598d1f485e00b

py

Python

PhysicsTools/Heppy/python/analyzers/objects/TauAnalyzer.py

ckamtsikis/cmssw

ea19fe642bb7537cbf58451dcf73aa5fd1b66250

2015-01-11T21:03:51.000Z

2022-03-25T21:14:00.000Z

PhysicsTools/Heppy/python/analyzers/objects/TauAnalyzer.py

ckamtsikis/cmssw

ea19fe642bb7537cbf58451dcf73aa5fd1b66250

2015-01-02T00:14:40.000Z

2022-03-31T23:26:05.000Z

PhysicsTools/Heppy/python/analyzers/objects/TauAnalyzer.py

ckamtsikis/cmssw

ea19fe642bb7537cbf58451dcf73aa5fd1b66250

2015-01-02T05:53:18.000Z

2022-03-31T17:24:21.000Z

from PhysicsTools.Heppy.analyzers.core.Analyzer import Analyzer from PhysicsTools.Heppy.analyzers.core.AutoHandle import AutoHandle from PhysicsTools.Heppy.physicsobjects.Tau import Tau from PhysicsTools.HeppyCore.utils.deltar import deltaR, matchObjectCollection3 import PhysicsTools.HeppyCore.framework.config as cfg class TauAnalyzer( Analyzer ): def __init__(self, cfg_ana, cfg_comp, looperName ): super(TauAnalyzer,self).__init__(cfg_ana,cfg_comp,looperName) #---------------------------------------- # DECLARATION OF HANDLES OF LEPTONS STUFF #---------------------------------------- def declareHandles(self): super(TauAnalyzer, self).declareHandles() self.handles['taus'] = AutoHandle( ('slimmedTaus',''),'std::vector<pat::Tau>') def beginLoop(self, setup): super(TauAnalyzer,self).beginLoop(setup) self.counters.addCounter('events') count = self.counters.counter('events') count.register('all events') count.register('has >=1 tau at preselection') count.register('has >=1 selected taus') count.register('has >=1 other taus') #------------------ # MAKE LEPTON LISTS #------------------ def makeTaus(self, event): event.inclusiveTaus = [] event.selectedTaus = [] event.otherTaus = [] #get all alltaus = map( Tau, self.handles['taus'].product() ) #make inclusive taus for tau in alltaus: tau.associatedVertex = event.goodVertices[0] if len(event.goodVertices)>0 else event.vertices[0] tau.lepVeto = False tau.idDecayMode = tau.tauID("decayModeFinding") tau.idDecayModeNewDMs = tau.tauID("decayModeFindingNewDMs") if hasattr(self.cfg_ana, 'inclusive_decayModeID') and self.cfg_ana.inclusive_decayModeID and not tau.tauID(self.cfg_ana.inclusive_decayModeID): continue tau.inclusive_lepVeto = False if self.cfg_ana.inclusive_vetoLeptons: for lep in event.selectedLeptons: if deltaR(lep.eta(), lep.phi(), tau.eta(), tau.phi()) < self.cfg_ana.inclusive_leptonVetoDR: tau.inclusive_lepVeto = True if tau.inclusive_lepVeto: continue if self.cfg_ana.inclusive_vetoLeptonsPOG: if not tau.tauID(self.cfg_ana.inclusive_tauAntiMuonID): tau.inclusive_lepVeto = True if not tau.tauID(self.cfg_ana.inclusive_tauAntiElectronID): tau.inclusive_lepVeto = True if tau.inclusive_lepVeto: continue if tau.pt() < self.cfg_ana.inclusive_ptMin: continue if abs(tau.eta()) > self.cfg_ana.inclusive_etaMax: continue if abs(tau.dxy()) > self.cfg_ana.inclusive_dxyMax or abs(tau.dz()) > self.cfg_ana.inclusive_dzMax: continue def id3(tau,X): """Create an integer equal to 1-2-3 for (loose,medium,tight)""" return tau.tauID(X%"Loose") + tau.tauID(X%"Medium") + tau.tauID(X%"Tight") def id5(tau,X): """Create an integer equal to 1-2-3-4-5 for (very loose, loose, medium, tight, very tight)""" return id3(tau, X) + tau.tauID(X%"VLoose") + tau.tauID(X%"VTight") def id6(tau,X): """Create an integer equal to 1-2-3-4-5-6 for (very loose, loose, medium, tight, very tight, very very tight)""" return id5(tau, X) + tau.tauID(X%"VVTight") tau.idMVA = id6(tau, "by%sIsolationMVArun2v1DBoldDMwLT") tau.idMVANewDM = id6(tau, "by%sIsolationMVArun2v1DBnewDMwLT") tau.idCI3hit = id3(tau, "by%sCombinedIsolationDeltaBetaCorr3Hits") tau.idAntiMu = tau.tauID("againstMuonLoose3") + tau.tauID("againstMuonTight3") tau.idAntiE = id5(tau, "againstElectron%sMVA6") #print "Tau pt %5.1f: idMVA2 %d, idCI3hit %d, %s, %s" % (tau.pt(), tau.idMVA2, tau.idCI3hit, tau.tauID(self.cfg_ana.tauID), tau.tauID(self.cfg_ana.tauLooseID)) if tau.tauID(self.cfg_ana.inclusive_tauID): event.inclusiveTaus.append(tau) for tau in event.inclusiveTaus: tau.loose_lepVeto = False if self.cfg_ana.loose_vetoLeptons: for lep in event.selectedLeptons: if deltaR(lep.eta(), lep.phi(), tau.eta(), tau.phi()) < self.cfg_ana.loose_leptonVetoDR: tau.loose_lepVeto = True if self.cfg_ana.loose_vetoLeptonsPOG: if not tau.tauID(self.cfg_ana.loose_tauAntiMuonID): tau.loose_lepVeto = True if not tau.tauID(self.cfg_ana.loose_tauAntiElectronID): tau.loose_lepVeto = True if tau.tauID(self.cfg_ana.loose_decayModeID) and \ tau.pt() > self.cfg_ana.loose_ptMin and abs(tau.eta()) < self.cfg_ana.loose_etaMax and \ abs(tau.dxy()) < self.cfg_ana.loose_dxyMax and abs(tau.dz()) < self.cfg_ana.loose_dzMax and \ tau.tauID(self.cfg_ana.loose_tauID) and not tau.loose_lepVeto: event.selectedTaus.append(tau) else: event.otherTaus.append(tau) event.inclusiveTaus.sort(key = lambda l : l.pt(), reverse = True) event.selectedTaus.sort(key = lambda l : l.pt(), reverse = True) event.otherTaus.sort(key = lambda l : l.pt(), reverse = True) self.counters.counter('events').inc('all events') if len(event.inclusiveTaus): self.counters.counter('events').inc('has >=1 tau at preselection') if len(event.selectedTaus): self.counters.counter('events').inc('has >=1 selected taus') if len(event.otherTaus): self.counters.counter('events').inc('has >=1 other taus') def matchTaus(self, event): match = matchObjectCollection3(event.inclusiveTaus, event.gentaus, deltaRMax = 0.5) for lep in event.inclusiveTaus: gen = match[lep] lep.mcMatchId = 1 if gen else 0 lep.genp = gen def process(self, event): self.readCollections( event.input ) self.makeTaus(event) if not self.cfg_comp.isMC: return True if hasattr(event, 'gentaus'): self.matchTaus(event) return True # Find the definitions of the tau ID strings here: # http://cmslxr.fnal.gov/lxr/source/PhysicsTools/PatAlgos/python/producersLayer1/tauProducer_cfi.py setattr(TauAnalyzer,"defaultConfig",cfg.Analyzer( class_object = TauAnalyzer, # inclusive very loose hadronic tau selection inclusive_ptMin = 18, inclusive_etaMax = 9999, inclusive_dxyMax = 1000., inclusive_dzMax = 0.4, inclusive_vetoLeptons = False, inclusive_leptonVetoDR = 0.4, inclusive_decayModeID = "decayModeFindingNewDMs", # ignored if not set or "" inclusive_tauID = "decayModeFindingNewDMs", inclusive_vetoLeptonsPOG = False, # If True, the following two IDs are required inclusive_tauAntiMuonID = "", inclusive_tauAntiElectronID = "", # loose hadronic tau selection loose_ptMin = 18, loose_etaMax = 9999, loose_dxyMax = 1000., loose_dzMax = 0.2, loose_vetoLeptons = True, loose_leptonVetoDR = 0.4, loose_decayModeID = "decayModeFindingNewDMs", # ignored if not set or "" loose_tauID = "byLooseCombinedIsolationDeltaBetaCorr3Hits", loose_vetoLeptonsPOG = False, # If True, the following two IDs are required loose_tauAntiMuonID = "againstMuonLoose3", loose_tauAntiElectronID = "againstElectronLooseMVA5" ) )

0a42e80075481314be34a3f3fd3ff44396a763e9

py

Python

vize/170401038.py

omuryorulmaz/kriptografi

04c22e4f05f126b14f41842597a7b27065326670

2020-04-15T12:06:42.000Z

2022-01-21T10:35:51.000Z