def __init__(self, **kwargs): self._input_sock = None self._output_sock = None self._control_sock = None # determine if outgoing messages should enable NOBLOCK on send # default behaviour is to block on a send call till receiver is present self.no_block_send = False # configure the interrupt handling self._stop = True signal.signal(signal.SIGINT, self._signal_interrupt_handler) # a regular hearbeat interval must be set to the default. self.heartbeat = 3 # seconds # create the zmq context self.zmq_ctx = Context() # set the default input receive handler, if none has been assigned if not hasattr(self, 'input_recv_handler'): self.input_recv_handler = self._default_recv_handler # set the default handler, if none has been assigned. if not hasattr(self, '_command_handler'): self._command_handler = self._default_command_handler # construct the poller self._poll = Poller() # monitoring of message stream is off by default self.monitor_stream = False Scaffold.__init__(self, **kwargs)
def constructScaffoldGlobalSection(trace,setsOfPNodes,globalBorder,useDeltaKernels = False, deltaKernelArgs = None, updateValue = False, updatedNodes = set()): while True: cDRG,cAbsorbing,cAAA = set(),set(),set() indexAssignments = {} assert isinstance(setsOfPNodes,list) for i in range(len(setsOfPNodes)): assert isinstance(setsOfPNodes[i],set) extendCandidateScaffoldGlobalSection(trace,setsOfPNodes[i],globalBorder,cDRG,cAbsorbing,cAAA,indexAssignments,i) brush = findBrush(trace,cDRG) drg,absorbing,aaa = removeBrush(cDRG,cAbsorbing,cAAA,brush) border = findBorder(trace,drg,absorbing,aaa) regenCounts = computeRegenCounts(trace,drg,absorbing,aaa,border,brush) if globalBorder is not None: assert globalBorder in border assert globalBorder in drg regenCounts[globalBorder] = 1 lkernels = loadKernels(trace,drg,aaa,useDeltaKernels,deltaKernelArgs) borderSequence = assignBorderSequnce(border,indexAssignments,len(setsOfPNodes)) scaffold = Scaffold(setsOfPNodes,regenCounts,absorbing,aaa,borderSequence,lkernels,brush) if not updateValue or not updateValuesAtScaffold(trace,scaffold,updatedNodes,useDeltaKernels,deltaKernelArgs): break scaffold.globalBorder = globalBorder scaffold.local_children = list(trace.childrenAt(globalBorder)) if globalBorder is not None else [] scaffold.N = len(scaffold.local_children) return scaffold
def test_run_scenario_integ(monkeypatch): dyn_resource = boto3.resource('dynamodb') table_name = 'partiql-single-scenario-test-table' scaff = Scaffold(dyn_resource) wrapper = scenario.PartiQLWrapper(dyn_resource) with patch('builtins.print') as mock_print: scenario.run_scenario(scaff, wrapper, table_name) mock_print.assert_any_call("\nThanks for watching!")
def test_run_scenario(make_stubber, stub_runner, monkeypatch, error_code, stop_on_method): dyn_resource = boto3.resource('dynamodb') dyn_stubber = make_stubber(dyn_resource.meta.client) table_name = 'test-table' scaff = Scaffold(dyn_resource) wrapper = scenario.PartiQLWrapper(dyn_resource) with stub_runner(error_code, stop_on_method) as runner: runner.add(dyn_stubber.stub_create_table, table_name, [{ 'name': 'year', 'type': 'N', 'key_type': 'HASH' }, { 'name': 'title', 'type': 'S', 'key_type': 'RANGE' }], { 'read': 10, 'write': 10 }) runner.add(dyn_stubber.stub_describe_table, table_name) runner.add(dyn_stubber.stub_execute_statement, ANY, ANY, []) runner.add(dyn_stubber.stub_execute_statement, ANY, ANY, [{ 'title': { 'S': 'test' }, 'year': { 'N': '2000' } }]) runner.add(dyn_stubber.stub_execute_statement, ANY, ANY, []) runner.add(dyn_stubber.stub_execute_statement, ANY, ANY, [{ 'title': { 'S': 'test' }, 'year': { 'N': '2000' } }]) runner.add(dyn_stubber.stub_execute_statement, ANY, ANY, []) runner.add(dyn_stubber.stub_delete_table, table_name) if error_code is None: scenario.run_scenario(scaff, wrapper, table_name) else: with pytest.raises(ClientError) as exc_info: scenario.run_scenario(scaff, wrapper, table_name) assert exc_info.value.response['Error']['Code'] == error_code
def main(): args = parse_arguments() scaffold = Scaffold() with open(args.program, "r") as bfCode: bf = bfCode.read() convertedCode = convert_brainfuck(bf, scaffold.offset["program"], scaffold) scaffold.append(convertedCode) # Create an infinite loop at the end to prevent chip-8 from crashing self_loop_address = 0x200 + len(scaffold.code) * 2 self_loop_code = 0x1000 | self_loop_address scaffold.append([self_loop_code]) output_binary = convert_to_program(scaffold.code) with open(args.output, "wb") as output_file: output_file.write(output_binary)
import torch_geometric as tg from torch_geometric.datasets import ModelNet from torch_geometric.data import DataLoader, DataListLoader from torch_geometric.utils import degree, get_laplacian, remove_self_loops import torch_scatter as tscatter import numpy as np import random, math, colorama, os, json from collections import defaultdict from tqdm import * from itertools import product from scaffold import Scaffold from utils import * from train_bf import process_batch from dataloader import ADataListLoader, MPEGDataset, MPEGTransform scaf = Scaffold() scaf.debug() sprint = scaf.print warn = scaf.warn class NaiveBilateralFilter(MessagePassing): """ Naive BF. gamma: filter strength sigma: kernel variance k: total neighbors number in kNN $$ x_i=\gamma x_i + (1-\gamma)\frac{\sum_{v_j\in N_i}x_j \exp(\sigma\|x_j-x_i\|^{2})} {\sum_{v_j\in N_i} \exp(\sigma\|x_j-x_i\|^{2})}
output = wrapper.dyn_resource.meta.client.execute_statement( Statement=f'SELECT title, info.rating FROM "{table_name}"') pprint(output['Items']) print('-' * 88) print(f"Deleting a batch of movies from the table.") statements = [f"DELETE FROM \"{table_name}\" WHERE title=? AND year=?" ] * len(movie_data) params = [[movie['title'], movie['year']] for movie in movie_data] wrapper.run_partiql(statements, params) print("Success!") print('-' * 88) print(f"Deleting table '{table_name}'...") scaffold.delete_table() print('-' * 88) print("\nThanks for watching!") print('-' * 88) if __name__ == '__main__': try: dyn_res = boto3.resource('dynamodb') scaffold = Scaffold(dyn_res) movies = PartiQLBatchWrapper(dyn_res) run_scenario(scaffold, movies, 'doc-example-table-partiql-movies') except Exception as e: print(f"Something went wrong with the demo! Here's what: {e}") # snippet-end:[python.example_code.dynamodb.Scenario_PartiQLBatch]
def generate_scaffold(config, column_preferences, model_grouping, schema, table): scaffold = Scaffold(config, column_preferences, model_grouping, schema, table)
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see <https://www.gnu.org/licenses/>. # # # Copyright 2019 Ledger SAS, written by Olivier Hériveaux from scaffold import Scaffold from scaffold.iso7816 import Smartcard, T1RedundancyCode, ProtocolError import sys scaffold = Scaffold() sc = Smartcard(scaffold) if not sc.card_inserted: print('No card inserted') sys.exit(1) scaffold.power.dut = 1 atr = sc.reset() print('ATR: ' + atr.hex()) print('Protocols: ' + ', '.join(f"T={x}" for x in sc.protocols)) if 1 in sc.protocols: edc_dict = { T1RedundancyCode.LRC: 'LRC (1 byte)', T1RedundancyCode.CRC: 'CRC (2 bytes)' }
parser = argparse.ArgumentParser(description='This script uses Scaffold to ' 'communicate with STM32 devices. It allows loading and executing code.') default_com = {'win32': 'COM0'}.get(sys.platform, '/dev/ttyUSB0') parser.add_argument('-d', '--dev', help='Scaffold serial device path. ' f'If not specified, {default_com} is used on Linux by default.', default=default_com) parser.add_argument('-l', '--load', help='Load binary into device.') parser.add_argument('--ram', help='Load binary into RAM memory.') parser.add_argument('-r', '--run', help='Reset and run device from Flash ' 'memory.', action='store_true') parser.add_argument('-j', '--jump', help='Jump to RAM memory.') parser.add_argument('--erase', help='Erase Flash memory.', action='store_true') args = parser.parse_args() # Connect to Scaffold board scaffold = Scaffold(args.dev) stm = STM32(scaffold) # Try to connect to ST bootloader by sending 0x7f byte on USART and expecting a # response from the device bootloader. This may fail if the device is locked in # RDP2 state. try: stm.startup_bootloader() except TimeoutError as e: print('Failed to communicate with bootloader!') sys.exit() print('Communication initiated') pid = stm.get_id() print(f'Product ID: 0x{pid:04x}') if stm.device is not None:
# the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see <https://www.gnu.org/licenses/>. # # # Copyright 2019 Ledger SAS, written by Olivier Hériveaux from scaffold import Scaffold from scaffold.iso7816 import Smartcard from binascii import hexlify scaffold = Scaffold('/dev/ttyUSB0') sc = Smartcard(scaffold) scaffold.power.dut = 1 atr = sc.reset() print('ATR: ' + hexlify(atr).decode()) info = sc.find_info() if info: print('Card found in ATR list:') for line in info: print(' ' + line) else: print('No info found on this card.')
import cProfile import numpy as np import os, sys, pstats from time import sleep sys.path.append(os.path.join(os.path.dirname(__file__), "..")) from scaffold import Scaffold from scaffold.config import ScaffoldIniConfig config = ScaffoldIniConfig('../test.ini') instance = Scaffold(config) for i in range(1, 40): config.resize(100 + i * 20, 100 + i * 20) instance.resetNetworkCache() cProfile.run('instance.compileNetworkArchitecture()', 'compile_stats') p = pstats.Stats('compile_stats') p.strip_dirs().sort_stats('cumulative').print_stats('place', 25) print('square size:', config.X) sleep(1)