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 __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 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)
