code stringlengths 281 23.7M |
|---|
def test_cli_with_poetry(poetry_venv_factory: PoetryVenvFactory) -> None:
with poetry_venv_factory('project_with_poetry') as virtual_env:
issue_report = f'{uuid.uuid4()}.json'
result = virtual_env.run(f'deptry . -o {issue_report}')
assert (result.returncode == 1)
assert (get_issues_report(Path(issue_report)) == [{'error': {'code': 'DEP002', 'message': "'isort' defined as a dependency but not used in the codebase"}, 'module': 'isort', 'location': {'file': str(Path('pyproject.toml')), 'line': None, 'column': None}}, {'error': {'code': 'DEP002', 'message': "'requests' defined as a dependency but not used in the codebase"}, 'module': 'requests', 'location': {'file': str(Path('pyproject.toml')), 'line': None, 'column': None}}, {'error': {'code': 'DEP004', 'message': "'black' imported but declared as a dev dependency"}, 'module': 'black', 'location': {'file': str(Path('src/main.py')), 'line': 4, 'column': 0}}, {'error': {'code': 'DEP004', 'message': "'mypy' imported but declared as a dev dependency"}, 'module': 'mypy', 'location': {'file': str(Path('src/main.py')), 'line': 6, 'column': 0}}, {'error': {'code': 'DEP004', 'message': "'pytest' imported but declared as a dev dependency"}, 'module': 'pytest', 'location': {'file': str(Path('src/main.py')), 'line': 7, 'column': 0}}, {'error': {'code': 'DEP004', 'message': "'pytest_cov' imported but declared as a dev dependency"}, 'module': 'pytest_cov', 'location': {'file': str(Path('src/main.py')), 'line': 8, 'column': 0}}, {'error': {'code': 'DEP001', 'message': "'white' imported but missing from the dependency definitions"}, 'module': 'white', 'location': {'file': str(Path('src/main.py')), 'line': 9, 'column': 0}}]) |
class SurfaceIntegrationMonitor(Monitor, ABC):
normal_dir: Direction = pydantic.Field(None, title='Normal Vector Orientation', description="Direction of the surface monitor's normal vector w.r.t. the positive x, y or z unit vectors. Must be one of ``'+'`` or ``'-'``. Applies to surface monitors only, and defaults to ``'+'`` if not provided.")
exclude_surfaces: Tuple[(BoxSurface, ...)] = pydantic.Field(None, title='Excluded Surfaces', description='Surfaces to exclude in the integration, if a volume monitor.')
def integration_surfaces(self):
if (self.size.count(0.0) == 0):
return self.surfaces_with_exclusion(**self.dict())
return [self]
_validator(skip_on_failure=True)
def normal_dir_exists_for_surface(cls, values):
normal_dir = values.get('normal_dir')
name = values.get('name')
size = values.get('size')
if (size.count(0.0) != 1):
if (normal_dir is not None):
log.warning(f'The ``normal_dir`` field is relevant only for surface monitors and will be ignored for monitor {name}, which is a box.')
elif (normal_dir is None):
values['normal_dir'] = '+'
return values
_validator(skip_on_failure=True)
def check_excluded_surfaces(cls, values):
exclude_surfaces = values.get('exclude_surfaces')
if (exclude_surfaces is None):
return values
name = values.get('name')
size = values.get('size')
if (size.count(0.0) > 0):
raise SetupError(f"Can't specify ``exclude_surfaces`` for surface monitor {name}; valid for box monitors only.")
return values
def _storage_size_solver(self, num_cells: int, tmesh: ArrayFloat1D) -> int:
num_sample = len(getattr(self, 'freqs', [0]))
return (((BYTES_COMPLEX * num_cells) * num_sample) * 6) |
def _get_normal_forms(form):
terms = [(~ logic_x[1].copy()), (((~ logic_x[1].copy()) | logic_x[2].copy()) & (logic_x[3].copy() | (~ logic_x[1].copy()))), ((((~ logic_x[1].copy()) | logic_x[2].copy()) & (logic_x[3].copy() | (~ logic_x[1].copy()))) & (logic_x[4].copy() | (logic_x[2].copy() & logic_x[3].copy()))), ((logic_x[2].copy() & (~ logic_x[1].copy())) | (logic_x[3].copy() & (~ logic_x[1].copy()))), (((logic_x[1].copy() | (logic_x[2].copy() & (~ logic_x[1].copy()))) | (logic_x[3].copy() & (~ (logic_x[1].copy() | logic_x[2].copy())))) | ((logic_x[5].copy() & logic_x[4].copy()) & (~ logic_x[1].copy()))), (((logic_x[2].copy() | logic_x[4].copy()) & (~ logic_x[1].copy())) | ((logic_x[3].copy() | logic_x[4].copy()) & (logic_x[5].copy() | (~ logic_x[1].copy()))))]
if (form == 'cnf'):
result = [(~ logic_x[1].copy()), ((logic_x[2].copy() | (~ logic_x[1].copy())) & (logic_x[3].copy() | (~ logic_x[1].copy()))), ((((logic_x[2].copy() | (~ logic_x[1].copy())) & (logic_x[3].copy() | (~ logic_x[1].copy()))) & (logic_x[2].copy() | logic_x[4].copy())) & (logic_x[4].copy() | logic_x[3].copy())), ((logic_x[2].copy() | logic_x[3].copy()) & (~ logic_x[1].copy())), ((((logic_x[1].copy() | logic_x[2].copy()) | logic_x[3].copy()) | logic_x[5].copy()) & (((logic_x[1].copy() | logic_x[4].copy()) | logic_x[2].copy()) | logic_x[3].copy())), ((((logic_x[2].copy() | logic_x[3].copy()) | logic_x[4].copy()) & (((~ logic_x[1].copy()) | logic_x[3].copy()) | logic_x[4].copy())) & ((~ logic_x[1].copy()) | logic_x[5].copy()))]
elif (form == 'dnf'):
result = [Not(z3_symbol[1]), Or(Not(z3_symbol[1]), And(z3_symbol[3], z3_symbol[2])), Or(And(z3_symbol[3], z3_symbol[2]), And(z3_symbol[4], Not(z3_symbol[1]))), Or(And(z3_symbol[2], Not(z3_symbol[1])), And(z3_symbol[3], Not(z3_symbol[1]))), Or(z3_symbol[1], z3_symbol[2], z3_symbol[3], And(z3_symbol[5], z3_symbol[4]))]
else:
raise ValueError(f'wrong input')
return [(term, normal_form) for (term, normal_form) in zip(terms, result)] |
class PredictionTable(Base):
__tablename__ = 'prediction'
id = Column(Integer, primary_key=True)
lpep_pickup_datetime = Column(Float)
PULocationID = Column(Integer)
DOLocationID = Column(Integer)
passenger_count = Column(Integer)
trip_distance = Column(Float)
fare_amount = Column(Float)
total_amount = Column(Float)
uuid = Column(String)
duration_min = Column(Float)
predictions = Column(Float) |
def test_functional_block_single_arg_lambda_unsqueeze():
in_dict = build_input_dict(dims=[100, 64])
net: FunctionalBlock = FunctionalBlock(in_keys='in_key', out_keys='out_key', in_shapes=(100, 64), func=(lambda value: torch.unsqueeze(value, dim=(- 1))))
str(net)
out_dict = net(in_dict)
assert isinstance(out_dict, Dict)
assert set(net.out_keys).issubset(set(out_dict.keys()))
assert (out_dict[net.out_keys[0]].shape == (100, 64, 1)) |
class EventHandler(object):
def __init__(self):
self.tab = None
self.token = None
self.is_first_request = False
self.post_data = {}
def set_tab(self, t):
self.tab = t
def set_token(self, t):
self.token = t
def set_post_data(self, pd):
self.post_data = pd
def on_request_intercepted(self, **kwargs):
new_args = {'interceptionId': kwargs['interceptionId']}
if self.is_first_request:
self.is_first_request = False
extra_headers = {'Requested-by': 'Chromium', 'Authorization': ('Token ' + self.token)}
request = kwargs.get('request')
request['headers'].update(extra_headers)
new_args.update({'url': request['url'], 'method': 'POST', 'headers': request['headers'], 'postData': urllib.urlencode(self.post_data)})
self.tab.Network.continueInterceptedRequest(**new_args) |
class Plotly2D():
def __init__(self, ui):
self.page = ui.page
self.chartFamily = 'Plotly'
def line(self, record=None, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'type': 'line', 'mode': 'lines+markers'})
data = self.page.data.plotly.xy(record, y_columns, x_axis)
line_chart = graph.GraphPlotly.Line(self.page, width, height, (options or {}), html_code, profile)
line_chart.options.responsive = True
line_chart.colors(self.page.theme.charts)
for d in data['datasets']:
line_chart.add_trace(d)
return line_chart
def bar(self, record=None, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'type': 'bar', 'mode': None})
data = self.page.data.plotly.xy(record, y_columns, x_axis)
bar_chart = graph.GraphPlotly.Bar(self.page, width, height, options, html_code, profile)
bar_chart.colors(self.page.theme.charts)
bar_chart.options.responsive = True
for d in data['datasets']:
bar_chart.add_trace(d)
return bar_chart
def hbar(self, record, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'type': 'bar', 'mode': None, 'attrs': {'orientation': 'h'}})
data = self.page.data.plotly.xy(record, y_columns, x_axis)
bar_chart = graph.GraphPlotly.Bar(self.page, width, height, options, html_code, profile)
bar_chart.colors(self.page.theme.charts)
for d in data['datasets']:
bar_chart.add_trace(d, type='bar')
bar_chart.data.orientation = 'h'
return bar_chart
def scatter(self, record=None, y_columns=None, x_axis=None, text_column=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'text_column': text_column, 'type': 'scatter', 'mode': ('markers+text' if (text_column is not None) else 'markers')})
data = self.page.data.plotly.xy_text(record, y_columns, x_axis, text_column, options={'agg': options.get('agg', 'distinct')})
sc_chart = graph.GraphPlotly.Line(self.page, width, height, (options or {}), html_code, profile)
sc_chart.colors(self.page.theme.charts)
sc_chart.options.responsive = True
for (i, d) in enumerate(data['datasets']):
sc_chart.add_trace(d, mode=options['mode'], type=options['type'])
sc_chart.data.marker.color = self.page.theme.charts[i]
if (text_column is not None):
sc_chart.data.text = d['text']
sc_chart.layout.no_background()
return sc_chart
def timeseries(self, record, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'mode': 'lines', 'type': 'scatter'})
data = self.page.data.plotly.xy(record, y_columns, x_axis)
sc_chart = graph.GraphPlotly.Line(self.page, width, height, options, html_code, profile)
sc_chart.colors(self.page.theme.charts)
for d in data['datasets']:
sc_chart.add_trace(d)
return sc_chart
def scattergl(self, record, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'mode': 'markers', 'type': 'scattergl'})
data = self.page.data.plotly.xy(record, y_columns, x_axis)
sc_chart = graph.GraphPlotly.Line(self.page, width, height, (options or {}), html_code, profile)
sc_chart.colors(self.page.theme.charts)
for d in data['datasets']:
sc_chart.add_trace(d, type='scattergl', mode='markers')
return sc_chart
def histogram(self, record, y_columns=None, x_columns=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
data = []
histo_axis = (('y', y_columns) if (y_columns is not None) else ('x', x_columns))
for y in histo_axis[1]:
series = {histo_axis[0]: []}
for rec in record:
if (y in rec):
series[histo_axis[0]].append(float(rec[y]))
data.append(series)
histo_chart = graph.GraphPlotly.Bar(self.page, width, height, (options or {}), html_code, profile)
histo_chart.colors(self.page.theme.charts)
for d in data:
histo_chart.add_trace(d, type='histogram')
return histo_chart
def pie(self, record=None, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'type': 'pie', 'marker': {'colors': self.page.theme.charts}, 'mode': None, 'attrs': {'orientation': 'h'}})
data = self.page.data.plotly.xy(record, y_columns, x_axis)
pie_chart = graph.GraphPlotly.Pie(self.page, width, height, (options or {}), html_code, profile)
pie_chart.colors(self.page.theme.charts)
pie_chart.options.responsive = True
for d in data['datasets']:
pie_chart.add_trace({'label': d['x'], 'values': d['y']})
pie_chart.data.marker.colors = self.page.theme.charts
return pie_chart
def donut(self, record=None, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'type': 'pie', 'marker': {'colors': self.page.theme.charts}, 'mode': None, 'attrs': {'orientation': 'h'}})
data = self.page.data.plotly.xy(record, y_columns, x_axis)
pie_chart = graph.GraphPlotly.Pie(self.page, width, height, (options or {}), html_code, profile)
pie_chart.colors(self.page.theme.charts)
pie_chart.options.responsive = True
for d in data['datasets']:
pie_chart.add_trace({'label': d['x'], 'values': d['y']})
pie_chart.data.marker.colors = self.page.theme.charts
pie_chart.data.hole = 0.4
return pie_chart
def area(self, record, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'type': 'scatter', 'attrs': {'fill': 'tozeroy'}})
data = self.page.data.plotly.xy(record, y_columns, x_axis)
line_chart = graph.GraphPlotly.Line(self.page, width, height, options, html_code, profile)
line_chart.colors(self.page.theme.charts)
for d in data['datasets']:
line_chart.add_trace(d)
line_chart.data.type = options['type']
line_chart.data.fill = 'tozeroy'
return line_chart
def bubble(self, record, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'y_columns': y_columns, 'x_column': x_axis, 'mode': 'markers'})
data = self.page.data.plotly.xy(record, y_columns, x_axis)
line_chart = graph.GraphPlotly.Line(self.page, width, height, options, html_code, profile)
line_chart.colors(self.page.theme.charts)
line_chart.options.responsive = True
for d in data['datasets']:
line_chart.add_trace(d, mode=options['mode'])
return line_chart
def number(self, value, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'type': 'indicator', 'mode': 'number'})
ind = graph.GraphPlotly.Indicator(self.page, width, height, options, html_code, profile)
ind.add_trace({'value': value}, mode=options['mode'])
return ind
def number_with_delta(self, value, delta=100, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'type': 'indicator', 'mode': 'number+delta', 'delta': {'reference': delta}})
ind = graph.GraphPlotly.Indicator(self.page, width, height, options, html_code, profile)
ind.add_trace({'value': value}, mode=options['mode'])
ind.data.delta.reference = delta
return ind
def gauge(self, value, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
options = (options or {})
options.update({'type': 'indicator', 'mode': 'gauge+number'})
gau = graph.GraphPlotly.Indicator(self.page, width, height, (options or {}), html_code, profile)
gau.add_trace({'value': value}, mode=options['mode'], type=options['type'])
return gau
def scatterpolar(self, record, r_columns=None, theta_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
all_series = []
for c in r_columns:
series = {'r': [], 'theta': []}
for rec in record:
series['r'].append(rec[c])
series['theta'].append(rec[theta_axis])
all_series.append(series)
spolar_chart = graph.GraphPlotly.ScatterPolar(self.page, width, height, (options or {}), html_code, profile)
spolar_chart.colors(self.page.theme.charts)
for d in all_series:
spolar_chart.add_trace(d, mode='line')
spolar_chart.data.marker.color = None
return spolar_chart
def box(self, record=None, y_columns=None, x_columns=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
(axis, cols) = (('y', y_columns) if (y_columns is not None) else ('x', x_columns))
series = []
if (cols is not None):
for c in cols:
series.append([rec.get(c) for rec in record])
box_chart = graph.GraphPlotly.Box(self.page, width, height, (options or {}), html_code, profile)
for s in series:
box_chart.add_trace({axis: s})
return box_chart
def group_box(self, record, y_columns=None, x_axis=None, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
(series, x) = ([[] for _ in range(len(y_columns))], [])
for rec in record:
for (i, c) in enumerate(y_columns):
series[i].append(rec.get(c))
x.append(rec.get(x_axis))
box_chart = graph.GraphPlotly.Box(self.page, width, height, (options or {}), html_code, profile)
for s in series:
box_chart.add_trace({'y': s, 'x': x})
return box_chart
def candlestick(self, record, closes, highs, lows, opens, x_axis, profile=None, options=None, width=(100, '%'), height=(330, 'px'), html_code=None):
all_series = []
for (i, c) in enumerate(closes):
series = {'x': [], 'close': [], 'high': [], 'low': [], 'open': []}
for rec in record:
series['x'].append(rec[x_axis])
series['close'].append(rec[c])
series['high'].append(rec[highs[i]])
series['low'].append(rec[lows[i]])
series['open'].append(rec[opens[i]])
all_series.append(series)
candle_chart = graph.GraphPlotly.CandleStick(self.page, width, height, (options or {}), html_code, profile)
for s in all_series:
candle_chart.add_trace(s)
candle_chart.layout.no_background()
return candle_chart |
class Git(LocalComponent):
def _git_branch():
return check_subprocess(['git', 'rev-parse', '--abbrev-ref', 'HEAD'])[0].strip()
def setup(self):
if (not self._config.get('checkout', False)):
return
branch = Git._git_branch()
L.info('Updating git repo to branch {} on device {}'.format(branch, self._device.device_id()))
connector_helper = ConnectorHelper(self._device)
git_root = self._device.config().get('git_root', tools_root())
connector_helper.execute_command(['cd', git_root, '&&', 'git', 'checkout', branch, '&&', 'git', 'pull', '&&', 'git', 'submodule', 'update', '--init', '--recursive']) |
class TacDialogues(Model, BaseTacDialogues):
def __init__(self, **kwargs: Any) -> None:
Model.__init__(self, **kwargs)
def role_from_first_message(message: Message, receiver_address: Address) -> BaseDialogue.Role:
return BaseTacDialogue.Role.PARTICIPANT
BaseTacDialogues.__init__(self, self_address=self.context.agent_address, role_from_first_message=role_from_first_message) |
class op(bpy.types.Operator):
bl_idname = 'uv.textools_island_straighten_edge_loops'
bl_label = 'Straight edges chain'
bl_description = 'Straighten selected edge-chain and relax the rest of the UV Island'
bl_options = {'REGISTER', 'UNDO'}
def poll(cls, context):
if (bpy.context.area.ui_type != 'UV'):
return False
if (not bpy.context.active_object):
return False
if (bpy.context.active_object.mode != 'EDIT'):
return False
if (bpy.context.active_object.type != 'MESH'):
return False
if (not bpy.context.object.data.uv_layers):
return False
if (bpy.context.scene.tool_settings.uv_select_mode != 'EDGE'):
return False
if bpy.context.scene.tool_settings.use_uv_select_sync:
return False
return True
def execute(self, context):
utilities_uv.multi_object_loop(main, self, context)
return {'FINISHED'} |
.parametrize('options_prefix', [None, '', 'foo'])
def test_matrix_prefix_solver(options_prefix):
parameters = {'ksp_type': 'preonly', 'pc_type': 'lu', 'pc_factor_mat_solver_type': 'mumps', 'mat_mumps_icntl_14': 200, 'mat_mumps_icntl_24': 1}
mesh = UnitSquareMesh(1, 1)
V = FunctionSpace(mesh, 'P', 1)
u = TrialFunction(V)
v = TestFunction(V)
a = (inner(u, v) * dx)
L = (conj(v) * dx)
uh = Function(V)
problem = LinearVariationalProblem(a, L, uh)
solver = LinearVariationalSolver(problem, solver_parameters=parameters, options_prefix=options_prefix)
solver.solve()
pc = solver.snes.ksp.pc
factor = pc.getFactorMatrix()
assert (factor.getType() == 'mumps')
assert (factor.getMumpsIcntl(24) == 1)
for A in pc.getOperators():
pfx = A.getOptionsPrefix()
if (pfx is None):
pfx = ''
assert (pfx == solver.options_prefix) |
class Shadow(Cover):
SIZE = 120.0
WIDTH = 11
def __init__(self, size, image):
super(Shadow, self).__init__(size, image)
self._calculate_sizes(size)
def resize(self, size):
super(Shadow, self).resize(size)
self._calculate_sizes(size)
def _calculate_sizes(self, size):
self.width = int(((size / self.SIZE) * self.WIDTH))
self.cover_size = (self.size - (self.width * 2)) |
class TestEllipticRedistancing(object):
def setup_class(cls):
pass
def teardown_class(cls):
pass
def setup_method(self, method):
self._scriptdir = os.path.dirname(__file__)
def teardown_method(self, method):
pass
def test_ELLIPTIC_REDISTANCING_0(self):
vortex2D.ct.ELLIPTIC_REDISTANCING = 0
reload(rdls_p)
reload(rdls_n)
reload(vortex2D_so)
pnList = [(ncls_p, ncls_n), (rdls_p, rdls_n)]
self.so = vortex2D_so
pList = []
nList = []
sList = []
for (pModule, nModule) in pnList:
pList.append(pModule)
if (pList[(- 1)].name == None):
pList[(- 1)].name = pModule.__name__
nList.append(nModule)
for i in range(len(pnList)):
sList.append(default_s)
self.so.name += '_ELLIPTIC_REDIST_0'
petsc_options = PETSc.Options()
petsc_options.setValue('ncls_pc_type', 'lu')
petsc_options.setValue('ncls_ksp_type', 'preonly')
petsc_options.setValue('ncls_pc_factor_mat_solver_package', 'superlu')
petsc_options.setValue('rdls_pc_type', 'lu')
petsc_options.setValue('rdls_ksp_type', 'preonly')
petsc_options.setValue('rdls_pc_factor_mat_solver_package', 'superlu')
ns = proteus.NumericalSolution.NS_base(self.so, pList, nList, sList, opts)
ns.calculateSolution('rdls')
actual = tables.open_file('vortex_c0p1_level_1_ELLIPTIC_REDIST_0.h5', 'r')
assert np.isclose(np.amax(actual.root.u_t1), 0., atol=1e-10)
actual.close()
def test_ELLIPTIC_REDISTANCING_1(self):
vortex2D.ct.ELLIPTIC_REDISTANCING = 1
reload(rdls_p)
reload(rdls_n)
reload(vortex2D_so)
pnList = [(ncls_p, ncls_n), (rdls_p, rdls_n)]
self.so = vortex2D_so
pList = []
nList = []
sList = []
for (pModule, nModule) in pnList:
pList.append(pModule)
if (pList[(- 1)].name == None):
pList[(- 1)].name = pModule.__name__
nList.append(nModule)
for i in range(len(pnList)):
sList.append(default_s)
self.so.name += '_ELLIPTIC_REDIST_1'
petsc_options = PETSc.Options()
petsc_options.setValue('ncls_pc_type', 'lu')
petsc_options.setValue('ncls_ksp_type', 'preonly')
petsc_options.setValue('ncls_pc_factor_mat_solver_package', 'superlu')
petsc_options.setValue('rdls_pc_type', 'lu')
petsc_options.setValue('rdls_ksp_type', 'preonly')
petsc_options.setValue('rdls_pc_factor_mat_solver_package', 'superlu')
ns = proteus.NumericalSolution.NS_base(self.so, pList, nList, sList, opts)
ns.calculateSolution('rdls')
actual = tables.open_file('vortex_c0p1_level_1_ELLIPTIC_REDIST_1.h5', 'r')
assert np.isclose(np.amax(actual.root.u_t1), 0., atol=1e-10)
actual.close()
def test_ELLIPTIC_REDISTANCING_2(self):
vortex2D.ct.ELLIPTIC_REDISTANCING = 2
reload(default_p)
reload(default_so)
reload(rdls_p)
reload(rdls_n)
reload(vortex2D_so)
pnList = [(ncls_p, ncls_n), (rdls_p, rdls_n)]
self.so = vortex2D_so
pList = []
nList = []
sList = []
for (pModule, nModule) in pnList:
pList.append(pModule)
if (pList[(- 1)].name == None):
pList[(- 1)].name = pModule.__name__
nList.append(nModule)
for i in range(len(pnList)):
sList.append(default_s)
self.so.name += '_ELLIPTIC_REDIST_2'
petsc_options = PETSc.Options()
petsc_options.setValue('ncls_pc_type', 'lu')
petsc_options.setValue('ncls_ksp_type', 'preonly')
petsc_options.setValue('ncls_pc_factor_mat_solver_package', 'superlu')
petsc_options.setValue('rdls_pc_type', 'lu')
petsc_options.setValue('rdls_ksp_type', 'preonly')
petsc_options.setValue('rdls_pc_factor_mat_solver_package', 'superlu')
ns = proteus.NumericalSolution.NS_base(self.so, pList, nList, sList, opts)
ns.calculateSolution('rdls')
actual = tables.open_file('vortex_c0p1_level_1_ELLIPTIC_REDIST_2.h5', 'r')
print(np.amax(actual.root.u_t1))
assert np.isclose(np.amax(actual.root.u_t1), 0., atol=1e-10)
actual.close()
def test_ELLIPTIC_REDISTANCING_3(self):
vortex2D.ct.ELLIPTIC_REDISTANCING = 3
reload(rdls_p)
reload(rdls_n)
reload(vortex2D_so)
pnList = [(ncls_p, ncls_n), (rdls_p, rdls_n)]
self.so = vortex2D_so
pList = []
nList = []
sList = []
for (pModule, nModule) in pnList:
pList.append(pModule)
if (pList[(- 1)].name == None):
pList[(- 1)].name = pModule.__name__
nList.append(nModule)
for i in range(len(pnList)):
sList.append(default_s)
self.so.name += '_ELLIPTIC_REDIST_3'
petsc_options = PETSc.Options()
petsc_options.setValue('ncls_pc_type', 'lu')
petsc_options.setValue('ncls_ksp_type', 'preonly')
petsc_options.setValue('ncls_pc_factor_mat_solver_package', 'superlu')
petsc_options.setValue('rdls_pc_type', 'lu')
petsc_options.setValue('rdls_ksp_type', 'preonly')
petsc_options.setValue('rdls_pc_factor_mat_solver_package', 'superlu')
ns = proteus.NumericalSolution.NS_base(self.so, pList, nList, sList, opts)
ns.calculateSolution('rdls')
actual = tables.open_file('vortex_c0p1_level_1_ELLIPTIC_REDIST_3.h5', 'r')
assert np.isclose(np.amax(actual.root.u_t1), 0., atol=1e-10)
actual.close() |
class _FlowSpecPrefixBase(_FlowSpecIPv4Component, IPAddrPrefix):
def __init__(self, length, addr, type_=None):
super(_FlowSpecPrefixBase, self).__init__(type_)
self.length = length
prefix = ('%s/%s' % (addr, length))
self.addr = str(netaddr.ip.IPNetwork(prefix).network)
def parse_body(cls, buf):
return cls.parser(buf)
def serialize_body(self):
return self.serialize()
def from_str(cls, value):
rule = []
(addr, length) = value.split('/')
rule.append(cls(int(length), addr))
return rule
def value(self):
return ('%s/%s' % (self.addr, self.length))
def to_str(self):
return self.value |
class ClientC2Data(C2Data):
def iter_encrypted_packets(self) -> Iterator[EncryptedPacket]:
data = self.output
while data:
fobj = io.BytesIO(data)
size = c2struct.uint32(fobj)
ciphertext = fobj.read((size - 16))
signature = fobj.read(16)
data = fobj.read()
(yield EncryptedPacket(ciphertext, signature)) |
class AsyncNode():
def __init__(self, async_entity, entity_name, execution=None, url=None):
self.entity_name = entity_name
self.async_entity = async_entity
self.execution = execution
self._url = url
def url(self) -> str:
endpoint_root = FLYTE_SANDBOX_INTERNAL_ENDPOINT.replace(' '')
if (endpoint_root in self._url):
return self._url.replace(endpoint_root, 'localhost:30080')
return self._url
def entity_type(self) -> str:
if (isinstance(self.async_entity.entity, PythonTask) and (getattr(self.async_entity.entity, 'execution_mode', None) == PythonFunctionTask.ExecutionBehavior.EAGER)):
return 'Eager Workflow'
elif isinstance(self.async_entity.entity, PythonTask):
return 'Task'
elif isinstance(self.async_entity.entity, WorkflowBase):
return 'Workflow'
return str(type(self.async_entity.entity))
def __repr__(self):
ex_id = self.execution.id
execution_id = (None if (self.execution is None) else f'{ex_id.project}:{ex_id.domain}:{ex_id.name}')
return f'<async_node | entity_type: {self.entity_type} | entity: {self.entity_name} | execution: {execution_id}' |
def pwdlyze(passwords):
prefixes = {}
postfixes = {}
lengths = {}
symbols = {}
numbers = {}
for password in passwords:
if (not password):
continue
prefix = password[0]
postfix = password[(- 1)]
length = len(password)
if (prefix not in prefixes):
prefixes[prefix] = 0
prefixes[prefix] += 1
if (postfix not in postfixes):
postfixes[postfix] = 0
postfixes[postfix] += 1
if (length not in lengths):
lengths[length] = 0
lengths[length] += 1
return {'prefixes': sorted(prefixes.items(), key=operator.itemgetter(1), reverse=True)[:20], 'postfixes': sorted(postfixes.items(), key=operator.itemgetter(1), reverse=True)[:20], 'lengths': sorted(lengths.items(), key=operator.itemgetter(1), reverse=True)[:20]} |
def get_shuffling(seed: Bytes32, validators: List[Validator], epoch: Epoch) -> List[List[ValidatorIndex]]:
param_hash = (seed, hash_tree_root(validators, [Validator]), epoch)
if (param_hash in shuffling_cache):
return shuffling_cache[param_hash]
else:
ret = _get_shuffling(seed, validators, epoch)
shuffling_cache[param_hash] = ret
return ret |
class OptionPlotoptionsAreaSonificationContexttracksMappingLowpassFrequency(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
def _get_pe_size(pe_file_path: str) -> Optional[int]:
binary = lief.PE.parse(pe_file_path)
if (binary is None):
LOG.error("Failed to parse PE '%s'", pe_file_path)
return None
number_of_sections = len(binary.sections)
if (number_of_sections == 0):
return None
highest_section = binary.sections[0]
for section in lief_pe_sections(binary):
if (section.offset > highest_section.offset):
highest_section = section
elif ((section.offset == highest_section.offset) and (section.size > highest_section.size)):
highest_section = section
pe_size = (highest_section.offset + highest_section.size)
return pe_size |
_required
_required
_required
_required('DNS_ENABLED')
def dc_domain_list(request):
user = request.user
domains = Domain.objects.order_by('name')
dc_domain_ids = list(request.dc.domaindc_set.values_list('domain_id', flat=True))
context = collect_view_data(request, 'dc_domain_list')
context['is_staff'] = is_staff = user.is_staff
context['can_edit'] = can_edit = (is_staff or user.has_permission(request, DnsAdminPermission.name))
context['all'] = _all = (is_staff and request.GET.get('all', False))
context['deleted'] = _deleted = (can_edit and request.GET.get('deleted', False))
qs = get_query_string(request, all=_all, deleted=_deleted)
qs.pop('domain', None)
context['qs'] = qs = qs.urlencode()
if _deleted:
domains = domains.exclude(access=Domain.INTERNAL)
else:
domains = domains.exclude(access__in=Domain.INVISIBLE)
if can_edit:
domains = domains.annotate(records=Count('record', distinct=True))
if _all:
context['domains'] = prefetch_domain_dcs(prefetch_domain_owner(domains))
else:
context['domains'] = prefetch_domain_owner(domains.filter(id__in=dc_domain_ids))
if is_staff:
if _all:
context['can_add'] = set(Domain.objects.exclude(id__in=dc_domain_ids).values_list('id', flat=True))
else:
context['can_add'] = Domain.objects.exclude(id__in=dc_domain_ids).count()
context['form_dc'] = DcDomainForm(request, domains)
context['form_admin'] = AdminDomainForm(request, None, prefix='adm', initial={'owner': user.username, 'access': Domain.PRIVATE, 'dc_bound': (not is_staff)})
context['url_form_dc'] = reverse('dc_domain_form', query_string=qs)
context['url_form_admin'] = reverse('admin_domain_form', query_string=qs)
return render(request, 'gui/dc/domain_list.html', context) |
def flag_dict(name):
def _init_flag_dict(source):
def subscribe(observer, scheduler=None):
def on_next(value):
flag_dict = {name: value}
observer.on_next(flag_dict)
return source.subscribe(on_next, observer.on_error, observer.on_completed, scheduler)
return rx.create(subscribe)
return _init_flag_dict |
class UpdateConfiguration(BaseModel):
update_steps: ConstrainedUpdateStepList
def __iter__(self) -> Iterator[UpdateStep]:
(yield from self.update_steps)
def __getitem__(self, item: int) -> UpdateStep:
return self.update_steps[item]
def __len__(self) -> int:
return len(self.update_steps)
def context_validate(self, valid_observations: List[str], valid_parameters: List[str]) -> None:
errors = []
for update_step in self.update_steps:
for observation in update_step.observations:
if (observation.name not in valid_observations):
errors.append(f'Observation: {observation} not in valid observations')
for parameter in (update_step.parameters + update_step.row_scaling_parameters):
if (parameter.name not in valid_parameters):
errors.append(f'Parameter: {parameter} not in valid parameters')
if errors:
raise ValueError(f'Update configuration not valid, valid observations: {valid_observations}, valid parameters: {valid_parameters}, errors: {errors}')
def global_update_step(cls, observations: List[str], parameters: List[str]) -> Self:
global_update_step = [UpdateStep(name='ALL_ACTIVE', observations=observations, parameters=parameters)]
return cls(update_steps=global_update_step) |
class ConfirmationAW3TestCase(BaseSkillTestCase):
path_to_skill = Path(ROOT_DIR, 'packages', 'fetchai', 'skills', 'confirmation_aw3')
def setup(cls):
cls.aw1_aea = 'some_aw1_aea'
cls.leaderboard_url = 'some_leaderboard_url'
cls.leaderboard_token = 'some_leaderboard_token'
config_overrides = {'models': {'strategy': {'args': {'aw1_aea': cls.aw1_aea, 'leaderboard_url': cls.leaderboard_url, 'leaderboard_token': cls.leaderboard_token}}}}
super().setup(config_overrides=config_overrides) |
class MyNode(Node):
config: MyConfig
state: MyState
A = Topic(MyMessage)
B = Topic(MyMessage)
def setup(self) -> None:
self.other_state: int = 5
(A)
async def my_publisher(self) -> AsyncPublisher:
for i in range(NUM_MESSAGES):
(yield (self.A, MyMessage(my_field=i)))
(B)
async def my_subscriber(self, message: MyMessage) -> None:
self.state.counter = message.my_field
def cleanup(self) -> None:
self.other_state = 6 |
class GlobalStyle():
def __init__(self, page: primitives.PageModel):
self.page = page
self._font = None
self._icon = None
self._table = None
self._line_height = max(defaultHtml.LINE_HEIGHT, self.font.size)
def line_height(self):
return self._line_height
_height.setter
def line_height(self, value: int):
self._line_height = value
def font(self) -> Font:
if (self._font is None):
self._font = Font(self.page)
return self._font
def icon(self) -> Icon:
if (self._icon is None):
self._icon = Icon()
return self._icon
def table(self):
if (self._table is None):
class GlobalTable():
header_background = (self.page.theme.colors[0] if self.page.theme.dark else self.page.theme.colors[(- 1)])
header_color = self.page.theme.white
header_border = (('1px solid %s' % self.page.theme.black) if self.page.theme.dark else self.page.theme.white)
cell_border_bottom = ('1px solid %s' % self.page.theme.colors[4])
cell_border_right = None
sorter_arrow_selected = self.page.theme.colors[(- 3)]
sorter_arrow = (self.page.theme.black if self.page.theme.dark else self.page.theme.white)
self._table = GlobalTable()
return self._table |
def test_dict_wf_with_conversion():
def t1(a: int) -> typing.Dict[(str, str)]:
return {'a': str(a)}
def t2(a: dict) -> str:
print(f'HAHAH {a}')
return ' '.join([v for (k, v) in a.items()])
def my_wf(a: int) -> str:
return t2(a=t1(a=a))
with pytest.raises(TypeError):
my_wf(a=5) |
class override_maintenance_mode(ContextDecorator):
def __init__(self, value):
self.value = value
self.old_value = None
def __enter__(self):
self.old_value = get_maintenance_mode()
set_maintenance_mode(self.value)
def __exit__(self, exc_type, exc_value, traceback):
set_maintenance_mode(self.old_value) |
def downgrade():
op.add_column(u'Projects', sa.Column('lead_id', sa.INTEGER(), nullable=True))
op.add_column(u'Departments', sa.Column('lead_id', sa.INTEGER(), nullable=True))
op.drop_column(u'Project_Users', 'rid')
op.drop_column(u'Department_Users', 'rid')
op.rename_table('Department_Users', 'User_Departments')
op.rename_table('Group_Users', 'User_Groups')
op.add_column(u'Users', sa.Column('company_id', sa.INTEGER(), nullable=True))
op.drop_table('Client_Users')
op.drop_table('Roles') |
class table_feature_prop_experimenter(table_feature_prop):
subtypes = {}
type = 65534
def __init__(self, experimenter=None, subtype=None):
if (experimenter != None):
self.experimenter = experimenter
else:
self.experimenter = 0
if (subtype != None):
self.subtype = subtype
else:
self.subtype = 0
return
def pack(self):
packed = []
packed.append(struct.pack('!H', self.type))
packed.append(struct.pack('!H', 0))
packed.append(struct.pack('!L', self.experimenter))
packed.append(struct.pack('!L', self.subtype))
length = sum([len(x) for x in packed])
packed[1] = struct.pack('!H', length)
return ''.join(packed)
def unpack(reader):
(subtype,) = reader.peek('!L', 4)
subclass = table_feature_prop_experimenter.subtypes.get(subtype)
if subclass:
return subclass.unpack(reader)
obj = table_feature_prop_experimenter()
_type = reader.read('!H')[0]
assert (_type == 65534)
_length = reader.read('!H')[0]
orig_reader = reader
reader = orig_reader.slice(_length, 4)
obj.experimenter = reader.read('!L')[0]
obj.subtype = reader.read('!L')[0]
return obj
def __eq__(self, other):
if (type(self) != type(other)):
return False
if (self.experimenter != other.experimenter):
return False
if (self.subtype != other.subtype):
return False
return True
def pretty_print(self, q):
q.text('table_feature_prop_experimenter {')
with q.group():
with q.indent(2):
q.breakable()
q.text('subtype = ')
q.text(('%#x' % self.subtype))
q.breakable()
q.text('}') |
class NpmProviderFactory(ProviderFactory):
class Options(NamedTuple):
lockfile: NpmLockfileProvider.Options
module: NpmModuleProvider.Options
def __init__(self, lockfile_root: Path, options: Options) -> None:
self.lockfile_root = lockfile_root
self.options = options
def create_lockfile_provider(self) -> NpmLockfileProvider:
return NpmLockfileProvider(self.options.lockfile)
def create_rcfile_providers(self) -> List[RCFileProvider]:
return [NpmRCFileProvider()]
def create_module_provider(self, gen: ManifestGenerator, special: SpecialSourceProvider) -> NpmModuleProvider:
return NpmModuleProvider(gen, special, self.lockfile_root, self.options.module) |
class TestRegisterMessage():
def setup_class(cls):
cls.info = {'a': 'b', 'c': 'd'}
def test_register(self):
tx_msg = RegisterMessage(performative=RegisterMessage.Performative.REGISTER, info=self.info)
assert tx_msg._is_consistent()
encoded_tx_msg = tx_msg.encode()
decoded_tx_msg = tx_msg.serializer.decode(encoded_tx_msg)
assert (tx_msg == decoded_tx_msg)
def test_success(self):
tx_msg = RegisterMessage(performative=RegisterMessage.Performative.SUCCESS, info=self.info, target=1, message_id=2)
assert tx_msg._is_consistent()
encoded_tx_msg = tx_msg.encode()
decoded_tx_msg = tx_msg.serializer.decode(encoded_tx_msg)
assert (tx_msg == decoded_tx_msg)
def test_error(self):
some_error_code = 1
some_error_msg = 'Some error message'
tx_msg = RegisterMessage(performative=RegisterMessage.Performative.ERROR, error_code=some_error_code, error_msg=some_error_msg, info=self.info)
assert tx_msg._is_consistent()
encoded_tx_msg = tx_msg.encode()
decoded_tx_msg = tx_msg.serializer.decode(encoded_tx_msg)
assert (tx_msg == decoded_tx_msg) |
def get_kerning_by_blocks(blocks: List[Tuple[(int, int)]]) -> Tuple[(List[str], str)]:
value = 0
glyphs: List[str] = []
rules = []
for (script, (width, height)) in enumerate(blocks):
glyphs.extend((f'g_{script}_{i}' for i in range(max(width, height))))
for l in range(height):
for r in range(width):
value += 1
rules.append((f'g_{script}_{l}', f'g_{script}_{r}', value))
classes = '\n'.join([f'{g} = [{g}];' for g in glyphs])
statements = '\n'.join([f'pos {l} {r} {v};' for (l, r, v) in rules])
features = f'''
{classes}
feature kern {{
{statements}
}} kern;
'''
return (glyphs, features) |
def extractPrinceOfStrideNovelTranslation(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
if ('WATTT' in item['tags']):
return buildReleaseMessageWithType(item, 'WATTT', vol, chp, frag=frag, postfix=postfix)
return False |
def compute_specifier_from_version(version: Version) -> str:
new_major_low = version.major
new_major_high = (version.major + 1)
new_minor_low = version.minor
new_minor_high = (new_minor_low + 1)
if (new_major_low == 0):
lower_bound = Version(f'{new_major_low}.{new_minor_low}.0')
lower_bound = (lower_bound if (lower_bound < version) else version)
upper_bound = Version(f'{new_major_low}.{new_minor_high}.0')
else:
lower_bound = Version(f'{new_major_low}.{version.minor}.0')
lower_bound = (lower_bound if (lower_bound < version) else version)
upper_bound = Version(f'{new_major_high}.0.0')
specifier_set = f'>={lower_bound}, <{upper_bound}'
return specifier_set |
def test_adding_a_label_on_non_headless_service():
config = ''
r = helm_template(config)
assert ('label1' not in r['service'][uname]['metadata']['labels'])
config = '\n service:\n labels:\n label1: value1\n '
r = helm_template(config)
assert (r['service'][uname]['metadata']['labels']['label1'] == 'value1') |
def test_adding_an_extra_volume_with_volume_mount():
config = '\nextraVolumes:\n - name: extras\n emptyDir: {}\nextraVolumeMounts:\n - name: extras\n mountPath: /usr/share/extras\n readOnly: true\n'
r = helm_template(config)
extraVolume = r['deployment'][name]['spec']['template']['spec']['volumes']
assert ({'name': 'extras', 'emptyDir': {}} in extraVolume)
extraVolumeMounts = r['deployment'][name]['spec']['template']['spec']['containers'][0]['volumeMounts']
assert ({'name': 'extras', 'mountPath': '/usr/share/extras', 'readOnly': True} in extraVolumeMounts) |
class TornadoServer(AbstractServer):
def __init__(self, *args, **kwargs):
self._app = None
self._server = None
super().__init__(*args, **kwargs)
def _open(self, host, port, **kwargs):
self._io_loop = AsyncIOMainLoop()
if hasattr(IOLoop, '_current'):
IOLoop._current.instance = None
else:
IOLoop.current().instance = None
self._io_loop.make_current()
if config.ssl_certfile:
if ('ssl_options' not in kwargs):
kwargs['ssl_options'] = {}
if ('certfile' not in kwargs['ssl_options']):
kwargs['ssl_options']['certfile'] = config.ssl_certfile
if config.ssl_keyfile:
if ('ssl_options' not in kwargs):
kwargs['ssl_options'] = {}
if ('keyfile' not in kwargs['ssl_options']):
kwargs['ssl_options']['keyfile'] = config.ssl_keyfile
if config.tornado_debug:
app_kwargs = dict(debug=True)
else:
app_kwargs = dict()
self._app = Application([('/flexx/ws/(.*)', WSHandler), ('/flexx/(.*)', MainHandler), ('/(.*)', AppHandler)], **app_kwargs)
self._app._io_loop = self._io_loop
if (tornado.version_info < (5,)):
kwargs['io_loop'] = self._io_loop
self._server = HTTPServer(self._app, **kwargs)
if port:
try:
port = int(port)
except ValueError:
port = port_hash(port)
self._server.listen(port, host)
else:
prefered_port = port_hash('Flexx')
for i in range(8):
port = (prefered_port + i)
try:
self._server.listen(port, host)
break
except OSError:
pass
else:
[sock] = netutil.bind_sockets(None, host, family=socket.AF_INET)
self._server.add_sockets([sock])
port = sock.getsockname()[1]
self._serving = self._app._flexx_serving = (host, port)
proto = '
if ('ssl_options' in kwargs):
proto = '
logger.info(('Serving apps at %s://%s:%i/' % (proto, host, port)))
def _close(self):
self._server.stop()
def app(self):
return self._app
def server(self):
return self._server
def protocol(self):
if (self._server.ssl_options is not None):
return '
return ' |
class ValveSwitchStackManagerReflection(ValveSwitchStackManagerBase):
_USES_REFLECTION = True
def _learn_cache_check(self, entry, vlan, now, eth_src, port, ofmsgs, cache_port, cache_age, delete_existing, refresh_rules):
learn_exit = False
update_cache = True
if (cache_port is not None):
same_lag = (port.lacp and (port.lacp == cache_port.lacp))
local_stack_learn = (port.stack and (not cache_port.stack))
guard_time = self.cache_update_guard_time
if ((cache_port == port) or same_lag or local_stack_learn):
port_cache_valid = ((port.dyn_update_time is not None) and (port.dyn_update_time <= entry.cache_time))
if (same_lag or local_stack_learn):
guard_time = 2
if ((cache_age < guard_time) and port_cache_valid):
update_cache = False
learn_exit = True
elif ((cache_port == port) or same_lag):
delete_existing = False
if port_cache_valid:
refresh_rules = True
return (learn_exit, ofmsgs, cache_port, update_cache, delete_existing, refresh_rules)
def _flood_actions(self, in_port, external_ports, away_flood_actions, toward_flood_actions, local_flood_actions):
if self.stack_manager.stack.is_root():
if external_ports:
flood_prefix = self._set_nonext_port_flag
else:
flood_prefix = self._set_ext_port_flag
flood_actions = (away_flood_actions + local_flood_actions)
if (in_port and self.stack_manager.is_away(in_port)):
flood_actions = ((away_flood_actions + (valve_of.output_in_port(),)) + local_flood_actions)
flood_actions = (flood_prefix + flood_actions)
else:
if external_ports:
flood_actions = (self._set_nonext_port_flag + toward_flood_actions)
else:
flood_actions = (self._set_ext_port_flag + toward_flood_actions)
if in_port:
if self.stack_manager.is_away(in_port):
flood_actions = toward_flood_actions
elif self.stack_manager.is_towards_root(in_port):
if external_ports:
flood_actions = ((self._set_nonext_port_flag + away_flood_actions) + local_flood_actions)
else:
flood_actions = ((away_flood_actions + self._set_nonext_port_flag) + local_flood_actions)
elif in_port.loop_protect_external:
flood_actions = (self._set_nonext_port_flag + toward_flood_actions)
else:
flood_actions = (self._set_ext_port_flag + toward_flood_actions)
return flood_actions
def _edge_dp_for_host(self, other_valves, pkt_meta):
peer_dp = pkt_meta.port.stack['dp']
if peer_dp.dyn_running:
return self._non_stack_learned(other_valves, pkt_meta)
if (peer_dp.stack.is_edge() or peer_dp.stack.is_root()):
return peer_dp
return None |
class ServiceRecord():
SERVICE_RECORD_HANDLE = 0
SERVICE_CLASS_ID_LIST = 1
SERVICE_RECORD_STATE = 2
SERVICE_ID = 3
PROTOCOL_DESCRIPTOR_LIST = 4
BROWSE_GROUP_LIST = 5
LANGUAGE_BASE_ATTRIBUTE_ID_LIST = 6
SERVICE_INFO_TIME_TO_LIVE = 7
SERVICE_AVAILABILITY = 8
BLUETOOTH_PROFILE_DESCRIPTOR_LIST = 9
DOCUMENTATION_URL = 10
CLIENT_EXECUTABLE_URL = 11
ICON_URL = 12
ADDITIONAL_PROTOCOL_DESCRIPTOR_LISTS = 13
SERVICE_NAME = 0
SERVICE_DESCRIPTION = 1
PROVIDER_NAME = 2
def __init__(self, record_xml: str):
self.universal_attrs = {self.SERVICE_RECORD_HANDLE: {'Name': 'ServiceRecordHandle', 'Parser': (lambda val: print(('\t0x%08x' % val)))}, self.SERVICE_CLASS_ID_LIST: {'Name': 'ServiceClassIDList', 'Parser': self.pp_service_cls_list}, self.SERVICE_RECORD_STATE: {'Name': 'ServiceRecordState', 'Parser': (lambda val: print(('\t0x%08x: to be parsed' % val)))}, self.SERVICE_ID: {'Name': 'ServiceID', 'Parser': (lambda val: print((('\t' + val) + ': to be parsed')))}, self.PROTOCOL_DESCRIPTOR_LIST: {'Name': 'ProtocolDescriptorList', 'Parser': self.pp_protocol_descp_list}, self.BROWSE_GROUP_LIST: {'Name': 'BrowseGroupList', 'Parser': self.pp_browse_group_list}, self.LANGUAGE_BASE_ATTRIBUTE_ID_LIST: {'Name': 'LanguageBaseAttributeIDList', 'Parser': self.pp_lang_base_attr_id_list}, self.SERVICE_INFO_TIME_TO_LIVE: {'Name': 'ServiceInfoTimeToLive', 'Parser': (lambda val: print(('\t0x%08x: to be parsed' % val)))}, self.SERVICE_AVAILABILITY: {'Name': 'ServiceAvailability', 'Parser': (lambda val: print(('\t0x%02x: to be parsed' % val)))}, self.BLUETOOTH_PROFILE_DESCRIPTOR_LIST: {'Name': 'BluetoothProfileDescriptorList', 'Parser': self.pp_bt_profile_descp_list}, self.DOCUMENTATION_URL: {'Name': 'DocumentationURL', 'Parser': (lambda val: print((('\t' + val) + ': to be parsed')))}, self.CLIENT_EXECUTABLE_URL: {'Name': 'ClientExecutableURL', 'Parser': (lambda val: print((('\t' + val) + ': to be parsed')))}, self.ICON_URL: {'Name': 'IconURL', 'Parser': (lambda val: print((('\t' + val) + ': to be parsed')))}, self.ADDITIONAL_PROTOCOL_DESCRIPTOR_LISTS: {'Name': 'AdditionalProtocolDescriptorList', 'Parser': self.pp_additional_protocol_descp_lists}}
self.universal_attr_offsets = {self.SERVICE_NAME: {'Name': 'ServiceName', 'Parser': (lambda val: print(('\t' + val)))}, self.SERVICE_DESCRIPTION: {'Name': 'ServiceDescription', 'Parser': (lambda val: print(('\t' + val)))}, self.PROVIDER_NAME: {'Name': 'ProviderName', 'Parser': (lambda val: print(('\t' + val)))}}
self.record_xml = record_xml
self.service_clses = []
self.attr_id_bases = []
def pp(self):
attrs = ElementTree.fromstring(self.record_xml).findall('./attribute')
for attr in attrs:
self.pp_attr(attr)
def pp_attr(self, attr: ElementTree.Element):
attr_id = int(attr.attrib['id'][2:], base=16)
val_type = attr.find('./').tag
if ('uint' in val_type):
val = int(attr.find(('./' + val_type)).attrib['value'][2:], base=16)
elif (val_type == 'sequence'):
val = attr.find(('./' + val_type))
else:
val = attr.find(('./' + val_type)).attrib['value']
for base in self.attr_id_bases:
offset = (attr_id - base)
try:
print(('0x%04x:' % attr_id), self.universal_attr_offsets[offset]['Name'], ('(%s)' % val_type))
self.universal_attr_offsets[offset]['Parser'](val)
return
except KeyError:
continue
try:
print(('0x%04x:' % attr_id), self.universal_attrs[attr_id]['Name'], ('(%s)' % val_type))
self.universal_attrs[attr_id]['Parser'](val)
except KeyError:
from .ag_service_record import AGServiceRecord
from .hf_service_record import HFServiceRecord
from .hid_service_record import HIDServiceRecord
from .mce_service_record import MCEServiceRecord
from .mse_service_record import MSEServiceRecord
from .op_service_record import ObjPushServiceRecord
offset = (attr_id - 256)
try:
print(('0x%04x:' % attr_id), self.universal_attr_offsets[offset]['Name'], '(guess)', ('(%s)' % val_type))
self.universal_attr_offsets[offset]['Parser'](val)
return
except KeyError:
pass
if (self.service_clses[0] == HFServiceRecord.service_clses[0]['UUID']):
hfsr = HFServiceRecord(self.record_xml)
print(('0x%04x:' % attr_id), hfsr.attrs[attr_id]['Name'], ('(%s)' % val_type))
hfsr.attrs[attr_id]['Parser'](val)
elif (self.service_clses[0] == AGServiceRecord.service_clses[0]['UUID']):
agsr = AGServiceRecord(self.record_xml)
print(('0x%04x:' % attr_id), agsr.attrs[attr_id]['Name'], ('(%s)' % val_type))
agsr.attrs[attr_id]['Parser'](val)
elif (self.service_clses[0] == MSEServiceRecord.service_clses[0]['UUID']):
msesr = MSEServiceRecord(self.record_xml)
print(('0x%04x:' % attr_id), msesr.attrs[attr_id]['Name'], ('(%s)' % val_type))
msesr.attrs[attr_id]['Parser'](val)
elif (self.service_clses[0] == MCEServiceRecord.service_clses[0]['UUID']):
mcesr = MCEServiceRecord(self.record_xml)
print(('0x%04x:' % attr_id), mcesr.attrs[attr_id]['Name'], ('(%s)' % val_type))
mcesr.attrs[attr_id]['Parser'](val)
elif (self.service_clses[0] == HIDServiceRecord.service_clses[0]['UUID']):
hidsr = HIDServiceRecord(self.record_xml)
print(('0x%04x:' % attr_id), hidsr.attrs[attr_id]['Name'], ('(%s)' % val_type))
hidsr.attrs[attr_id]['Parser'](val)
elif (self.service_clses[0] == ObjPushServiceRecord.service_clses[0]['UUID']):
opsr = ObjPushServiceRecord(self.record_xml)
print(('0x%04x:' % attr_id), opsr.attrs[attr_id]['Name'], '(guess)', ('(%s)' % val_type))
opsr.attrs[attr_id]['Parser'](val)
else:
print(('0x%04x:' % attr_id), red('unknown'))
for elem in list(attr):
s = [i.strip() for i in ElementTree.tostring(elem).decode().strip().replace('\t', '').split('\n')]
for i in s:
print(('\t' + i))
def pp_service_cls_list(self, seq: ElementTree.Element):
uuids = seq.findall('./uuid')
for uuid in uuids:
uuid = uuid.attrib['value']
print((('\t' + uuid) + ':'), end=' ')
try:
uuid = int(uuid[2:], base=16)
except ValueError:
pass
self.service_clses.append(uuid)
try:
if ('Service Class' in service_cls_profile_ids[uuid]['Allowed Usage']):
name = service_cls_profile_ids[uuid]['Name']
print(green(name))
else:
print(red('unknown'))
except KeyError:
if (uuid == 6144):
print(green('Generic Access'))
elif (uuid == 6145):
print(green('Generic Attribute'))
else:
print(red('unknown'))
def pp_protocol_descp_list(self, seq: ElementTree.Element):
protocols = seq.findall('./sequence')
for protocol in protocols:
uuid = protocol.find('./uuid').attrib['value']
print((('\t' + uuid) + ':'), end=' ')
try:
name = protocol_ids[uuid]['Name']
print(name)
if (name == 'L2CAP'):
try:
psm = protocol.find('./uint16').attrib['value']
print(('\t\t' + 'PSM:'), psm)
except AttributeError:
pass
elif (name == 'RFCOMM'):
channel = protocol.find('./uint8').attrib['value']
print('\t\tchannel:', channel)
elif (name in ('AVDTP', 'AVCTP')):
version = int(protocol.find('./uint16').attrib['value'][2:], base=16)
print(('\t\tv%d.%d' % ((version >> 8), (version & 255))))
elif (name in 'BNEP'):
version = protocol.find('./uint16').attrib['value']
print('\t\tversion:', version)
uint16s = protocol.find('./sequence').findall('./uint16')
for val in uint16s:
print('\t\tuint16:', val.attrib['value'])
else:
for elem in list(protocol)[1:]:
s = ElementTree.tostring(elem).decode().strip().replace('\t', '').split('\n')
for i in s:
print(('\t\t' + i))
except KeyError:
print('(Unknown)')
def pp_browse_group_list(self, seq: ElementTree.Element):
uuids = seq.findall('./uuid')
for uuid in uuids:
uuid = uuid.attrib['value']
print((('\t' + uuid) + ':'), end=' ')
if (uuid == '0x1002'):
print(green('PublicBrowseRoot'))
else:
print('Unknown')
def pp_lang_base_attr_id_list(self, seq: ElementTree.Element):
values = seq.findall('./uint16')
triplets = []
for i in range(0, len(values), 3):
triplets.append(values[i:(i + 3)])
for triplet in triplets:
lang_name = triplet[0].attrib['value']
encoding = triplet[1].attrib['value']
base = triplet[2].attrib['value']
print('\tlanguage name:', lang_name)
print('\tencoding:', encoding)
print('\tattribute ID base:', base)
self.attr_id_bases.append(int(base[2:], base=16))
def pp_bt_profile_descp_list(self, seq: ElementTree.Element):
profiles = seq.findall('./sequence')
for profile in profiles:
uuid = profile.find('./uuid').attrib['value']
print((('\t' + uuid) + ':'), end=' ')
try:
uuid = int(uuid[2:], base=16)
except ValueError:
pass
try:
if ('Profile' in service_cls_profile_ids[uuid]['Allowed Usage']):
name = service_cls_profile_ids[uuid]['Name']
print(green(name), end=' ')
else:
print(red('unknown'), end=' ')
version = int(profile.find('./uint16').attrib['value'][2:], base=16)
print(green(('v%d.%d' % ((version >> 8), (version & 255)))))
except KeyError:
print(red('unknown'))
def pp_additional_protocol_descp_lists(self, seq: ElementTree.Element):
sequences = seq.findall('./sequence')
for sequence in sequences:
self.pp_protocol_descp_list(sequence) |
class OptionSeriesSankeySonificationContexttracksMappingPan(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
def test_regression():
(X, y) = df_regression()
sel = SelectByTargetMeanPerformance(variables=None, bins=2, scoring='r2', regression=True, cv=2, strategy='equal_width', threshold=None)
sel.fit(X, y)
Xtransformed = X[['cat_var_A', 'cat_var_B', 'num_var_A']]
performance_dict = {'cat_var_A': 1.0, 'cat_var_B': 0., 'num_var_A': 0.8, 'num_var_B': 0.512}
assert (sel.features_to_drop_ == ['num_var_B'])
assert (sel.feature_performance_ == performance_dict)
pd.testing.assert_frame_equal(sel.transform(X), Xtransformed)
(X, y) = df_regression()
sel = SelectByTargetMeanPerformance(variables=['cat_var_A', 'cat_var_B', 'num_var_A', 'num_var_B'], bins=2, scoring='neg_root_mean_squared_error', regression=True, cv=2, strategy='equal_width', threshold=(- 0.2))
sel.fit(X, y)
Xtransformed = X['cat_var_A'].to_frame()
performance_dict = {'cat_var_A': 0.0, 'cat_var_B': (- 0.), 'num_var_A': (- 0.5), 'num_var_B': (- 0.)}
assert (sel.features_to_drop_ == ['cat_var_B', 'num_var_A', 'num_var_B'])
assert (sel.feature_performance_ == performance_dict)
pd.testing.assert_frame_equal(sel.transform(X), Xtransformed) |
_log_on_failure_all
class TestSlowQueue():
_log_on_failure
def setup_class(cls):
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
cls.multiplexers = []
try:
port_genesis = (DEFAULT_PORT + 10)
temp_dir_gen = os.path.join(cls.t, 'temp_dir_gen')
os.mkdir(temp_dir_gen)
cls.bad_address = _make_libp2p_connection(data_dir=temp_dir_gen, port=port_genesis).node.address
cls.connection_genesis = _make_libp2p_connection(data_dir=temp_dir_gen, port=port_genesis)
cls.multiplexer_genesis = Multiplexer([cls.connection_genesis], protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection_genesis.node.log_file)
cls.multiplexer_genesis.connect()
cls.multiplexers.append(cls.multiplexer_genesis)
genesis_peer = cls.connection_genesis.node.multiaddrs[0]
cls.connections = [cls.connection_genesis]
temp_dir = os.path.join(cls.t, 'temp_dir_100')
os.mkdir(temp_dir)
cls.conn = _make_libp2p_connection(data_dir=temp_dir, port=(port_genesis + 100), entry_peers=[genesis_peer])
port = port_genesis
for i in range(2):
port += 1
temp_dir = os.path.join(cls.t, f'temp_dir_{i}')
os.mkdir(temp_dir)
conn = _make_libp2p_connection(data_dir=temp_dir, port=port, entry_peers=[genesis_peer])
mux = Multiplexer([conn], protocols=[MockDefaultMessageProtocol])
cls.connections.append(conn)
cls.log_files.append(conn.node.log_file)
mux.connect()
cls.multiplexers.append(mux)
for conn in cls.connections:
assert (conn.is_connected is True)
except Exception as e:
cls.teardown_class()
raise e
.asyncio
async def test_slow_queue(self):
con2 = self.connections[(- 1)]
(await self.conn.connect())
def _make_envelope(addr):
msg = DefaultMessage(dialogue_reference=('', ''), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b'hello')
envelope = Envelope(to=addr, sender=self.conn.node.address, message=msg)
return envelope
try:
for _ in range(50):
for addr in [con2.node.address, self.bad_address]:
(await self.conn._node_client.send_envelope(_make_envelope(addr)))
for _ in range(2):
for addr in [self.bad_address, con2.node.address]:
(await self.conn._node_client.send_envelope(_make_envelope(addr)))
def _check():
with open(self.conn.node.log_file) as f:
return ('while sending slow envelope:' in f.read())
wait_for_condition(_check, timeout=30, period=0.1)
finally:
(await self.conn.disconnect())
def teardown_class(cls):
for mux in cls.multiplexers:
mux.disconnect()
os.chdir(cls.cwd)
try:
shutil.rmtree(cls.t)
except (OSError, IOError):
pass |
class ProductCatalogImageSettingsOperation(AbstractObject):
def __init__(self, api=None):
super(ProductCatalogImageSettingsOperation, self).__init__()
self._isProductCatalogImageSettingsOperation = True
self._api = api
class Field(AbstractObject.Field):
transformation_type = 'transformation_type'
_field_types = {'transformation_type': 'string'}
def _get_field_enum_info(cls):
field_enum_info = {}
return field_enum_info |
def test_dstdirs_to_furthest_phase() -> None:
all_jobs = [job_w_dstdir_phase('/plots1', job.Phase(1, 5)), job_w_dstdir_phase('/plots2', job.Phase(1, 1)), job_w_dstdir_phase('/plots2', job.Phase(3, 1)), job_w_dstdir_phase('/plots2', job.Phase(2, 1)), job_w_dstdir_phase('/plots3', job.Phase(4, 1))]
assert (manager.dstdirs_to_furthest_phase(all_jobs) == {'/plots1': job.Phase(1, 5), '/plots2': job.Phase(3, 1), '/plots3': job.Phase(4, 1)}) |
def test_with_gen_kw(copy_case, storage):
copy_case('snake_oil')
ert_config = ErtConfig.from_file('snake_oil.ert')
experiment_id = storage.create_experiment(parameters=ert_config.ensemble_config.parameter_configuration)
prior_ensemble = storage.create_ensemble(experiment_id, name='prior', ensemble_size=1)
prior = ensemble_context(prior_ensemble, [True], 0, None, '', ert_config.model_config.runpath_format_string, 'name')
sample_prior(prior_ensemble, [0])
create_run_path(prior, ert_config.substitution_list, ert_config)
assert os.path.exists('storage/snake_oil/runpath/realization-0/iter-0/parameters.txt')
assert (len(os.listdir('storage/snake_oil/runpath')) == 1)
assert (len(os.listdir('storage/snake_oil/runpath/realization-0')) == 1) |
class InMemoryAttribute(IAttribute):
def __init__(self, pk, **kwargs):
self.id = pk
self.pk = pk
for (key, value) in kwargs.items():
if (key == 'value'):
self.value = value
elif (key == 'lock_storage'):
self.lock_storage = value
else:
setattr(self, f'db_{key}', value)
def __value_get(self):
return self.db_value
def __value_set(self, new_value):
self.db_value = new_value
def __value_del(self):
pass
value = property(__value_get, __value_set, __value_del) |
class TestUpdateModel():
def setup_class(cls):
cred = testutils.MockCredential()
firebase_admin.initialize_app(cred, {'projectId': PROJECT_ID})
ml._MLService.POLL_BASE_WAIT_TIME_SECONDS = 0.1
def teardown_class(cls):
testutils.cleanup_apps()
def _url(project_id, model_id):
return (BASE_URL + 'projects/{0}/models/{1}'.format(project_id, model_id))
def _op_url(project_id):
return (BASE_URL + 'projects/{0}/operations/123'.format(project_id))
def test_immediate_done(self):
instrument_ml_service(status=200, payload=OPERATION_DONE_RESPONSE)
model = ml.update_model(MODEL_1)
assert (model == CREATED_UPDATED_MODEL_1)
def test_returns_locked(self):
recorder = instrument_ml_service(status=[200, 200], payload=[OPERATION_NOT_DONE_RESPONSE, LOCKED_MODEL_2_RESPONSE])
expected_model = ml.Model.from_dict(LOCKED_MODEL_JSON_2)
model = ml.update_model(MODEL_1)
assert (model == expected_model)
assert (len(recorder) == 2)
assert (recorder[0].method == 'PATCH')
assert (recorder[0].url == TestUpdateModel._url(PROJECT_ID, MODEL_ID_1))
assert (recorder[0].headers[HEADER_CLIENT_KEY] == HEADER_CLIENT_VALUE)
assert (recorder[1].method == 'GET')
assert (recorder[1].url == TestUpdateModel._url(PROJECT_ID, MODEL_ID_1))
assert (recorder[1].headers[HEADER_CLIENT_KEY] == HEADER_CLIENT_VALUE)
def test_operation_error(self):
instrument_ml_service(status=200, payload=OPERATION_ERROR_RESPONSE)
with pytest.raises(Exception) as excinfo:
ml.update_model(MODEL_1)
check_operation_error(excinfo, OPERATION_ERROR_EXPECTED_STATUS, OPERATION_ERROR_MSG)
def test_malformed_operation(self):
instrument_ml_service(status=200, payload=OPERATION_MALFORMED_RESPONSE)
with pytest.raises(Exception) as excinfo:
ml.update_model(MODEL_1)
check_error(excinfo, exceptions.UnknownError, 'Internal Error: Malformed Operation.')
def test_rpc_error(self):
create_recorder = instrument_ml_service(status=400, payload=ERROR_RESPONSE_BAD_REQUEST)
with pytest.raises(Exception) as excinfo:
ml.update_model(MODEL_1)
check_firebase_error(excinfo, ERROR_STATUS_BAD_REQUEST, ERROR_CODE_BAD_REQUEST, ERROR_MSG_BAD_REQUEST)
assert (len(create_recorder) == 1)
.parametrize('model', INVALID_MODEL_ARGS)
def test_not_model(self, model):
with pytest.raises(Exception) as excinfo:
ml.update_model(model)
check_error(excinfo, TypeError, 'Model must be an ml.Model.')
def test_missing_display_name(self):
with pytest.raises(Exception) as excinfo:
ml.update_model(ml.Model.from_dict({}))
check_error(excinfo, ValueError, 'Model must have a display name.')
def test_missing_op_name(self):
instrument_ml_service(status=200, payload=OPERATION_MISSING_NAME_RESPONSE)
with pytest.raises(Exception) as excinfo:
ml.update_model(MODEL_1)
check_error(excinfo, TypeError)
.parametrize('op_name', INVALID_OP_NAME_ARGS)
def test_invalid_op_name(self, op_name):
payload = json.dumps({'name': op_name})
instrument_ml_service(status=200, payload=payload)
with pytest.raises(Exception) as excinfo:
ml.update_model(MODEL_1)
check_error(excinfo, ValueError, 'Operation name format is invalid.') |
class OptionSeriesHistogramSonificationTracksMappingHighpassResonance(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
def workflow_expect_event_tuples(workflow: Workflow) -> Set[EventKeyTuple]:
result_keys = set()
for (task_name, rules) in workflow.rules.items():
for rule in rules:
keys = expect_keys_to_tuple_set(workflow.namespace, rule.condition.expect_event_keys)
result_keys = (result_keys | keys)
return result_keys |
class OptionSeriesPictorialSonificationContexttracksMappingHighpass(Options):
def frequency(self) -> 'OptionSeriesPictorialSonificationContexttracksMappingHighpassFrequency':
return self._config_sub_data('frequency', OptionSeriesPictorialSonificationContexttracksMappingHighpassFrequency)
def resonance(self) -> 'OptionSeriesPictorialSonificationContexttracksMappingHighpassResonance':
return self._config_sub_data('resonance', OptionSeriesPictorialSonificationContexttracksMappingHighpassResonance) |
.skip
def test_molcas_s1_opt():
path = Path(os.path.dirname(os.path.abspath(__file__)))
xyz_fn = (path / 'trans_butadien.xyz')
inporb_fn = (path / 'butadien_vdzp.RasOrb')
geom = geom_from_xyz_file(xyz_fn)
kwargs = {'basis': 'ano-rcc-vdzp', 'inporb': inporb_fn, 'charge': 0, 'mult': 1, 'roots': 5, 'mdrlxroot': 2}
calc = OpenMolcas(**kwargs)
geom.set_calculator(calc)
opt_kwargs = {'dump': True, 'max_cycles': 5}
opt = BFGS(geom, **opt_kwargs)
opt.run()
assert (opt.max_forces[(- 1)] == pytest.approx(0.))
assert (opt.rms_forces[(- 1)] == pytest.approx(0.)) |
def setup_logger(name, log_file, level=logging.INFO, formatter=None):
if (not formatter):
formatter = logging.Formatter('%(asctime)s\t%(levelname)s\t%(message)s')
handler = RotatingFileHandler(log_file, maxBytes=, backupCount=50)
handler.setFormatter(formatter)
logger = logging.getLogger(name)
logger.setLevel(level)
if (not logger.hasHandlers()):
logger.addHandler(handler)
return logger |
class TaxAgencyTests(unittest.TestCase):
def test_unicode(self):
transfer = Transfer()
transfer.Amount = 100
self.assertEqual(str(transfer), '100')
def test_valid_object_name(self):
obj = Transfer()
client = QuickBooks()
result = client.isvalid_object_name(obj.qbo_object_name)
self.assertTrue(result) |
.parametrize('max_age', [0, 300])
def test_yaml_loader_without_cache(tmpdir, mocker, yaml_string, expected_from_loader, max_age):
mock_resp = mocker.Mock()
mock_resp.status_code = 200
mock_resp.text = yaml_string
mock_get = mocker.patch('requests.Session.get', return_value=mock_resp)
mock_mal = mocker.patch('awsrun.acctload.MetaAccountLoader.__init__')
mocker.patch('tempfile.gettempdir', return_value=tmpdir)
url = '
acctload.YAMLAccountLoader(url, max_age=max_age)
mock_get.assert_called_once()
((url_called,), _) = mock_get.call_args
assert (url == url_called)
((accts,), _) = mock_mal.call_args
assert (accts == expected_from_loader)
if (max_age == 0):
with pytest.raises(FileNotFoundError):
with open(tmpdir.join('awsrun.dat'), encoding='utf-8') as f:
pass
else:
with open(tmpdir.join('awsrun.dat'), encoding='utf-8') as f:
cached_accts = yaml.safe_load(f)
assert (accts == cached_accts) |
class CreateRevisionFollowTest(TestBase):
def testCreateRevisionFollow(self):
reversion.register(TestModel, follow=('related',))
reversion.register(TestModelRelated)
obj_related = TestModelRelated.objects.create()
with reversion.create_revision():
obj = TestModel.objects.create()
obj.related.add(obj_related)
self.assertSingleRevision((obj, obj_related))
def testCreateRevisionFollowThrough(self):
reversion.register(TestModel, follow=('related_through',))
reversion.register(TestModelThrough, follow=('test_model', 'test_model_related'))
reversion.register(TestModelRelated)
obj_related = TestModelRelated.objects.create()
with reversion.create_revision():
obj = TestModel.objects.create()
obj_through = TestModelThrough.objects.create(test_model=obj, test_model_related=obj_related)
self.assertSingleRevision((obj, obj_through, obj_related))
def testCreateRevisionFollowInvalid(self):
reversion.register(TestModel, follow=('name',))
with reversion.create_revision():
with self.assertRaises(reversion.RegistrationError):
TestModel.objects.create() |
def extractHiohbyeTranslations(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol or frag)) or ('preview' in item['title'].lower())):
return None
if ('The Corpse King Confuses the World, All Seven Husbands Are Devils' in item['tags']):
return buildReleaseMessageWithType(item, 'The Corpse King Confuses the World, All Seven Husbands Are Devils', vol, chp, frag=frag, postfix=postfix)
tagmap = [('The Corpse King Confuses the World, All Seven Husbands Are Devils', 'The Corpse King Confuses the World, All Seven Husbands Are Devils', 'translated'), ('Blood-Sucking Empress', 'Blood-Sucking Empress', 'translated'), ('Seventh Imperial "Brother"', 'Seventh Imperial "Brother"', 'translated'), ("Chang'an Intoxicated", "Chang'an Intoxicated", 'translated'), ('mistress, i want it', 'mistress, i want it', 'translated'), ('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
def test():
assert (('token1.similarity(token2)' in __solution__) or ('token2.similarity(token1)' in __solution__)), 'Voce esta comparando a similaridade entre os dois tokens?'
assert (0 <= float(similarity) <= 1), 'O valor da similaridade deve ser um numero de ponto flutuante. Voce fez este calculo corretamente?'
__msg__.good('Bom!') |
class LayoutEukOgs(TreeLayout):
def __init__(self, name='OGs euk', text_color='grey'):
super().__init__(name, aligned_faces=True)
self.text_color = text_color
def set_node_style(self, node):
if node.is_leaf:
if node.props.get('OG_euk'):
OG = node.props.get('OG_euk')
og_face = TextFace(OG, color=self.text_color)
node.add_face(og_face, column=6, position='aligned')
else:
target_leaf = node.get_leaves()[0]
if target_leaf.props.get('OG_euk'):
OG = target_leaf.props.get('OG_euk')
og_face = TextFace(OG, color=self.text_color)
node.add_face(og_face, column=6, position='aligned', collapsed_only=True) |
def test_machine_should_not_allow_transitions_from_final_state():
with pytest.raises(exceptions.InvalidDefinition):
class CampaignMachine(StateMachine):
draft = State(initial=True)
producing = State()
closed = State(final=True)
add_job = ((draft.to(draft) | producing.to(producing)) | closed.to(draft))
produce = draft.to(producing)
deliver = producing.to(closed) |
class TestESP32FlashHeader(BaseTestCase):
def test_16mb(self):
ELF = 'esp32-app-template.elf'
BIN = 'esp32-app-template.bin'
try:
self.run_elf2image('esp32', ELF, extra_args=['--flash_size', '16MB', '--flash_mode', 'dio', '--min-rev', '1'])
with open(BIN, 'rb') as f:
header = f.read(24)
self.assertEqualHex(233, header[0])
self.assertEqualHex(2, header[2])
self.assertEqualHex(64, header[3])
self.assertEqualHex(1, header[14])
finally:
try_delete(BIN) |
class OptionSeriesTreegraphAccessibilityPoint(Options):
def dateFormat(self):
return self._config_get(None)
def dateFormat(self, text: str):
self._config(text, js_type=False)
def dateFormatter(self):
return self._config_get(None)
def dateFormatter(self, value: Any):
self._config(value, js_type=False)
def describeNull(self):
return self._config_get(True)
def describeNull(self, flag: bool):
self._config(flag, js_type=False)
def descriptionFormat(self):
return self._config_get(None)
def descriptionFormat(self, text: str):
self._config(text, js_type=False)
def descriptionFormatter(self):
return self._config_get(None)
def descriptionFormatter(self, value: Any):
self._config(value, js_type=False)
def valueDecimals(self):
return self._config_get(None)
def valueDecimals(self, num: float):
self._config(num, js_type=False)
def valueDescriptionFormat(self):
return self._config_get('{xDescription}{separator}{value}.')
def valueDescriptionFormat(self, text: str):
self._config(text, js_type=False)
def valuePrefix(self):
return self._config_get(None)
def valuePrefix(self, text: str):
self._config(text, js_type=False)
def valueSuffix(self):
return self._config_get(None)
def valueSuffix(self, text: str):
self._config(text, js_type=False) |
class ClickType(Enum):
SINGLE = auto()
DOUBLE = auto()
def from_click_times(cls, last_click_time, previous_click_time) -> 'ClickType':
if (previous_click_time is None):
return cls.SINGLE
if ((last_click_time - previous_click_time) < _DOUBLE_CLICK_THRESHOLD_SECONDS):
return cls.DOUBLE
return cls.SINGLE |
class LiteEthPHYRGMIIRX(LiteXModule):
def __init__(self, pads, rx_delay=2e-09, usp=False):
self.source = source = stream.Endpoint(eth_phy_description(8))
rx_ctl_ibuf = Signal()
rx_ctl_idelay = Signal()
rx_ctl = Signal()
rx_data_ibuf = Signal(4)
rx_data_idelay = Signal(4)
rx_data = Signal(8)
self.specials += [Instance('IBUF', i_I=pads.rx_ctl, o_O=rx_ctl_ibuf), Instance('IDELAYE3', p_DELAY_SRC='IDATAIN', p_CASCADE='NONE', p_DELAY_TYPE='FIXED', p_DELAY_VALUE=int((rx_delay * .0)), p_REFCLK_FREQUENCY=300.0, p_DELAY_FORMAT='TIME', p_UPDATE_MODE='ASYNC', p_SIM_DEVICE=('ULTRASCALE_PLUS' if usp else 'ULTRASCALE'), i_CASC_IN=0, i_CASC_RETURN=0, i_CE=0, i_CLK=0, i_INC=0, i_LOAD=0, i_CNTVALUEIN=0, i_IDATAIN=rx_ctl_ibuf, i_RST=0, i_EN_VTC=1, o_DATAOUT=rx_ctl_idelay), Instance('IDDRE1', p_DDR_CLK_EDGE='SAME_EDGE_PIPELINED', p_IS_C_INVERTED=0, p_IS_CB_INVERTED=1, i_C=ClockSignal('eth_rx'), i_CB=ClockSignal('eth_rx'), i_R=0, i_D=rx_ctl_idelay, o_Q1=rx_ctl, o_Q2=Signal())]
for i in range(4):
self.specials += [Instance('IBUF', i_I=pads.rx_data[i], o_O=rx_data_ibuf[i]), Instance('IDELAYE3', p_DELAY_SRC='IDATAIN', p_CASCADE='NONE', p_DELAY_TYPE='FIXED', p_DELAY_VALUE=int((rx_delay * .0)), p_REFCLK_FREQUENCY=300.0, p_UPDATE_MODE='ASYNC', p_DELAY_FORMAT='TIME', p_SIM_DEVICE=('ULTRASCALE_PLUS' if usp else 'ULTRASCALE'), i_CASC_IN=0, i_CASC_RETURN=0, i_CE=0, i_CLK=0, i_INC=0, i_LOAD=0, i_CNTVALUEIN=0, i_IDATAIN=rx_data_ibuf[i], i_RST=0, i_EN_VTC=1, o_DATAOUT=rx_data_idelay[i]), Instance('IDDRE1', p_DDR_CLK_EDGE='SAME_EDGE_PIPELINED', p_IS_C_INVERTED=0, p_IS_CB_INVERTED=1, i_C=ClockSignal('eth_rx'), i_CB=ClockSignal('eth_rx'), i_R=0, i_D=rx_data_idelay[i], o_Q1=rx_data[i], o_Q2=rx_data[(i + 4)])]
rx_ctl_d = Signal()
self.sync += rx_ctl_d.eq(rx_ctl)
last = Signal()
self.comb += last.eq(((~ rx_ctl) & rx_ctl_d))
self.sync += [source.valid.eq(rx_ctl), source.data.eq(rx_data)]
self.comb += source.last.eq(last) |
def get_log_rhos(target_action_log_probs: List[TorchActionType], behaviour_action_log_probs: List[TorchActionType]) -> List[torch.Tensor]:
log_rhos = list()
with torch.no_grad():
for (step_target_action_log_probs, step_behaviour_action_log_probs) in zip(target_action_log_probs, behaviour_action_log_probs):
target = torch.stack(list(step_target_action_log_probs.values()))
behaviour = torch.stack(list(step_behaviour_action_log_probs.values()))
step_log_rhos = torch.sum((target - behaviour), dim=0)
log_rhos.append(step_log_rhos)
return log_rhos |
.xfail(reason='Test case should fail because of wrong input.')
def test_significant_one_gene_bigwig_fail():
outfile = NamedTemporaryFile(suffix='.tar.gz', delete=False)
outfile.close()
args = '-f {} -o {} -om {} -omn {} -oft {}'.format((ROOT + 'chicSignificantInteractions/significantInteractions_dual.hdf5'), outfile.name, 'geneName', 'Eya1', 'bigwig').split()
chicExportData.main(args) |
def test_make_hash():
assert (make_hash({'a': 1}) == make_hash({'a': 1}))
assert (make_hash({'a': 1}) != make_hash({'a': 2}))
assert (make_hash({'a': 1, 'b': 2}) == make_hash({'a': 1, 'b': 2}))
assert (make_hash({'a': 1, 'b': 2}) != make_hash({'a': 2, 'b': 1}))
def make_complex_object():
return {'a': {'b': [1, {'c': 2}, {3, 'f', 4}]}}
hashes = []
for _ in range(6):
hashes.append(make_hash(make_complex_object()))
assert (len(set(hashes)) == 1) |
class Migration(migrations.Migration):
dependencies = [('awards', '0095_auto__1620'), ('references', '0058_bureautitlelookup'), ('search', '0009_awardsearch_view_drop')]
operations = [CreateExtension('intarray'), CreateExtension('pg_trgm'), migrations.CreateModel(name='SubawardSearch', fields=[('broker_created_at', models.DateTimeField(blank=True, db_index=True, null=True)), ('broker_updated_at', models.DateTimeField(blank=True, db_index=True, null=True)), ('broker_subaward_id', models.BigIntegerField(db_index=True, primary_key=True, serialize=False, unique=True)), ('unique_award_key', models.TextField(blank=True, db_index=True, null=True)), ('award_piid_fain', models.TextField(blank=True, null=True)), ('parent_award_id', models.TextField(blank=True, null=True)), ('award_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('action_date', models.DateField(blank=True, null=True)), ('fy', models.TextField(blank=True, null=True)), ('awarding_agency_code', models.TextField(blank=True, null=True)), ('awarding_agency_name', models.TextField(blank=True, null=True)), ('awarding_sub_tier_agency_c', models.TextField(blank=True, null=True)), ('awarding_sub_tier_agency_n', models.TextField(blank=True, null=True)), ('awarding_office_code', models.TextField(blank=True, null=True)), ('awarding_office_name', models.TextField(blank=True, null=True)), ('funding_agency_code', models.TextField(blank=True, null=True)), ('funding_agency_name', models.TextField(blank=True, null=True)), ('funding_sub_tier_agency_co', models.TextField(blank=True, null=True)), ('funding_sub_tier_agency_na', models.TextField(blank=True, null=True)), ('funding_office_code', models.TextField(blank=True, null=True)), ('funding_office_name', models.TextField(blank=True, null=True)), ('awardee_or_recipient_uniqu', models.TextField(blank=True, null=True)), ('awardee_or_recipient_uei', models.TextField(blank=True, null=True)), ('awardee_or_recipient_legal', models.TextField(blank=True, null=True)), ('dba_name', models.TextField(blank=True, null=True)), ('ultimate_parent_unique_ide', models.TextField(blank=True, null=True)), ('ultimate_parent_uei', models.TextField(blank=True, null=True)), ('ultimate_parent_legal_enti', models.TextField(blank=True, null=True)), ('legal_entity_country_code', models.TextField(blank=True, null=True)), ('legal_entity_country_name', models.TextField(blank=True, null=True)), ('legal_entity_state_code', models.TextField(blank=True, null=True)), ('legal_entity_state_name', models.TextField(blank=True, null=True)), ('legal_entity_zip', models.TextField(blank=True, null=True)), ('legal_entity_congressional', models.TextField(blank=True, null=True)), ('legal_entity_foreign_posta', models.TextField(blank=True, null=True)), ('legal_entity_city_name', models.TextField(blank=True, null=True)), ('legal_entity_address_line1', models.TextField(blank=True, null=True)), ('business_types', models.TextField(blank=True, null=True)), ('place_of_perform_country_co', models.TextField(blank=True, null=True)), ('place_of_perform_country_na', models.TextField(blank=True, null=True)), ('place_of_perform_state_code', models.TextField(blank=True, null=True)), ('place_of_perform_state_name', models.TextField(blank=True, null=True)), ('place_of_performance_zip', models.TextField(blank=True, null=True)), ('place_of_perform_congressio', models.TextField(blank=True, null=True)), ('place_of_perform_city_name', models.TextField(blank=True, null=True)), ('place_of_perform_street', models.TextField(blank=True, null=True)), ('award_description', models.TextField(blank=True, null=True)), ('naics', models.TextField(blank=True, null=True)), ('naics_description', models.TextField(blank=True, null=True)), ('cfda_numbers', models.TextField(blank=True, null=True)), ('cfda_titles', models.TextField(blank=True, null=True)), ('subaward_type', models.TextField(blank=True, null=True)), ('subaward_report_year', models.SmallIntegerField()), ('subaward_report_month', models.SmallIntegerField()), ('subaward_number', models.TextField(blank=True, null=True)), ('subaward_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('sub_action_date', models.DateField(blank=True, null=True)), ('sub_awardee_or_recipient_uniqu', models.TextField(blank=True, null=True)), ('sub_awardee_or_recipient_uei', models.TextField(blank=True, null=True)), ('sub_awardee_or_recipient_legal_raw', models.TextField(blank=True, null=True)), ('sub_dba_name', models.TextField(blank=True, null=True)), ('sub_ultimate_parent_unique_ide', models.TextField(blank=True, null=True)), ('sub_ultimate_parent_uei', models.TextField(blank=True, null=True)), ('sub_ultimate_parent_legal_enti_raw', models.TextField(blank=True, null=True)), ('sub_legal_entity_country_code_raw', models.TextField(blank=True, null=True)), ('sub_legal_entity_country_name_raw', models.TextField(blank=True, null=True)), ('sub_legal_entity_state_code', models.TextField(blank=True, null=True)), ('sub_legal_entity_state_name', models.TextField(blank=True, null=True)), ('sub_legal_entity_zip', models.TextField(blank=True, null=True)), ('sub_legal_entity_congressional_raw', models.TextField(blank=True, null=True)), ('sub_legal_entity_foreign_posta', models.TextField(blank=True, null=True)), ('sub_legal_entity_city_name', models.TextField(blank=True, null=True)), ('sub_legal_entity_address_line1', models.TextField(blank=True, null=True)), ('sub_business_types', models.TextField(blank=True, null=True)), ('sub_place_of_perform_country_co_raw', models.TextField(blank=True, null=True)), ('sub_place_of_perform_country_na', models.TextField(blank=True, null=True)), ('sub_place_of_perform_state_code', models.TextField(blank=True, null=True)), ('sub_place_of_perform_state_name', models.TextField(blank=True, null=True)), ('sub_place_of_performance_zip', models.TextField(blank=True, null=True)), ('sub_place_of_perform_congressio_raw', models.TextField(blank=True, null=True)), ('sub_place_of_perform_city_name', models.TextField(blank=True, null=True)), ('sub_place_of_perform_street', models.TextField(blank=True, null=True)), ('subaward_description', models.TextField(blank=True, null=True)), ('sub_high_comp_officer1_full_na', models.TextField(blank=True, null=True)), ('sub_high_comp_officer1_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('sub_high_comp_officer2_full_na', models.TextField(blank=True, null=True)), ('sub_high_comp_officer2_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('sub_high_comp_officer3_full_na', models.TextField(blank=True, null=True)), ('sub_high_comp_officer3_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('sub_high_comp_officer4_full_na', models.TextField(blank=True, null=True)), ('sub_high_comp_officer4_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('sub_high_comp_officer5_full_na', models.TextField(blank=True, null=True)), ('sub_high_comp_officer5_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('prime_id', models.IntegerField(blank=True, db_index=True, null=True)), ('internal_id', models.TextField(blank=True, db_index=True, null=True)), ('date_submitted', models.DateTimeField(blank=True, null=True)), ('report_type', models.TextField(blank=True, null=True)), ('transaction_type', models.TextField(blank=True, null=True)), ('program_title', models.TextField(blank=True, null=True)), ('contract_agency_code', models.TextField(blank=True, null=True)), ('contract_idv_agency_code', models.TextField(blank=True, null=True)), ('grant_funding_agency_id', models.TextField(blank=True, null=True)), ('grant_funding_agency_name', models.TextField(blank=True, null=True)), ('federal_agency_name', models.TextField(blank=True, null=True)), ('treasury_symbol', models.TextField(blank=True, null=True)), ('dunsplus4', models.TextField(blank=True, null=True)), ('recovery_model_q1', models.BooleanField(blank=True, null=True)), ('recovery_model_q2', models.BooleanField(blank=True, null=True)), ('compensation_q1', models.BooleanField(blank=True, null=True)), ('compensation_q2', models.BooleanField(blank=True, null=True)), ('high_comp_officer1_full_na', models.TextField(blank=True, null=True)), ('high_comp_officer1_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('high_comp_officer2_full_na', models.TextField(blank=True, null=True)), ('high_comp_officer2_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('high_comp_officer3_full_na', models.TextField(blank=True, null=True)), ('high_comp_officer3_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('high_comp_officer4_full_na', models.TextField(blank=True, null=True)), ('high_comp_officer4_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('high_comp_officer5_full_na', models.TextField(blank=True, null=True)), ('high_comp_officer5_amount', models.DecimalField(blank=True, decimal_places=2, max_digits=23, null=True)), ('sub_id', models.IntegerField(blank=True, null=True)), ('sub_parent_id', models.IntegerField(blank=True, null=True)), ('sub_federal_agency_id', models.TextField(blank=True, null=True)), ('sub_federal_agency_name', models.TextField(blank=True, null=True)), ('sub_funding_agency_id', models.TextField(blank=True, null=True)), ('sub_funding_agency_name', models.TextField(blank=True, null=True)), ('sub_funding_office_id', models.TextField(blank=True, null=True)), ('sub_funding_office_name', models.TextField(blank=True, null=True)), ('sub_naics', models.TextField(blank=True, null=True)), ('sub_cfda_numbers', models.TextField(blank=True, null=True)), ('sub_dunsplus4', models.TextField(blank=True, null=True)), ('sub_recovery_subcontract_amt', models.TextField(blank=True, null=True)), ('sub_recovery_model_q1', models.BooleanField(blank=True, null=True)), ('sub_recovery_model_q2', models.BooleanField(blank=True, null=True)), ('sub_compensation_q1', models.BooleanField(blank=True, null=True)), ('sub_compensation_q2', models.BooleanField(blank=True, null=True)), ('prime_award_group', models.TextField(blank=True, null=True)), ('prime_award_type', models.TextField(blank=True, null=True)), ('piid', models.TextField(blank=True, null=True)), ('fain', models.TextField(blank=True, null=True)), ('latest_transaction_id', models.BigIntegerField(blank=True, null=True)), ('last_modified_date', models.DateField(blank=True, null=True)), ('awarding_toptier_agency_name', models.TextField(blank=True, null=True)), ('awarding_toptier_agency_abbreviation', models.TextField(blank=True, null=True)), ('awarding_subtier_agency_name', models.TextField(blank=True, null=True)), ('awarding_subtier_agency_abbreviation', models.TextField(blank=True, null=True)), ('funding_toptier_agency_name', models.TextField(blank=True, null=True)), ('funding_toptier_agency_abbreviation', models.TextField(blank=True, null=True)), ('funding_subtier_agency_name', models.TextField(blank=True, null=True)), ('funding_subtier_agency_abbreviation', models.TextField(blank=True, null=True)), ('cfda_number', models.TextField(blank=True, null=True)), ('cfda_title', models.TextField(blank=True, null=True)), ('sub_fiscal_year', models.IntegerField()), ('sub_total_obl_bin', models.TextField()), ('sub_awardee_or_recipient_legal', models.TextField(blank=True, null=True)), ('sub_ultimate_parent_legal_enti', models.TextField(blank=True, null=True)), ('business_type_code', models.TextField(blank=True, null=True)), ('business_categories', django.contrib.postgres.fields.ArrayField(base_field=models.TextField(), default=list, size=None, null=True)), ('treasury_account_identifiers', django.contrib.postgres.fields.ArrayField(base_field=models.IntegerField(), default=None, null=True, size=None)), ('pulled_from', models.TextField(blank=True, null=True)), ('type_of_contract_pricing', models.TextField(blank=True, null=True)), ('type_set_aside', models.TextField(blank=True, null=True)), ('extent_competed', models.TextField(blank=True, null=True)), ('product_or_service_code', models.TextField(blank=True, null=True)), ('product_or_service_description', models.TextField(blank=True, null=True)), ('sub_legal_entity_country_code', models.TextField(blank=True, null=True)), ('sub_legal_entity_country_name', models.TextField(blank=True, null=True)), ('sub_legal_entity_county_code', models.TextField(blank=True, null=True)), ('sub_legal_entity_county_name', models.TextField(blank=True, null=True)), ('sub_legal_entity_zip5', models.TextField(blank=True, null=True)), ('sub_legal_entity_city_code', models.TextField(blank=True, null=True)), ('sub_legal_entity_congressional', models.TextField(blank=True, null=True)), ('place_of_perform_scope', models.TextField(blank=True, null=True)), ('sub_place_of_perform_country_co', models.TextField(blank=True, null=True)), ('sub_place_of_perform_country_name', models.TextField(blank=True, null=True)), ('sub_place_of_perform_county_code', models.TextField(blank=True, null=True)), ('sub_place_of_perform_county_name', models.TextField(blank=True, null=True)), ('sub_place_of_perform_zip5', models.TextField(blank=True, null=True)), ('sub_place_of_perform_city_code', models.TextField(blank=True, null=True)), ('sub_place_of_perform_congressio', models.TextField(blank=True, null=True)), ('keyword_ts_vector', django.contrib.postgres.search.SearchVectorField(null=True)), ('award_ts_vector', django.contrib.postgres.search.SearchVectorField(null=True)), ('recipient_name_ts_vector', django.contrib.postgres.search.SearchVectorField(null=True)), ('award', models.BigIntegerField(null=True, db_column='award_id')), ('awarding_agency', models.IntegerField(null=True, db_column='awarding_agency_id')), ('cfda', models.IntegerField(null=True, db_column='cfda_id')), ('funding_agency', models.IntegerField(null=True, db_column='funding_agency_id'))], options={'db_table': 'subaward_search'}), migrations.RunSQL(sql='', reverse_sql='', state_operations=[migrations.AlterField(model_name='subawardsearch', name='award', field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='subawardsearch', to='awards.award'))]), migrations.RunSQL(sql='', reverse_sql='', state_operations=[migrations.AlterField(model_name='subawardsearch', name='awarding_agency', field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='awarding_subawardsearch', to='references.agency'))]), migrations.RunSQL(sql='', reverse_sql='', state_operations=[migrations.AlterField(model_name='subawardsearch', name='funding_agency', field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='funding_subawardsearch', to='references.agency'))]), migrations.RunSQL(sql='', reverse_sql='', state_operations=[migrations.AlterField(model_name='subawardsearch', name='cfda', field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='related_subawardsearch', to='references.cfda'))]), migrations.AddIndex(model_name='subawardsearch', index=models.Index(fields=['award_id'], name='ss_idx_award_id')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('prime_award_type__isnull', False)), fields=['prime_award_type'], name='ss_idx_prime_award_type')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('subaward_number'), descending=True, nulls_last=True), name='ss_idx_ordered_subaward_number')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('prime_award_type'), descending=True, nulls_last=True), name='ss_idx_order_prime_award_type')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.functions.text.Upper('fain'), descending=True, nulls_last=True), condition=models.Q(('fain__isnull', False)), name='ss_idx_ordered_fain')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.functions.text.Upper('piid'), descending=True, nulls_last=True), condition=models.Q(('piid__isnull', False)), name='ss_idx_ordered_piid')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('subaward_amount__isnull', False)), fields=['subaward_amount'], name='ss_idx_subaward_amount')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('subaward_amount'), descending=True, nulls_last=True), name='ss_idx_ordered_subaward_amount')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(fields=['sub_total_obl_bin'], name='ss_idx_sub_total_obl_bin')), migrations.AddIndex(model_name='subawardsearch', index=django.contrib.postgres.indexes.GinIndex(fields=['sub_awardee_or_recipient_legal'], name='ss_idx_gin_sub_recp_name', opclasses=['gin_trgm_ops'])), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_awardee_or_recipient_legal__isnull', False)), fields=['sub_awardee_or_recipient_legal'], name='ss_idx_sub_recp_name')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_awardee_or_recipient_uniqu__isnull', False)), fields=['sub_awardee_or_recipient_uniqu'], name='ss_idx_sub_duns')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_awardee_or_recipient_uei__isnull', False)), fields=['sub_awardee_or_recipient_uei'], name='ss_idx_sub_uei')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_ultimate_parent_unique_ide__isnull', False)), fields=['sub_ultimate_parent_unique_ide'], name='ss_idx_sub_parent_duns')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_ultimate_parent_uei__isnull', False)), fields=['sub_ultimate_parent_uei'], name='ss_idx_sub_parent_uei')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('sub_action_date'), descending=True, nulls_last=True), name='ss_idx_sub_action_date')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('last_modified_date'), descending=True, nulls_last=True), name='ss_idx_last_modified_date')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('sub_fiscal_year'), descending=True, nulls_last=True), name='ss_idx_sub_fiscal_year')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('awarding_agency_id'), nulls_last=True), condition=models.Q(('awarding_agency_id__isnull', False)), name='ss_idx_awarding_agency_id')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('funding_agency_id'), nulls_last=True), condition=models.Q(('funding_agency_id__isnull', False)), name='ss_idx_funding_agency_id')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('awarding_toptier_agency_name'), descending=True, nulls_last=True), name='ss_idx_order_awarding_top_name')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(django.db.models.expressions.OrderBy(django.db.models.expressions.F('awarding_subtier_agency_name'), descending=True, nulls_last=True), name='ss_idx_order_awarding_sub_name')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('awarding_toptier_agency_name__isnull', False)), fields=['awarding_toptier_agency_name'], name='ss_idx_awarding_top_agency_nam')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('awarding_subtier_agency_name__isnull', False)), fields=['awarding_subtier_agency_name'], name='ss_idx_awarding_sub_agency_nam')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('funding_toptier_agency_name__isnull', False)), fields=['funding_toptier_agency_name'], name='ss_idx_funding_top_agency_name')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('funding_subtier_agency_name__isnull', False)), fields=['funding_subtier_agency_name'], name='ss_idx_funding_sub_agency_name')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_legal_entity_country_code__isnull', False)), fields=['sub_legal_entity_country_code'], name='ss_idx_sub_le_country_code')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_legal_entity_state_code__isnull', False)), fields=['sub_legal_entity_state_code'], name='ss_idx_sub_le_state_code')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_legal_entity_county_code__isnull', False)), fields=['sub_legal_entity_county_code'], name='ss_idx_sub_le_county_code')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_legal_entity_zip5__isnull', False)), fields=['sub_legal_entity_zip5'], name='ss_idx_sub_le_zip5')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_legal_entity_congressional__isnull', False)), fields=['sub_legal_entity_congressional'], name='ss_idx_sub_le_congressional')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_legal_entity_city_name__isnull', False)), fields=['sub_legal_entity_city_name'], name='ss_idx_sub_le_city_name')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_place_of_perform_country_co__isnull', False)), fields=['sub_place_of_perform_country_co'], name='ss_idx_sub_ppop_country_co')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_place_of_perform_state_code__isnull', False)), fields=['sub_place_of_perform_state_code'], name='ss_idx_sub_ppop_state_code')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_place_of_perform_county_code__isnull', False)), fields=['sub_place_of_perform_county_code'], name='ss_idx_sub_ppop_county_code')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_place_of_perform_zip5__isnull', False)), fields=['sub_place_of_perform_zip5'], name='ss_idx_sub_ppop_zip5')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_place_of_perform_congressio__isnull', False)), fields=['sub_place_of_perform_congressio'], name='ss_idx_sub_ppop_congressio')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('sub_place_of_perform_city_name__isnull', False)), fields=['sub_place_of_perform_city_name'], name='ss_idx_sub_ppop_city_name')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('cfda_number__isnull', False)), fields=['cfda_number'], name='ss_idx_cfda_number')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('type_of_contract_pricing__isnull', False)), fields=['type_of_contract_pricing'], name='ss_idx_type_of_contract_pricin')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('extent_competed__isnull', False)), fields=['extent_competed'], name='ss_idx_extent_competed')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('type_set_aside__isnull', False)), fields=['type_set_aside'], name='ss_idx_type_set_aside')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(condition=models.Q(('product_or_service_code__isnull', False)), fields=['product_or_service_code'], name='ss_idx_product_service_code')), migrations.AddIndex(model_name='subawardsearch', index=django.contrib.postgres.indexes.GinIndex(fields=['product_or_service_description'], name='ss_idx_gin_product_service_des', opclasses=['gin_trgm_ops'])), migrations.AddIndex(model_name='subawardsearch', index=django.contrib.postgres.indexes.GinIndex(fields=['business_categories'], name='ss_idx_gin_business_categories')), migrations.AddIndex(model_name='subawardsearch', index=django.contrib.postgres.indexes.GinIndex(fields=['keyword_ts_vector'], name='ss_idx_gin_keyword_ts_vector')), migrations.AddIndex(model_name='subawardsearch', index=django.contrib.postgres.indexes.GinIndex(fields=['award_ts_vector'], name='ss_idx_gin_award_ts_vector')), migrations.AddIndex(model_name='subawardsearch', index=django.contrib.postgres.indexes.GinIndex(fields=['recipient_name_ts_vector'], name='ss_idx_gin_recip_name_ts_vecto')), migrations.AddIndex(model_name='subawardsearch', index=django.contrib.postgres.indexes.GinIndex(fields=['treasury_account_identifiers'], name='ss_idx_gin_treasury_account_id', opclasses=['gin__int_ops'])), migrations.AddIndex(model_name='subawardsearch', index=models.Index(fields=['product_or_service_code', 'sub_action_date'], name='ss_idx_comp_psc_sub_action_dat')), migrations.AddIndex(model_name='subawardsearch', index=models.Index(fields=['cfda_number', 'sub_action_date'], name='ss_idx_comp_cfda_sub_action_da'))] |
def extractAshtranslationsWordpressCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('Someone Explain This Situation!', 'Someone Explain This Situation!', 'translated'), ('Someone Please Explain This Situation!', 'Someone Explain This Situation!', 'translated'), ('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
class SaplingApi(ProviderInterface, TextInterface):
provider_name = 'sapling'
def __init__(self, api_keys: Optional[Dict]=None) -> None:
self.api_settings = load_provider(ProviderDataEnum.KEY, self.provider_name, api_keys=(api_keys or {}))
self.api_key = self.api_settings['key']
self.url = '
def _check_error(response: requests.Response) -> None:
if (response.status_code >= HTTPStatus.INTERNAL_SERVER_ERROR):
raise ProviderException('Internal server error', code=response.status_code)
try:
response_json = response.json()
except json.JSONDecodeError as exc:
raise ProviderException(response.text, code=response.status_code) from exc
if (response.status_code >= HTTPStatus.BAD_REQUEST):
raise ProviderException(response_json.get('msg', response.text), code=response.status_code)
def text__spell_check(self, text: str, language: str) -> ResponseType[SpellCheckDataClass]:
session_id = str(uuid.uuid4())
payload = {'key': self.api_key, 'text': text, 'session_id': session_id, 'multiple_edits': True}
if (language is not None):
payload['lang'] = language
response = requests.post(f'{self.url}spellcheck', json=payload)
SaplingApi._check_error(response)
original_response = response.json()
items: List[SpellCheckItem] = []
candidates = original_response.get('candidates', {})
edits = original_response.get('edits', [])
def extract_item(misspelled_word: Dict[(str, Any)]) -> SpellCheckItem:
(end, _, replacement, __, sentence_start, start) = misspelled_word.values()
offset = (start + sentence_start)
length = (end - start)
checked_word = text[offset:(offset + length)]
list_of_suggestions = candidates.get(checked_word, [replacement])
suggestions: List[SuggestionItem] = [SuggestionItem(suggestion=suggestion, score=None) for suggestion in list_of_suggestions]
return SpellCheckItem(text=checked_word, offset=offset, length=length, suggestions=suggestions, type=None)
for edit in edits:
extracted_item = extract_item(edit)
items.append(extracted_item)
return ResponseType[SpellCheckDataClass](original_response=original_response, standardized_response=SpellCheckDataClass(text=text, items=items))
def text__sentiment_analysis(self, language: str, text: str) -> ResponseType[SentimentAnalysisDataClass]:
headers = {'Content-Type': 'application/json'}
payload = {'key': self.api_key, 'text': text}
try:
response = requests.post(f'{self.url}sentiment', json=payload, headers=headers)
except Exception as excp:
raise ProviderException(str(excp), code=500)
if (response.status_code >= HTTPStatus.INTERNAL_SERVER_ERROR):
raise ProviderException('Internal server error', code=response.status_code)
response_json = response.json()
if (response.status_code >= HTTPStatus.BAD_REQUEST):
raise ProviderException(response_json, code=response.status_code)
best_sentiment = {'general_sentiment': None, 'general_sentiment_rate': 0, 'items': []}
for i in range(len((response_json.get('sents') or []))):
sentence = response_json['sents'][i]
sentiment = response_json['results'][i][0][1]
sentiment_rate = response_json['results'][i][0][0]
if (sentiment != 'Mixed'):
segment_sentiment = SegmentSentimentAnalysisDataClass(segment=sentence, sentiment=sentiment, sentiment_rate=sentiment_rate)
best_sentiment['items'].append(segment_sentiment)
overall = response_json.get('overall', [])
best_sentiment.update({'general_sentiment': (overall[0][1] if overall else None), 'general_sentiment_rate': (overall[0][0] if overall else 0)})
standarize = SentimentAnalysisDataClass(general_sentiment=best_sentiment['general_sentiment'], general_sentiment_rate=best_sentiment['general_sentiment_rate'], items=best_sentiment['items'])
return cast(ResponseType[SentimentAnalysisDataClass], ResponseType(original_response=response_json, standardized_response=standarize))
def text__ai_detection(self, text: str, provider_params: Optional[Dict[(str, Any)]]=None) -> ResponseType[ChatDataClass]:
payload = {'key': self.api_key, 'text': text}
try:
response = requests.post(f'{self.url}aidetect', json=payload)
except Exception as excp:
raise ProviderException(str(excp), code=500)
if (response.status_code >= HTTPStatus.INTERNAL_SERVER_ERROR):
raise ProviderException('Internal server error', code=response.status_code)
try:
original_response = response.json()
except json.JSONDecodeError as exc:
raise ProviderException(response.text, code=response.status_code) from exc
if (response.status_code >= HTTPStatus.BAD_REQUEST):
raise ProviderException(original_response, code=response.status_code)
items = []
for sentence_score in original_response.get('sentence_scores', {}):
ai_score = sentence_score['score']
items.append(AiDetectionItem(text=sentence_score['sentence'], prediction=AiDetectionItem.set_label_based_on_score(ai_score), ai_score=ai_score))
standardized_response = AiDetectionDataClass(ai_score=original_response.get('score'), items=items)
result = ResponseType[AiDetectionDataClass](original_response=original_response, standardized_response=standardized_response)
return result |
class MutualAuthenticationResponseAttributes(ModelComposed):
allowed_values = {}
validations = {}
_property
def additional_properties_type():
lazy_import()
return (bool, date, datetime, dict, float, int, list, str, none_type)
_nullable = False
_property
def openapi_types():
lazy_import()
return {'created_at': (datetime, none_type), 'deleted_at': (datetime, none_type), 'updated_at': (datetime, none_type), 'enforced': (bool,)}
_property
def discriminator():
return None
attribute_map = {'created_at': 'created_at', 'deleted_at': 'deleted_at', 'updated_at': 'updated_at', 'enforced': 'enforced'}
read_only_vars = {'created_at', 'deleted_at', 'updated_at'}
_js_args_to_python_args
def _from_openapi_data(cls, *args, **kwargs):
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
self = super(OpenApiModel, cls).__new__(cls)
if args:
raise ApiTypeError(('Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments.' % (args, self.__class__.__name__)), path_to_item=_path_to_item, valid_classes=(self.__class__,))
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = (_visited_composed_classes + (self.__class__,))
constant_args = {'_check_type': _check_type, '_path_to_item': _path_to_item, '_spec_property_naming': _spec_property_naming, '_configuration': _configuration, '_visited_composed_classes': self._visited_composed_classes}
composed_info = validate_get_composed_info(constant_args, kwargs, self)
self._composed_instances = composed_info[0]
self._var_name_to_model_instances = composed_info[1]
self._additional_properties_model_instances = composed_info[2]
discarded_args = composed_info[3]
for (var_name, var_value) in kwargs.items():
if ((var_name in discarded_args) and (self._configuration is not None) and self._configuration.discard_unknown_keys and self._additional_properties_model_instances):
continue
setattr(self, var_name, var_value)
return self
required_properties = set(['_data_store', '_check_type', '_spec_property_naming', '_path_to_item', '_configuration', '_visited_composed_classes', '_composed_instances', '_var_name_to_model_instances', '_additional_properties_model_instances'])
_js_args_to_python_args
def __init__(self, *args, **kwargs):
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
if args:
raise ApiTypeError(('Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments.' % (args, self.__class__.__name__)), path_to_item=_path_to_item, valid_classes=(self.__class__,))
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = (_visited_composed_classes + (self.__class__,))
constant_args = {'_check_type': _check_type, '_path_to_item': _path_to_item, '_spec_property_naming': _spec_property_naming, '_configuration': _configuration, '_visited_composed_classes': self._visited_composed_classes}
composed_info = validate_get_composed_info(constant_args, kwargs, self)
self._composed_instances = composed_info[0]
self._var_name_to_model_instances = composed_info[1]
self._additional_properties_model_instances = composed_info[2]
discarded_args = composed_info[3]
for (var_name, var_value) in kwargs.items():
if ((var_name in discarded_args) and (self._configuration is not None) and self._configuration.discard_unknown_keys and self._additional_properties_model_instances):
continue
setattr(self, var_name, var_value)
if (var_name in self.read_only_vars):
raise ApiAttributeError(f'`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate class with read only attributes.')
_property
def _composed_schemas():
lazy_import()
return {'anyOf': [], 'allOf': [MutualAuthenticationResponseAttributesAllOf, Timestamps], 'oneOf': []} |
def test_transform_interface_to_typed_interface_with_docstring():
def z(a: int, b: str) -> typing.Tuple[(int, str)]:
...
our_interface = transform_function_to_interface(z, Docstring(callable_=z))
typed_interface = transform_interface_to_typed_interface(our_interface)
assert (typed_interface.inputs.get('a').description == 'foo')
assert (typed_interface.inputs.get('b').description == 'bar')
assert (typed_interface.outputs.get('o1').description == 'ramen')
def z(a: int, b: str) -> typing.Tuple[(int, str)]:
...
our_interface = transform_function_to_interface(z, Docstring(callable_=z))
typed_interface = transform_interface_to_typed_interface(our_interface)
assert (typed_interface.inputs.get('a').description == 'foo')
assert (typed_interface.inputs.get('b').description == 'bar')
assert (typed_interface.outputs.get('o0').description == 'ramen')
assert (typed_interface.outputs.get('o1').description == 'ramen')
def z(a: int, b: str) -> typing.NamedTuple('NT', x_str=str, y_int=int):
...
our_interface = transform_function_to_interface(z, Docstring(callable_=z))
typed_interface = transform_interface_to_typed_interface(our_interface)
assert (typed_interface.inputs.get('a').description == 'foo')
assert (typed_interface.inputs.get('b').description == 'bar')
assert (typed_interface.outputs.get('x_str').description == 'description for x_str')
assert (typed_interface.outputs.get('y_int').description == 'description for y_int') |
def main():
N = 5
max_length = 10
hidden_size = 2
encodings = pos_encodings(max_length, hidden_size)
print(np.linalg.norm((encodings[2] - encodings[0])))
print(np.linalg.norm((encodings[3] - encodings[1])))
print(np.linalg.norm((encodings[4] - encodings[2])))
print(np.linalg.norm((encodings[5] - encodings[3])))
print(encodings.unsqueeze(0).expand(N, (- 1), (- 1)).shape) |
def quadrupole3d_44(ax, da, A, bx, db, B, R):
result = numpy.zeros((6, 15, 15), dtype=float)
x0 = (0.5 / (ax + bx))
x1 = ((ax + bx) ** (- 1.0))
x2 = ((- x1) * ((ax * A[0]) + (bx * B[0])))
x3 = ((- x2) - A[0])
x4 = ((- x2) - B[0])
x5 = ((ax * bx) * x1)
x6 = numpy.exp(((- x5) * ((A[0] - B[0]) ** 2)))
x7 = (1. * numpy.sqrt(x1))
x8 = (x6 * x7)
x9 = (x0 * x8)
x10 = ((- x2) - R[0])
x11 = (x4 * x8)
x12 = (x10 * x11)
x13 = (x12 + x9)
x14 = (x13 * x4)
x15 = (x3 * x6)
x16 = (x15 * x7)
x17 = (x0 * (x11 + x16))
x18 = (x16 * x4)
x19 = (x18 + x9)
x20 = (x19 * x4)
x21 = (x17 + x20)
x22 = (x10 * x8)
x23 = (x0 * (x11 + x22))
x24 = (3.0 * x23)
x25 = (x13 * x3)
x26 = (2.0 * x25)
x27 = (x24 + x26)
x28 = (x0 * ((x14 + x21) + x27))
x29 = (3.0 * x9)
x30 = (x10 * x16)
x31 = (x0 * (((x12 + x18) + x29) + x30))
x32 = (x23 + x25)
x33 = (x32 * x4)
x34 = (x31 + x33)
x35 = (x3 * x34)
x36 = (x28 + x35)
x37 = (x3 * x36)
x38 = (x36 * x4)
x39 = (x3 * x32)
x40 = (2.0 * x39)
x41 = (2.0 * x18)
x42 = ((x4 ** 2) * x8)
x43 = (x29 + x42)
x44 = (x0 * (x41 + x43))
x45 = (x21 * x3)
x46 = (x44 + x45)
x47 = (4.0 * x31)
x48 = ((2.0 * x33) + x47)
x49 = (x0 * ((x40 + x46) + x48))
x50 = (x21 * x4)
x51 = (3.0 * x45)
x52 = (x0 * (((5.0 * x44) + (2.0 * x50)) + x51))
x53 = (x19 * x3)
x54 = ((2.0 * x0) * (((2.0 * x17) + x20) + x53))
x55 = (x4 * x46)
x56 = (x54 + x55)
x57 = (x3 * x56)
x58 = (x52 + x57)
x59 = (x0 * ((((3.0 * x37) + (3.0 * x38)) + (6.0 * x49)) + x58))
x60 = (x34 * x4)
x61 = (2.0 * x60)
x62 = (3.0 * x35)
x63 = (x0 * ((((5.0 * x28) + x56) + x61) + x62))
x64 = (x38 + x49)
x65 = (x3 * x64)
x66 = (x63 + x65)
x67 = (x4 * x66)
x68 = (2.0 * x28)
x69 = (x10 * x32)
x70 = (x31 + x69)
x71 = (x3 * x70)
x72 = (x4 * x70)
x73 = (x10 * x13)
x74 = (x0 * (x16 + x22))
x75 = (x30 + x9)
x76 = (x10 * x75)
x77 = (x74 + x76)
x78 = (x0 * ((x27 + x73) + x77))
x79 = (x0 * (((((2.0 * x35) + x68) + (2.0 * x71)) + (2.0 * x72)) + (4.0 * x78)))
x80 = (2.0 * x69)
x81 = (2.0 * x12)
x82 = ((x10 ** 2) * x8)
x83 = (x29 + x82)
x84 = (x0 * (x81 + x83))
x85 = (x23 + x73)
x86 = (x4 * x85)
x87 = (x84 + x86)
x88 = (x0 * ((x48 + x80) + x87))
x89 = (x72 + x78)
x90 = (x3 * x89)
x91 = (x88 + x90)
x92 = (x4 * x91)
x93 = (x79 + x92)
x94 = (x4 * x93)
x95 = (x3 * x93)
x96 = (x4 * x89)
x97 = ((2.0 * x49) + (3.0 * x90))
x98 = (x0 * ((((2.0 * x38) + (5.0 * x88)) + (2.0 * x96)) + x97))
x99 = (x3 * x91)
x100 = (x0 * (((((2.0 * x63) + (2.0 * x65)) + (6.0 * x79)) + (3.0 * x92)) + (3.0 * x99)))
x101 = (x95 + x98)
x102 = (x100 + (x101 * x4))
x103 = numpy.exp(((- x5) * ((A[1] - B[1]) ** 2)))
x104 = (da * db)
x105 = (0. * x104)
x106 = numpy.exp(((- x5) * ((A[2] - B[2]) ** 2)))
x107 = ((3. * x1) * x106)
x108 = (x105 * x107)
x109 = (x103 * x108)
x110 = ((- x1) * ((ax * A[1]) + (bx * B[1])))
x111 = ((- x110) - B[1])
x112 = 2.
x113 = (x109 * x112)
x114 = (x113 * (x100 + (x101 * x3)))
x115 = ((- x1) * ((ax * A[2]) + (bx * B[2])))
x116 = ((- x115) - B[2])
x117 = (2.0 * x30)
x118 = (x0 * (x117 + x83))
x119 = (x3 * x77)
x120 = (x118 + x119)
x121 = (x0 * (((x120 + x40) + x47) + x80))
x122 = (x71 + x78)
x123 = (x122 * x3)
x124 = (x79 + x99)
x125 = ((x0 * (((((2.0 * x121) + (2.0 * x123)) + (2.0 * x37)) + (3.0 * x88)) + x97)) + (x124 * x3))
x126 = (x106 * x7)
x127 = 0.
x128 = (x103 * x7)
x129 = ((x111 ** 2) * x128)
x130 = (x0 * x128)
x131 = (x129 + x130)
x132 = (x104 * x131)
x133 = (x127 * x132)
x134 = 5.
x135 = (x109 * x134)
x136 = ((x116 ** 2) * x126)
x137 = (x0 * x126)
x138 = (x136 + x137)
x139 = (x104 * x138)
x140 = (x127 * x139)
x141 = (3.0 * x78)
x142 = (x3 * x75)
x143 = (((2.0 * x0) * ((x142 + (2.0 * x74)) + x76)) + (x120 * x3))
x144 = (x142 + x74)
x145 = (x17 + x53)
x146 = (x0 * (((x144 + x145) + (2.0 * x23)) + x26))
x147 = (x31 + x39)
x148 = (x147 * x3)
x149 = ((2.0 * x146) + (2.0 * x148))
x150 = (x121 + x123)
x151 = ((x0 * (((x141 + x143) + x149) + (3.0 * x71))) + (x150 * x3))
x152 = (2.0 * x130)
x153 = (x111 * (x131 + x152))
x154 = (x112 * x153)
x155 = (x105 * x126)
x156 = (x116 * x126)
x157 = (x131 * x134)
x158 = (x105 * x151)
x159 = (x111 * x128)
x160 = (x134 * x138)
x161 = (2.0 * x137)
x162 = (x116 * (x138 + x161))
x163 = (x112 * x162)
x164 = (x105 * x128)
x165 = (3.0 * x130)
x166 = ((x0 * ((3.0 * x129) + x165)) + (x111 * x153))
x167 = ((x3 ** 2) * x8)
x168 = (x167 + x29)
x169 = (x0 * (x117 + x168))
x170 = (x144 * x3)
x171 = ((x0 * ((((3.0 * x118) + (3.0 * x119)) + (2.0 * x169)) + (2.0 * x170))) + (x143 * x3))
x172 = (x105 * x171)
x173 = (3.0 * x137)
x174 = ((x0 * ((3.0 * x136) + x173)) + (x116 * x162))
x175 = ((- x110) - A[1])
x176 = (x102 * x113)
x177 = (x128 * x175)
x178 = (x111 * x177)
x179 = (x130 + x178)
x180 = (x104 * x179)
x181 = (0. * x180)
x182 = (0. * x104)
x183 = (x107 * x182)
x184 = (x116 * x183)
x185 = (x101 * x103)
x186 = (x0 * (x159 + x177))
x187 = (x111 * x179)
x188 = (x186 + x187)
x189 = 0.
x190 = (x104 * x189)
x191 = (x188 * x190)
x192 = 2.
x193 = (x181 * x192)
x194 = (x139 * x189)
x195 = (x165 + (2.0 * x178))
x196 = (x0 * (x129 + x195))
x197 = (x111 * x188)
x198 = (x196 + x197)
x199 = (x126 * x182)
x200 = (x150 * x192)
x201 = (x182 * x200)
x202 = (x162 * x182)
x203 = (3.0 * x186)
x204 = ((x0 * ((x153 + (3.0 * x187)) + x203)) + (x111 * x198))
x205 = (x112 * x143)
x206 = (0. * x143)
x207 = (x104 * x206)
x208 = (x143 * x189)
x209 = (x112 * x174)
x210 = (x105 * x143)
x211 = ((- x115) - A[2])
x212 = (x183 * x211)
x213 = (x126 * x211)
x214 = (x116 * x213)
x215 = (x137 + x214)
x216 = (x104 * x215)
x217 = (0. * x216)
x218 = (x132 * x189)
x219 = (x192 * x217)
x220 = (x0 * (x156 + x213))
x221 = (x116 * x215)
x222 = (x220 + x221)
x223 = (x190 * x222)
x224 = (x153 * x182)
x225 = (x173 + (2.0 * x214))
x226 = (x0 * (x136 + x225))
x227 = (x116 * x222)
x228 = (x226 + x227)
x229 = (x182 * x228)
x230 = (x112 * x166)
x231 = (3.0 * x220)
x232 = ((x0 * ((x162 + (3.0 * x221)) + x231)) + (x116 * x228))
x233 = (x94 + x98)
x234 = (x128 * (x175 ** 2))
x235 = (x130 + x234)
x236 = (x104 * x235)
x237 = (x127 * x236)
x238 = (x175 * x179)
x239 = (x186 + x238)
x240 = (x126 * x190)
x241 = (x189 * x236)
x242 = (x175 * x188)
x243 = (x196 + x242)
x244 = (0. * x104)
x245 = (x243 * x244)
x246 = 1.
x247 = (x239 * x246)
x248 = (x244 * x247)
x249 = (x138 * x244)
x250 = ((2.0 * x0) * (((2.0 * x186) + x187) + x238))
x251 = (x111 * x243)
x252 = (x250 + x251)
x253 = (x122 * x246)
x254 = (x162 * x189)
x255 = (3.0 * x242)
x256 = (x0 * (((5.0 * x196) + (2.0 * x197)) + x255))
x257 = (x111 * x252)
x258 = (x256 + x257)
x259 = (x104 * x120)
x260 = (x127 * x259)
x261 = (x189 * x259)
x262 = (x188 * x246)
x263 = (x244 * x262)
x264 = (0. * x180)
x265 = (x222 * x246)
x266 = (x244 * x265)
x267 = (x192 * x198)
x268 = (x182 * x267)
x269 = (0. * x216)
x270 = (x192 * x229)
x271 = (x105 * x120)
x272 = (x134 * x213)
x273 = (x120 * x192)
x274 = (x134 * x232)
x275 = (x126 * (x211 ** 2))
x276 = (x137 + x275)
x277 = (x104 * x276)
x278 = (x127 * x277)
x279 = (x189 * x277)
x280 = (x211 * x215)
x281 = (x220 + x280)
x282 = (x128 * x190)
x283 = (x131 * x244)
x284 = (x246 * x281)
x285 = (x244 * x284)
x286 = (x211 * x222)
x287 = (x226 + x286)
x288 = (x244 * x287)
x289 = (x153 * x189)
x290 = ((2.0 * x0) * (((2.0 * x220) + x221) + x280))
x291 = (x116 * x287)
x292 = (x290 + x291)
x293 = (x127 * x166)
x294 = (3.0 * x286)
x295 = (x0 * (((5.0 * x226) + (2.0 * x227)) + x294))
x296 = (x116 * x292)
x297 = (x295 + x296)
x298 = (((2.0 * x0) * ((x14 + (2.0 * x23)) + x73)) + (x4 * x87))
x299 = (x88 + x96)
x300 = ((x0 * ((((x141 + x298) + x61) + x68) + (3.0 * x72))) + (x299 * x4))
x301 = (x175 * (x152 + x235))
x302 = (x112 * x301)
x303 = (x0 * (x195 + x234))
x304 = (x175 * x239)
x305 = (x303 + x304)
x306 = (0. * x301)
x307 = (x104 * x306)
x308 = (x175 * x243)
x309 = (x250 + x308)
x310 = (x192 * x305)
x311 = (x182 * x310)
x312 = (x175 * x252)
x313 = (x256 + x312)
x314 = (x104 * x70)
x315 = (0. * x314)
x316 = (x192 * x315)
x317 = ((3.0 * x0) * (((2.0 * x250) + x251) + x308))
x318 = ((x111 * x313) + x317)
x319 = (x105 * x77)
x320 = (x112 * x319)
x321 = (x182 * x77)
x322 = (x105 * x300)
x323 = (x182 * x192)
x324 = (x299 * x323)
x325 = (x192 * x235)
x326 = (x245 * x246)
x327 = (0. * x314)
x328 = (x134 * x319)
x329 = (x192 * x77)
x330 = (x192 * x321)
x331 = (x134 * x276)
x332 = (x192 * x276)
x333 = (x244 * x276)
x334 = (x246 * x288)
x335 = (x211 * (x161 + x276))
x336 = (x112 * x335)
x337 = (x182 * x335)
x338 = (x0 * (x225 + x275))
x339 = (x211 * x281)
x340 = (x338 + x339)
x341 = (x182 * x340)
x342 = (x192 * x341)
x343 = (x211 * x287)
x344 = (x290 + x343)
x345 = (x190 * x344)
x346 = (0. * x335)
x347 = (x192 * x340)
x348 = (x211 * x292)
x349 = (x295 + x348)
x350 = ((3.0 * x0) * (((2.0 * x290) + x291) + x343))
x351 = ((x116 * x349) + x350)
x352 = ((x0 * (x165 + (3.0 * x234))) + (x175 * x301))
x353 = (x0 * (x43 + x81))
x354 = (x14 + x23)
x355 = (x354 * x4)
x356 = ((x0 * ((((2.0 * x353) + (2.0 * x355)) + (3.0 * x84)) + (3.0 * x86))) + (x298 * x4))
x357 = (x105 * x356)
x358 = ((x0 * ((x203 + (3.0 * x238)) + x301)) + (x175 * x305))
x359 = (x112 * x298)
x360 = (x112 * x352)
x361 = (x105 * x156)
x362 = (x126 * x127)
x363 = ((x0 * ((((3.0 * x196) + x255) + (2.0 * x303)) + (2.0 * x304))) + (x175 * x309))
x364 = (x104 * x363)
x365 = (x134 * x358)
x366 = ((x175 * x313) + x317)
x367 = (x105 * x85)
x368 = (x112 * x367)
x369 = (x134 * x367)
x370 = ((x0 * (((7.0 * x256) + (3.0 * x257)) + (4.0 * x312))) + (x175 * x318))
x371 = (x82 + x9)
x372 = (x105 * x371)
x373 = (x112 * x372)
x374 = (x182 * x213)
x375 = (x190 * x309)
x376 = (x192 * x85)
x377 = (0. * x371)
x378 = (x182 * x371)
x379 = (x189 * x298)
x380 = (x244 * x87)
x381 = (x189 * x85)
x382 = (x127 * x371)
x383 = (x190 * x371)
x384 = (x190 * x335)
x385 = (x177 * x182)
x386 = ((x0 * (x173 + (3.0 * x275))) + (x211 * x335))
x387 = (x112 * x386)
x388 = (x105 * x159)
x389 = ((x0 * ((x231 + (3.0 * x280)) + x335)) + (x211 * x340))
x390 = (x127 * x386)
x391 = (x134 * x389)
x392 = (x104 * x128)
x393 = ((x0 * ((((3.0 * x226) + x294) + (2.0 * x338)) + (2.0 * x339))) + (x211 * x344))
x394 = (x127 * x393)
x395 = ((x211 * x349) + x350)
x396 = ((x0 * (((7.0 * x295) + (3.0 * x296)) + (4.0 * x348))) + (x211 * x351))
x397 = ((- x110) - R[1])
x398 = (x4 * x64)
x399 = (x3 * x46)
x400 = ((3.0 * x0) * ((x399 + (2.0 * x54)) + x55))
x401 = ((x4 * x58) + x400)
x402 = (x59 + x67)
x403 = (x109 * ((x0 * ((((3.0 * x398) + x401) + (7.0 * x63)) + (4.0 * x65))) + (x3 * x402)))
x404 = ((x3 * x66) + x59)
x405 = (x159 * x397)
x406 = (x130 + x405)
x407 = (x105 * x406)
x408 = (x112 * x126)
x409 = (x113 * x397)
x410 = (x399 + x54)
x411 = (x37 + x49)
x412 = ((x0 * (((x149 + (3.0 * x28)) + x410) + x62)) + (x3 * x411))
x413 = (x128 * x397)
x414 = (x0 * (x159 + x413))
x415 = (x111 * x406)
x416 = (x414 + x415)
x417 = (x104 * x416)
x418 = (x134 * x407)
x419 = (x165 + (2.0 * x405))
x420 = (x0 * (x129 + x419))
x421 = (x111 * x416)
x422 = (x420 + x421)
x423 = (3.0 * x31)
x424 = (x169 + x170)
x425 = (x0 * (x168 + x41))
x426 = (x145 * x3)
x427 = (x425 + x426)
x428 = (x146 + x148)
x429 = ((x0 * ((((3.0 * x39) + x423) + x424) + x427)) + (x3 * x428))
x430 = (x112 * x155)
x431 = (x134 * x361)
x432 = (x105 * x413)
x433 = (x167 + x9)
x434 = (2.0 * x0)
x435 = ((x16 * x434) + (x3 * x433))
x436 = ((x0 * (((3.0 * x142) + x435) + (3.0 * x74))) + (x3 * x424))
x437 = (3.0 * x414)
x438 = ((x0 * ((x153 + (3.0 * x415)) + x437)) + (x111 * x422))
x439 = (x112 * x361)
x440 = (x105 * x174)
x441 = (x177 * x397)
x442 = (x130 + x441)
x443 = (x105 * x442)
x444 = (x175 * x406)
x445 = (x414 + x444)
x446 = (x182 * x445)
x447 = (x182 * x442)
x448 = (x0 * (((x165 + x178) + x405) + x441))
x449 = (x111 * x445)
x450 = (x448 + x449)
x451 = (x192 * x446)
x452 = (2.0 * x444)
x453 = (x437 + x452)
x454 = (x0 * ((x188 + x415) + x453))
x455 = (x111 * x450)
x456 = (x454 + x455)
x457 = (x192 * x428)
x458 = (x182 * x457)
x459 = (3.0 * x448)
x460 = ((x0 * (((x198 + x422) + (3.0 * x449)) + x459)) + (x111 * x456))
x461 = (x182 * x424)
x462 = (x182 * x406)
x463 = (x190 * x416)
x464 = (x112 * x424)
x465 = (x105 * x213)
x466 = (x398 + x63)
x467 = (x0 * (x177 + x413))
x468 = (x175 * x442)
x469 = (x467 + x468)
x470 = (x127 * x469)
x471 = (x104 * x126)
x472 = (x175 * x445)
x473 = (x448 + x472)
x474 = (x190 * x469)
x475 = (x175 * x450)
x476 = (x454 + x475)
x477 = (x244 * x36)
x478 = (x246 * x473)
x479 = (2.0 * x472)
x480 = (4.0 * x448)
x481 = ((2.0 * x449) + x480)
x482 = (x0 * ((x243 + x479) + x481))
x483 = (x111 * x476)
x484 = (x482 + x483)
x485 = (x147 * x246)
x486 = (x244 * x476)
x487 = (x104 * x254)
x488 = (2.0 * x455)
x489 = (3.0 * x475)
x490 = (x0 * (((x252 + (5.0 * x454)) + x488) + x489))
x491 = (x111 * x484)
x492 = (x490 + x491)
x493 = (x127 * x144)
x494 = (x144 * x190)
x495 = (x104 * x174)
x496 = (x134 * x443)
x497 = (x246 * x450)
x498 = (x213 * x323)
x499 = (0. * x104)
x500 = (x222 * x499)
x501 = (x105 * x272)
x502 = (x190 * x413)
x503 = (x244 * x416)
x504 = (x104 * x297)
x505 = (x165 + (2.0 * x441))
x506 = (x0 * (x234 + x505))
x507 = (x175 * x469)
x508 = (x506 + x507)
x509 = (x353 + x355)
x510 = (x44 + x50)
x511 = (x28 + x60)
x512 = ((x0 * ((((3.0 * x33) + x423) + x509) + x510)) + (x4 * x511))
x513 = (x0 * (((x239 + (2.0 * x414)) + x452) + x469))
x514 = (x175 * x473)
x515 = (x513 + x514)
x516 = (x182 * x508)
x517 = (x175 * x476)
x518 = (x482 + x517)
x519 = (x192 * x515)
x520 = (x175 * x484)
x521 = (x490 + x520)
x522 = (x182 * x32)
x523 = (x192 * x522)
x524 = (x0 * (((x313 + (6.0 * x482)) + (3.0 * x483)) + (3.0 * x517)))
x525 = (x111 * x521)
x526 = (x524 + x525)
x527 = (x105 * x75)
x528 = (x182 * x75)
x529 = (x246 * x34)
x530 = (x134 * x527)
x531 = (x192 * x528)
x532 = (x192 * x447)
x533 = (x281 * x499)
x534 = (x32 * x499)
x535 = (x192 * x32)
x536 = (x112 * x351)
x537 = ((x0 * ((x301 + (3.0 * x467)) + (3.0 * x468))) + (x175 * x508))
x538 = (x42 + x9)
x539 = ((x11 * x434) + (x4 * x538))
x540 = ((x0 * (((3.0 * x14) + x24) + x539)) + (x4 * x509))
x541 = ((x0 * (((x305 + x459) + (3.0 * x472)) + x508)) + (x175 * x515))
x542 = ((2.0 * x513) + (2.0 * x514))
x543 = ((x0 * (((x309 + (3.0 * x454)) + x489) + x542)) + (x175 * x518))
x544 = (x104 * x354)
x545 = ((x175 * x521) + x524)
x546 = (x105 * x13)
x547 = (x134 * x546)
x548 = (x108 * x6)
x549 = (x548 * ((x0 * (((x318 + (7.0 * x490)) + (3.0 * x491)) + (4.0 * x520))) + (x175 * x526)))
x550 = (x10 * x548)
x551 = (x112 * x116)
x552 = (x105 * x22)
x553 = (x112 * x508)
x554 = (x190 * x354)
x555 = (x13 * x182)
x556 = (x112 * x526)
x557 = (x244 * x354)
x558 = (x190 * x22)
x559 = (x192 * x555)
x560 = (x105 * x386)
x561 = (x112 * x389)
x562 = (x112 * x395)
x563 = ((3. * x1) * x103)
x564 = (x105 * x563)
x565 = (x564 * x6)
x566 = (x10 * x565)
x567 = ((- x115) - R[2])
x568 = (x113 * x567)
x569 = (x156 * x567)
x570 = (x137 + x569)
x571 = (x105 * x570)
x572 = (x112 * x128)
x573 = (x126 * x567)
x574 = (x134 * x571)
x575 = (x0 * (x156 + x573))
x576 = (x116 * x570)
x577 = (x575 + x576)
x578 = (x127 * x577)
x579 = (x105 * x573)
x580 = (x134 * x388)
x581 = (x173 + (2.0 * x569))
x582 = (x0 * (x136 + x581))
x583 = (x116 * x577)
x584 = (x582 + x583)
x585 = (x112 * x164)
x586 = (x112 * x584)
x587 = (3.0 * x575)
x588 = ((x0 * ((x162 + (3.0 * x576)) + x587)) + (x116 * x584))
x589 = (x182 * x570)
x590 = (x190 * x577)
x591 = (x182 * x573)
x592 = (x105 * x177)
x593 = (x213 * x567)
x594 = (x137 + x593)
x595 = (x105 * x594)
x596 = (x182 * x594)
x597 = (x211 * x570)
x598 = (x575 + x597)
x599 = (x182 * x598)
x600 = (x192 * x599)
x601 = (x0 * (((x173 + x214) + x569) + x593))
x602 = (x116 * x598)
x603 = (x601 + x602)
x604 = (2.0 * x597)
x605 = (x587 + x604)
x606 = (x0 * ((x222 + x576) + x605))
x607 = (x116 * x603)
x608 = (x606 + x607)
x609 = (x128 * x182)
x610 = (3.0 * x601)
x611 = ((x0 * (((x228 + x584) + (3.0 * x602)) + x610)) + (x116 * x608))
x612 = (x190 * x573)
x613 = (x244 * x577)
x614 = (x104 * x573)
x615 = (x134 * x595)
x616 = (x246 * x477)
x617 = (x499 * x598)
x618 = (x177 * x323)
x619 = (x244 * x603)
x620 = (x134 * x592)
x621 = (x0 * (x213 + x573))
x622 = (x211 * x594)
x623 = (x621 + x622)
x624 = (x104 * x623)
x625 = (x127 * x128)
x626 = (x190 * x623)
x627 = (x211 * x598)
x628 = (x601 + x627)
x629 = (x211 * x603)
x630 = (x606 + x629)
x631 = (x244 * x630)
x632 = (2.0 * x627)
x633 = (4.0 * x601)
x634 = ((2.0 * x602) + x633)
x635 = (x0 * ((x287 + x632) + x634))
x636 = (x116 * x630)
x637 = (x635 + x636)
x638 = (x104 * x289)
x639 = (2.0 * x607)
x640 = (3.0 * x629)
x641 = (x0 * (((x292 + (5.0 * x606)) + x639) + x640))
x642 = (x116 * x637)
x643 = (x641 + x642)
x644 = (x112 * x573)
x645 = (x192 * x596)
x646 = (x173 + (2.0 * x593))
x647 = (x0 * (x275 + x646))
x648 = (x211 * x623)
x649 = (x647 + x648)
x650 = (x182 * x649)
x651 = (x0 * (((x281 + (2.0 * x575)) + x604) + x623))
x652 = (x211 * x628)
x653 = (x651 + x652)
x654 = (x323 * x653)
x655 = (x211 * x630)
x656 = (x635 + x655)
x657 = (x211 * x637)
x658 = (x641 + x657)
x659 = (x0 * (((x349 + (6.0 * x635)) + (3.0 * x636)) + (3.0 * x655)))
x660 = (x116 * x658)
x661 = (x659 + x660)
x662 = (x112 * x509)
x663 = (x112 * x22)
x664 = (x182 * x22)
x665 = (x127 * x624)
x666 = (x112 * x649)
x667 = (x112 * x661)
x668 = ((x0 * ((x335 + (3.0 * x621)) + (3.0 * x622))) + (x211 * x649))
x669 = ((x0 * (((x340 + x610) + (3.0 * x627)) + x649)) + (x211 * x653))
x670 = (x127 * x668)
x671 = ((2.0 * x651) + (2.0 * x652))
x672 = ((x0 * (((x344 + (3.0 * x606)) + x640) + x671)) + (x211 * x656))
x673 = ((x211 * x658) + x659)
x674 = (x111 * x112)
x675 = (x565 * ((x0 * (((x351 + (7.0 * x641)) + (3.0 * x642)) + (4.0 * x657))) + (x211 * x661)))
x676 = (x4 * x56)
x677 = ((x0 * (((7.0 * x52) + (4.0 * x57)) + (3.0 * x676))) + (x3 * x401))
x678 = (x128 * (x397 ** 2))
x679 = (x130 + x678)
x680 = (x105 * x679)
x681 = ((x3 * x58) + x400)
x682 = (x397 * x406)
x683 = (x414 + x682)
x684 = (x105 * x683)
x685 = (x112 * x680)
x686 = (x0 * (x419 + x678))
x687 = (x111 * x683)
x688 = (x686 + x687)
x689 = ((x0 * ((((2.0 * x425) + (2.0 * x426)) + (3.0 * x44)) + x51)) + (x3 * x410))
x690 = (x104 * x362)
x691 = (x134 * x684)
x692 = (((2.0 * x0) * (((2.0 * x414) + x415) + x682)) + (x111 * x688))
x693 = (3.0 * x17)
x694 = ((x0 * ((x435 + (3.0 * x53)) + x693)) + (x3 * x427))
x695 = ((x0 * ((3.0 * x167) + x29)) + (x3 * x435))
x696 = ((x0 * ((((2.0 * x420) + (2.0 * x421)) + (3.0 * x686)) + (3.0 * x687))) + (x111 * x692))
x697 = (x112 * x695)
x698 = (x397 * x442)
x699 = (x467 + x698)
x700 = (x105 * x699)
x701 = (x397 * x445)
x702 = (x448 + x701)
x703 = (x182 * x702)
x704 = (x182 * x699)
x705 = (x0 * ((x453 + x682) + x699))
x706 = (x111 * x702)
x707 = (x705 + x706)
x708 = (x192 * x703)
x709 = (2.0 * x701)
x710 = (x0 * ((x481 + x688) + x709))
x711 = (x111 * x707)
x712 = (x710 + x711)
x713 = (x323 * x427)
x714 = (x138 * x192)
x715 = (2.0 * x454)
x716 = (3.0 * x705)
x717 = ((x0 * ((((x488 + x692) + (3.0 * x706)) + x715) + x716)) + (x111 * x712))
x718 = (x112 * x435)
x719 = (x182 * x435)
x720 = (x190 * x410)
x721 = (x0 * (x505 + x678))
x722 = (x175 * x699)
x723 = (x721 + x722)
x724 = (x52 + x676)
x725 = (x175 * x702)
x726 = (x705 + x725)
x727 = (x190 * x723)
x728 = (x175 * x707)
x729 = (x710 + x728)
x730 = (x244 * x46)
x731 = (x246 * x730)
x732 = (x0 * (((((2.0 * x475) + (4.0 * x705)) + (2.0 * x706)) + x715) + (2.0 * x725)))
x733 = (x111 * x729)
x734 = (x732 + x733)
x735 = (x145 * x246)
x736 = (x244 * x735)
x737 = ((2.0 * x482) + (3.0 * x728))
x738 = (x0 * ((((2.0 * x483) + (5.0 * x710)) + (2.0 * x711)) + x737))
x739 = (x111 * x734)
x740 = (x738 + x739)
x741 = (x127 * x433)
x742 = (x104 * x741)
x743 = (x190 * x433)
x744 = (x190 * x679)
x745 = (x104 * x679)
x746 = (((2.0 * x0) * (((2.0 * x467) + x468) + x698)) + (x175 * x723))
x747 = ((x0 * (((3.0 * x20) + x539) + x693)) + (x4 * x510))
x748 = (x0 * (((x479 + x480) + x709) + x723))
x749 = (x175 * x726)
x750 = (x748 + x749)
x751 = (x182 * x510)
x752 = (x175 * x729)
x753 = (x732 + x752)
x754 = (x190 * x21)
x755 = (x323 * x750)
x756 = (x175 * x734)
x757 = (x738 + x756)
x758 = (x182 * x19)
x759 = (x192 * x758)
x760 = (x0 * (((((2.0 * x490) + (2.0 * x520)) + (6.0 * x732)) + (3.0 * x733)) + (3.0 * x752)))
x761 = ((x111 * x757) + x760)
x762 = (x112 * x761)
x763 = (x108 * x15)
x764 = (x105 * x16)
x765 = (x323 * x510)
x766 = (x21 * x246)
x767 = (x244 * x766)
x768 = (x19 * x499)
x769 = (x16 * x323)
x770 = (x16 * x182)
x771 = ((x0 * (x29 + (3.0 * x42))) + (x4 * x539))
x772 = ((x0 * ((((2.0 * x506) + (2.0 * x507)) + (3.0 * x721)) + (3.0 * x722))) + (x175 * x746))
x773 = ((x0 * (((x542 + x716) + (3.0 * x725)) + x746)) + (x175 * x750))
x774 = (x112 * x539)
x775 = ((x0 * (((((2.0 * x517) + (3.0 * x710)) + x737) + (2.0 * x748)) + (2.0 * x749))) + (x175 * x753))
x776 = (x104 * x538)
x777 = (x127 * x776)
x778 = (x112 * x4)
x779 = (x548 * ((x175 * x757) + x760))
x780 = (x134 * x4)
x781 = (x105 * x11)
x782 = (x105 * x8)
x783 = (x112 * x771)
x784 = (x182 * x539)
x785 = (x190 * x538)
x786 = (x4 * x6)
x787 = (x112 * x782)
x788 = (x190 * x539)
x789 = (x244 * x538)
x790 = (x190 * x8)
x791 = (x104 * x8)
x792 = (x112 * x8)
x793 = (x127 * x538)
x794 = (x112 * x413)
x795 = (x127 * x689)
x796 = (x112 * x422)
x797 = (x192 * x462)
x798 = (x445 * x499)
x799 = (x134 * x764)
x800 = (x15 * x564)
x801 = (x134 * x781)
x802 = (x11 * x182)
x803 = (x182 * x8)
x804 = (x127 * x8)
x805 = (x126 * (x567 ** 2))
x806 = (x137 + x805)
x807 = (x105 * x806)
x808 = (x112 * x807)
x809 = (x567 * x570)
x810 = (x575 + x809)
x811 = (x105 * x810)
x812 = (x134 * x811)
x813 = (x0 * (x581 + x805))
x814 = (x116 * x810)
x815 = (x813 + x814)
x816 = (((2.0 * x0) * (((2.0 * x575) + x576) + x809)) + (x116 * x815))
x817 = ((x0 * ((((2.0 * x582) + (2.0 * x583)) + (3.0 * x813)) + (3.0 * x814))) + (x116 * x816))
x818 = (x182 * x806)
x819 = (x567 * x594)
x820 = (x621 + x819)
x821 = (x105 * x820)
x822 = (x182 * x820)
x823 = (x567 * x598)
x824 = (x601 + x823)
x825 = (x159 * x323)
x826 = (x0 * ((x605 + x809) + x820))
x827 = (x116 * x824)
x828 = (x826 + x827)
x829 = (2.0 * x823)
x830 = (x0 * ((x634 + x815) + x829))
x831 = (x116 * x828)
x832 = (x830 + x831)
x833 = (2.0 * x606)
x834 = (3.0 * x826)
x835 = ((x0 * ((((x639 + x816) + (3.0 * x827)) + x833) + x834)) + (x116 * x832))
x836 = (x190 * x806)
x837 = (x134 * x821)
x838 = (x499 * x824)
x839 = (x0 * (x646 + x805))
x840 = (x211 * x820)
x841 = (x839 + x840)
x842 = (x104 * x841)
x843 = (x190 * x841)
x844 = (x211 * x824)
x845 = (x826 + x844)
x846 = (x211 * x828)
x847 = (x830 + x846)
x848 = (x0 * (((((2.0 * x629) + (4.0 * x826)) + (2.0 * x827)) + x833) + (2.0 * x844)))
x849 = (x116 * x847)
x850 = (x848 + x849)
x851 = ((2.0 * x635) + (3.0 * x846))
x852 = (x0 * ((((2.0 * x636) + (5.0 * x830)) + (2.0 * x831)) + x851))
x853 = (x116 * x850)
x854 = (x852 + x853)
x855 = (((2.0 * x0) * (((2.0 * x621) + x622) + x819)) + (x211 * x841))
x856 = (x0 * (((x632 + x633) + x829) + x841))
x857 = (x211 * x845)
x858 = (x856 + x857)
x859 = (x211 * x847)
x860 = (x848 + x859)
x861 = (x211 * x850)
x862 = (x852 + x861)
x863 = ((x182 * x563) * x862)
x864 = (x0 * (((((2.0 * x641) + (2.0 * x657)) + (6.0 * x848)) + (3.0 * x849)) + (3.0 * x859)))
x865 = ((x116 * x862) + x864)
x866 = (x112 * x865)
x867 = (x11 * x323)
x868 = ((x0 * ((((2.0 * x647) + (2.0 * x648)) + (3.0 * x839)) + (3.0 * x840))) + (x211 * x855))
x869 = ((x0 * (((x671 + x834) + (3.0 * x844)) + x855)) + (x211 * x858))
x870 = ((x0 * (((((2.0 * x655) + (3.0 * x830)) + x851) + (2.0 * x856)) + (2.0 * x857))) + (x211 * x860))
x871 = (x565 * ((x211 * x862) + x864))
result[(0, 0, 0)] = numpy.sum((x109 * ((x0 * (((((2.0 * x59) + (2.0 * x67)) + (3.0 * x94)) + (4.0 * x95)) + (7.0 * x98))) + (x102 * x3))))
result[(0, 0, 1)] = numpy.sum((x111 * x114))
result[(0, 0, 2)] = numpy.sum((x114 * x116))
result[(0, 0, 3)] = numpy.sum(((x125 * x126) * x133))
result[(0, 0, 4)] = numpy.sum((((x111 * x116) * x125) * x135))
result[(0, 0, 5)] = numpy.sum(((x125 * x128) * x140))
result[(0, 0, 6)] = numpy.sum(((x151 * x154) * x155))
result[(0, 0, 7)] = numpy.sum(((x156 * x157) * x158))
result[(0, 0, 8)] = numpy.sum(((x158 * x159) * x160))
result[(0, 0, 9)] = numpy.sum(((x151 * x163) * x164))
result[(0, 0, 10)] = numpy.sum(((x126 * x166) * x172))
result[(0, 0, 11)] = numpy.sum(((x154 * x156) * x172))
result[(0, 0, 12)] = numpy.sum(((x131 * x140) * x171))
result[(0, 0, 13)] = numpy.sum(((x159 * x163) * x172))
result[(0, 0, 14)] = numpy.sum(((x128 * x172) * x174))
result[(0, 1, 0)] = numpy.sum((x175 * x176))
result[(0, 1, 1)] = numpy.sum(((x101 * x126) * x181))
result[(0, 1, 2)] = numpy.sum(((x175 * x184) * x185))
result[(0, 1, 3)] = numpy.sum(((x124 * x126) * x191))
result[(0, 1, 4)] = numpy.sum(((x124 * x156) * x193))
result[(0, 1, 5)] = numpy.sum(((x124 * x177) * x194))
result[(0, 1, 6)] = numpy.sum(((x150 * x198) * x199))
result[(0, 1, 7)] = numpy.sum(((x156 * x188) * x201))
result[(0, 1, 8)] = numpy.sum(((x138 * x181) * x200))
result[(0, 1, 9)] = numpy.sum(((x150 * x177) * x202))
result[(0, 1, 10)] = numpy.sum(((x155 * x204) * x205))
result[(0, 1, 11)] = numpy.sum(((x156 * x198) * x207))
result[(0, 1, 12)] = numpy.sum(((x139 * x188) * x208))
result[(0, 1, 13)] = numpy.sum(((x162 * x180) * x206))
result[(0, 1, 14)] = numpy.sum(((x177 * x209) * x210))
result[(0, 2, 0)] = numpy.sum((x176 * x211))
result[(0, 2, 1)] = numpy.sum(((x111 * x185) * x212))
result[(0, 2, 2)] = numpy.sum(((x101 * x128) * x217))
result[(0, 2, 3)] = numpy.sum(((x124 * x213) * x218))
result[(0, 2, 4)] = numpy.sum(((x124 * x159) * x219))
result[(0, 2, 5)] = numpy.sum(((x124 * x128) * x223))
result[(0, 2, 6)] = numpy.sum(((x150 * x213) * x224))
result[(0, 2, 7)] = numpy.sum(((x131 * x200) * x217))
result[(0, 2, 8)] = numpy.sum(((x159 * x201) * x222))
result[(0, 2, 9)] = numpy.sum(((x128 * x150) * x229))
result[(0, 2, 10)] = numpy.sum(((x210 * x213) * x230))
result[(0, 2, 11)] = numpy.sum(((x153 * x206) * x216))
result[(0, 2, 12)] = numpy.sum(((x132 * x208) * x222))
result[(0, 2, 13)] = numpy.sum(((x159 * x207) * x228))
result[(0, 2, 14)] = numpy.sum(((x164 * x205) * x232))
result[(0, 3, 0)] = numpy.sum(((x126 * x233) * x237))
result[(0, 3, 1)] = numpy.sum(((x239 * x240) * x93))
result[(0, 3, 2)] = numpy.sum(((x156 * x241) * x93))
result[(0, 3, 3)] = numpy.sum(((x126 * x245) * x91))
result[(0, 3, 4)] = numpy.sum(((x156 * x248) * x91))
result[(0, 3, 5)] = numpy.sum(((x235 * x249) * x91))
result[(0, 3, 6)] = numpy.sum(((x122 * x240) * x252))
result[(0, 3, 7)] = numpy.sum(((x156 * x245) * x253))
result[(0, 3, 8)] = numpy.sum(((x239 * x249) * x253))
result[(0, 3, 9)] = numpy.sum(((x122 * x236) * x254))
result[(0, 3, 10)] = numpy.sum(((x126 * x258) * x260))
result[(0, 3, 11)] = numpy.sum(((x156 * x252) * x261))
result[(0, 3, 12)] = numpy.sum(((x120 * x243) * x249))
result[(0, 3, 13)] = numpy.sum(((x239 * x254) * x259))
result[(0, 3, 14)] = numpy.sum(((x120 * x174) * x237))
result[(0, 4, 0)] = numpy.sum((((x135 * x175) * x211) * x233))
result[(0, 4, 1)] = numpy.sum(((x193 * x213) * x93))
result[(0, 4, 2)] = numpy.sum(((x177 * x219) * x93))
result[(0, 4, 3)] = numpy.sum(((x213 * x263) * x91))
result[(0, 4, 4)] = numpy.sum(((x215 * x264) * x91))
result[(0, 4, 5)] = numpy.sum(((x177 * x266) * x91))
result[(0, 4, 6)] = numpy.sum(((x122 * x213) * x268))
result[(0, 4, 7)] = numpy.sum(((x122 * x188) * x269))
result[(0, 4, 8)] = numpy.sum(((x122 * x222) * x264))
result[(0, 4, 9)] = numpy.sum(((x122 * x177) * x270))
result[(0, 4, 10)] = numpy.sum(((x204 * x271) * x272))
result[(0, 4, 11)] = numpy.sum(((x198 * x217) * x273))
result[(0, 4, 12)] = numpy.sum(((x120 * x188) * x266))
result[(0, 4, 13)] = numpy.sum(((x181 * x228) * x273))
result[(0, 4, 14)] = numpy.sum(((x177 * x271) * x274))
result[(0, 5, 0)] = numpy.sum(((x128 * x233) * x278))
result[(0, 5, 1)] = numpy.sum(((x159 * x279) * x93))
result[(0, 5, 2)] = numpy.sum(((x281 * x282) * x93))
result[(0, 5, 3)] = numpy.sum(((x276 * x283) * x91))
result[(0, 5, 4)] = numpy.sum(((x159 * x285) * x91))
result[(0, 5, 5)] = numpy.sum(((x128 * x288) * x91))
result[(0, 5, 6)] = numpy.sum(((x122 * x277) * x289))
result[(0, 5, 7)] = numpy.sum(((x253 * x281) * x283))
result[(0, 5, 8)] = numpy.sum(((x159 * x253) * x288))
result[(0, 5, 9)] = numpy.sum(((x122 * x282) * x292))
result[(0, 5, 10)] = numpy.sum(((x259 * x276) * x293))
result[(0, 5, 11)] = numpy.sum(((x259 * x281) * x289))
result[(0, 5, 12)] = numpy.sum(((x120 * x283) * x287))
result[(0, 5, 13)] = numpy.sum(((x159 * x261) * x292))
result[(0, 5, 14)] = numpy.sum(((x128 * x260) * x297))
result[(0, 6, 0)] = numpy.sum(((x155 * x300) * x302))
result[(0, 6, 1)] = numpy.sum(((x199 * x299) * x305))
result[(0, 6, 2)] = numpy.sum(((x156 * x299) * x307))
result[(0, 6, 3)] = numpy.sum(((x240 * x309) * x89))
result[(0, 6, 4)] = numpy.sum(((x156 * x311) * x89))
result[(0, 6, 5)] = numpy.sum(((x194 * x301) * x89))
result[(0, 6, 6)] = numpy.sum(((x126 * x313) * x315))
result[(0, 6, 7)] = numpy.sum(((x156 * x309) * x316))
result[(0, 6, 8)] = numpy.sum(((x138 * x310) * x315))
result[(0, 6, 9)] = numpy.sum(((x162 * x306) * x314))
result[(0, 6, 10)] = numpy.sum(((x126 * x318) * x320))
result[(0, 6, 11)] = numpy.sum(((x156 * x313) * x321))
result[(0, 6, 12)] = numpy.sum(((x194 * x309) * x77))
result[(0, 6, 13)] = numpy.sum(((x162 * x305) * x321))
result[(0, 6, 14)] = numpy.sum(((x174 * x302) * x319))
result[(0, 7, 0)] = numpy.sum(((x235 * x272) * x322))
result[(0, 7, 1)] = numpy.sum(((x213 * x239) * x324))
result[(0, 7, 2)] = numpy.sum(((x217 * x299) * x325))
result[(0, 7, 3)] = numpy.sum(((x213 * x326) * x89))
result[(0, 7, 4)] = numpy.sum(((x239 * x269) * x89))
result[(0, 7, 5)] = numpy.sum(((x235 * x266) * x89))
result[(0, 7, 6)] = numpy.sum(((x213 * x252) * x316))
result[(0, 7, 7)] = numpy.sum(((x243 * x269) * x70))
result[(0, 7, 8)] = numpy.sum(((x222 * x239) * x327))
result[(0, 7, 9)] = numpy.sum(((x228 * x315) * x325))
result[(0, 7, 10)] = numpy.sum(((x213 * x258) * x328))
result[(0, 7, 11)] = numpy.sum(((x217 * x252) * x329))
result[(0, 7, 12)] = numpy.sum(((x245 * x265) * x77))
result[(0, 7, 13)] = numpy.sum(((x228 * x239) * x330))
result[(0, 7, 14)] = numpy.sum(((x232 * x235) * x328))
result[(0, 8, 0)] = numpy.sum(((x177 * x322) * x331))
result[(0, 8, 1)] = numpy.sum(((x181 * x299) * x332))
result[(0, 8, 2)] = numpy.sum(((x177 * x281) * x324))
result[(0, 8, 3)] = numpy.sum(((x262 * x333) * x89))
result[(0, 8, 4)] = numpy.sum(((x264 * x281) * x89))
result[(0, 8, 5)] = numpy.sum(((x177 * x334) * x89))
result[(0, 8, 6)] = numpy.sum(((x198 * x315) * x332))
result[(0, 8, 7)] = numpy.sum(((x188 * x281) * x327))
result[(0, 8, 8)] = numpy.sum(((x264 * x287) * x70))
result[(0, 8, 9)] = numpy.sum(((x177 * x292) * x316))
result[(0, 8, 10)] = numpy.sum(((x204 * x276) * x328))
result[(0, 8, 11)] = numpy.sum(((x198 * x281) * x330))
result[(0, 8, 12)] = numpy.sum(((x262 * x288) * x77))
result[(0, 8, 13)] = numpy.sum(((x181 * x292) * x329))
result[(0, 8, 14)] = numpy.sum(((x177 * x297) * x328))
result[(0, 9, 0)] = numpy.sum(((x164 * x300) * x336))
result[(0, 9, 1)] = numpy.sum(((x159 * x299) * x337))
result[(0, 9, 2)] = numpy.sum(((x128 * x299) * x341))
result[(0, 9, 3)] = numpy.sum(((x218 * x335) * x89))
result[(0, 9, 4)] = numpy.sum(((x159 * x342) * x89))
result[(0, 9, 5)] = numpy.sum(((x128 * x345) * x89))
result[(0, 9, 6)] = numpy.sum(((x153 * x314) * x346))
result[(0, 9, 7)] = numpy.sum(((x131 * x315) * x347))
result[(0, 9, 8)] = numpy.sum(((x159 * x316) * x344))
result[(0, 9, 9)] = numpy.sum(((x128 * x315) * x349))
result[(0, 9, 10)] = numpy.sum(((x166 * x319) * x336))
result[(0, 9, 11)] = numpy.sum(((x153 * x321) * x340))
result[(0, 9, 12)] = numpy.sum(((x218 * x344) * x77))
result[(0, 9, 13)] = numpy.sum(((x159 * x321) * x349))
result[(0, 9, 14)] = numpy.sum(((x128 * x320) * x351))
result[(0, 10, 0)] = numpy.sum(((x126 * x352) * x357))
result[(0, 10, 1)] = numpy.sum(((x155 * x358) * x359))
result[(0, 10, 2)] = numpy.sum(((x298 * x360) * x361))
result[(0, 10, 3)] = numpy.sum(((x362 * x364) * x87))
result[(0, 10, 4)] = numpy.sum(((x361 * x365) * x87))
result[(0, 10, 5)] = numpy.sum(((x140 * x352) * x87))
result[(0, 10, 6)] = numpy.sum(((x126 * x366) * x368))
result[(0, 10, 7)] = numpy.sum(((x156 * x363) * x369))
result[(0, 10, 8)] = numpy.sum(((x138 * x358) * x369))
result[(0, 10, 9)] = numpy.sum(((x163 * x352) * x367))
result[(0, 10, 10)] = numpy.sum(((x126 * x370) * x372))
result[(0, 10, 11)] = numpy.sum(((x156 * x366) * x373))
result[(0, 10, 12)] = numpy.sum(((x140 * x363) * x371))
result[(0, 10, 13)] = numpy.sum(((x163 * x358) * x372))
result[(0, 10, 14)] = numpy.sum(((x174 * x352) * x372))
result[(0, 11, 0)] = numpy.sum(((x213 * x302) * x357))
result[(0, 11, 1)] = numpy.sum(((x298 * x305) * x374))
result[(0, 11, 2)] = numpy.sum(((x216 * x298) * x306))
result[(0, 11, 3)] = numpy.sum(((x213 * x375) * x87))
result[(0, 11, 4)] = numpy.sum(((x217 * x310) * x87))
result[(0, 11, 5)] = numpy.sum(((x223 * x301) * x87))
result[(0, 11, 6)] = numpy.sum(((x313 * x374) * x85))
result[(0, 11, 7)] = numpy.sum(((x217 * x309) * x376))
result[(0, 11, 8)] = numpy.sum(((x222 * x311) * x85))
result[(0, 11, 9)] = numpy.sum(((x228 * x307) * x85))
result[(0, 11, 10)] = numpy.sum(((x213 * x318) * x373))
result[(0, 11, 11)] = numpy.sum(((x216 * x313) * x377))
result[(0, 11, 12)] = numpy.sum(((x223 * x309) * x371))
result[(0, 11, 13)] = numpy.sum(((x228 * x305) * x378))
result[(0, 11, 14)] = numpy.sum(((x232 * x302) * x372))
result[(0, 12, 0)] = numpy.sum(((x237 * x276) * x356))
result[(0, 12, 1)] = numpy.sum(((x239 * x277) * x379))
result[(0, 12, 2)] = numpy.sum(((x236 * x281) * x379))
result[(0, 12, 3)] = numpy.sum(((x243 * x276) * x380))
result[(0, 12, 4)] = numpy.sum(((x239 * x284) * x380))
result[(0, 12, 5)] = numpy.sum(((x235 * x287) * x380))
result[(0, 12, 6)] = numpy.sum(((x252 * x277) * x381))
result[(0, 12, 7)] = numpy.sum(((x245 * x284) * x85))
result[(0, 12, 8)] = numpy.sum(((x239 * x334) * x85))
result[(0, 12, 9)] = numpy.sum(((x236 * x292) * x381))
result[(0, 12, 10)] = numpy.sum(((x258 * x277) * x382))
result[(0, 12, 11)] = numpy.sum(((x252 * x281) * x383))
result[(0, 12, 12)] = numpy.sum(((x243 * x288) * x371))
result[(0, 12, 13)] = numpy.sum(((x239 * x292) * x383))
result[(0, 12, 14)] = numpy.sum(((x237 * x297) * x371))
result[(0, 13, 0)] = numpy.sum(((x177 * x336) * x357))
result[(0, 13, 1)] = numpy.sum(((x180 * x298) * x346))
result[(0, 13, 2)] = numpy.sum(((x177 * x298) * x341))
result[(0, 13, 3)] = numpy.sum(((x188 * x384) * x87))
result[(0, 13, 4)] = numpy.sum(((x181 * x347) * x87))
result[(0, 13, 5)] = numpy.sum(((x177 * x345) * x87))
result[(0, 13, 6)] = numpy.sum(((x198 * x337) * x85))
result[(0, 13, 7)] = numpy.sum(((x188 * x341) * x376))
result[(0, 13, 8)] = numpy.sum(((x181 * x344) * x376))
result[(0, 13, 9)] = numpy.sum(((x349 * x385) * x85))
result[(0, 13, 10)] = numpy.sum(((x204 * x336) * x372))
result[(0, 13, 11)] = numpy.sum(((x198 * x340) * x378))
result[(0, 13, 12)] = numpy.sum(((x188 * x344) * x383))
result[(0, 13, 13)] = numpy.sum(((x180 * x349) * x377))
result[(0, 13, 14)] = numpy.sum(((x177 * x351) * x373))
result[(0, 14, 0)] = numpy.sum(((x128 * x357) * x386))
result[(0, 14, 1)] = numpy.sum(((x298 * x387) * x388))
result[(0, 14, 2)] = numpy.sum(((x164 * x359) * x389))
result[(0, 14, 3)] = numpy.sum(((x132 * x390) * x87))
result[(0, 14, 4)] = numpy.sum(((x388 * x391) * x87))
result[(0, 14, 5)] = numpy.sum(((x392 * x394) * x87))
result[(0, 14, 6)] = numpy.sum(((x154 * x367) * x386))
result[(0, 14, 7)] = numpy.sum(((x131 * x369) * x389))
result[(0, 14, 8)] = numpy.sum(((x159 * x369) * x393))
result[(0, 14, 9)] = numpy.sum(((x128 * x368) * x395))
result[(0, 14, 10)] = numpy.sum(((x166 * x372) * x386))
result[(0, 14, 11)] = numpy.sum(((x154 * x372) * x389))
result[(0, 14, 12)] = numpy.sum(((x132 * x382) * x393))
result[(0, 14, 13)] = numpy.sum(((x159 * x373) * x395))
result[(0, 14, 14)] = numpy.sum(((x128 * x372) * x396))
result[(1, 0, 0)] = numpy.sum((x397 * x403))
result[(1, 0, 1)] = numpy.sum(((x404 * x407) * x408))
result[(1, 0, 2)] = numpy.sum(((x116 * x404) * x409))
result[(1, 0, 3)] = numpy.sum(((x362 * x412) * x417))
result[(1, 0, 4)] = numpy.sum(((x156 * x412) * x418))
result[(1, 0, 5)] = numpy.sum(((x140 * x412) * x413))
result[(1, 0, 6)] = numpy.sum(((x422 * x429) * x430))
result[(1, 0, 7)] = numpy.sum(((x416 * x429) * x431))
result[(1, 0, 8)] = numpy.sum(((x160 * x407) * x429))
result[(1, 0, 9)] = numpy.sum(((x163 * x429) * x432))
result[(1, 0, 10)] = numpy.sum(((x155 * x436) * x438))
result[(1, 0, 11)] = numpy.sum(((x422 * x436) * x439))
result[(1, 0, 12)] = numpy.sum(((x140 * x416) * x436))
result[(1, 0, 13)] = numpy.sum(((x163 * x407) * x436))
result[(1, 0, 14)] = numpy.sum(((x413 * x436) * x440))
result[(1, 1, 0)] = numpy.sum(((x402 * x408) * x443))
result[(1, 1, 1)] = numpy.sum(((x126 * x446) * x66))
result[(1, 1, 2)] = numpy.sum(((x156 * x447) * x66))
result[(1, 1, 3)] = numpy.sum(((x240 * x411) * x450))
result[(1, 1, 4)] = numpy.sum(((x156 * x411) * x451))
result[(1, 1, 5)] = numpy.sum(((x194 * x411) * x442))
result[(1, 1, 6)] = numpy.sum(((x199 * x428) * x456))
result[(1, 1, 7)] = numpy.sum(((x156 * x450) * x458))
result[(1, 1, 8)] = numpy.sum(((x138 * x446) * x457))
result[(1, 1, 9)] = numpy.sum(((x202 * x428) * x442))
result[(1, 1, 10)] = numpy.sum(((x424 * x430) * x460))
result[(1, 1, 11)] = numpy.sum(((x156 * x456) * x461))
result[(1, 1, 12)] = numpy.sum(((x194 * x424) * x450))
result[(1, 1, 13)] = numpy.sum(((x202 * x424) * x445))
result[(1, 1, 14)] = numpy.sum(((x209 * x424) * x443))
result[(1, 2, 0)] = numpy.sum(((x211 * x402) * x409))
result[(1, 2, 1)] = numpy.sum(((x213 * x462) * x66))
result[(1, 2, 2)] = numpy.sum(((x217 * x413) * x66))
result[(1, 2, 3)] = numpy.sum(((x213 * x411) * x463))
result[(1, 2, 4)] = numpy.sum(((x219 * x406) * x411))
result[(1, 2, 5)] = numpy.sum(((x223 * x411) * x413))
result[(1, 2, 6)] = numpy.sum(((x374 * x422) * x428))
result[(1, 2, 7)] = numpy.sum(((x217 * x416) * x457))
result[(1, 2, 8)] = numpy.sum(((x222 * x457) * x462))
result[(1, 2, 9)] = numpy.sum(((x229 * x413) * x428))
result[(1, 2, 10)] = numpy.sum(((x438 * x464) * x465))
result[(1, 2, 11)] = numpy.sum(((x217 * x422) * x424))
result[(1, 2, 12)] = numpy.sum(((x223 * x416) * x424))
result[(1, 2, 13)] = numpy.sum(((x228 * x424) * x462))
result[(1, 2, 14)] = numpy.sum(((x232 * x432) * x464))
result[(1, 3, 0)] = numpy.sum(((x466 * x470) * x471))
result[(1, 3, 1)] = numpy.sum(((x240 * x473) * x64))
result[(1, 3, 2)] = numpy.sum(((x156 * x474) * x64))
result[(1, 3, 3)] = numpy.sum(((x126 * x476) * x477))
result[(1, 3, 4)] = numpy.sum(((x156 * x477) * x478))
result[(1, 3, 5)] = numpy.sum(((x249 * x36) * x469))
result[(1, 3, 6)] = numpy.sum(((x147 * x240) * x484))
result[(1, 3, 7)] = numpy.sum(((x156 * x485) * x486))
result[(1, 3, 8)] = numpy.sum(((x249 * x473) * x485))
result[(1, 3, 9)] = numpy.sum(((x147 * x469) * x487))
result[(1, 3, 10)] = numpy.sum(((x471 * x492) * x493))
result[(1, 3, 11)] = numpy.sum(((x156 * x484) * x494))
result[(1, 3, 12)] = numpy.sum(((x144 * x249) * x476))
result[(1, 3, 13)] = numpy.sum(((x144 * x473) * x487))
result[(1, 3, 14)] = numpy.sum(((x469 * x493) * x495))
result[(1, 4, 0)] = numpy.sum(((x213 * x466) * x496))
result[(1, 4, 1)] = numpy.sum(((x213 * x451) * x64))
result[(1, 4, 2)] = numpy.sum(((x219 * x442) * x64))
result[(1, 4, 3)] = numpy.sum(((x213 * x477) * x497))
result[(1, 4, 4)] = numpy.sum(((x269 * x36) * x445))
result[(1, 4, 5)] = numpy.sum(((x266 * x36) * x442))
result[(1, 4, 6)] = numpy.sum(((x147 * x456) * x498))
result[(1, 4, 7)] = numpy.sum(((x147 * x269) * x450))
result[(1, 4, 8)] = numpy.sum(((x147 * x445) * x500))
result[(1, 4, 9)] = numpy.sum(((x147 * x270) * x442))
result[(1, 4, 10)] = numpy.sum(((x144 * x460) * x501))
result[(1, 4, 11)] = numpy.sum(((x144 * x219) * x456))
result[(1, 4, 12)] = numpy.sum(((x144 * x266) * x450))
result[(1, 4, 13)] = numpy.sum(((x144 * x270) * x445))
result[(1, 4, 14)] = numpy.sum(((x144 * x274) * x443))
result[(1, 5, 0)] = numpy.sum(((x278 * x413) * x466))
result[(1, 5, 1)] = numpy.sum(((x279 * x406) * x64))
result[(1, 5, 2)] = numpy.sum(((x281 * x502) * x64))
result[(1, 5, 3)] = numpy.sum(((x333 * x36) * x416))
result[(1, 5, 4)] = numpy.sum(((x285 * x36) * x406))
result[(1, 5, 5)] = numpy.sum(((x288 * x36) * x413))
result[(1, 5, 6)] = numpy.sum(((x147 * x279) * x422))
result[(1, 5, 7)] = numpy.sum(((x147 * x284) * x503))
result[(1, 5, 8)] = numpy.sum(((x147 * x334) * x406))
result[(1, 5, 9)] = numpy.sum(((x147 * x292) * x502))
result[(1, 5, 10)] = numpy.sum(((x277 * x438) * x493))
result[(1, 5, 11)] = numpy.sum(((x281 * x422) * x494))
result[(1, 5, 12)] = numpy.sum(((x144 * x288) * x416))
result[(1, 5, 13)] = numpy.sum(((x292 * x406) * x494))
result[(1, 5, 14)] = numpy.sum(((x413 * x493) * x504))
result[(1, 6, 0)] = numpy.sum(((x430 * x508) * x512))
result[(1, 6, 1)] = numpy.sum(((x199 * x511) * x515))
result[(1, 6, 2)] = numpy.sum(((x156 * x511) * x516))
result[(1, 6, 3)] = numpy.sum(((x240 * x34) * x518))
result[(1, 6, 4)] = numpy.sum((((x156 * x182) * x34) * x519))
result[(1, 6, 5)] = numpy.sum(((x194 * x34) * x508))
result[(1, 6, 6)] = numpy.sum(((x126 * x521) * x522))
result[(1, 6, 7)] = numpy.sum(((x156 * x518) * x523))
result[(1, 6, 8)] = numpy.sum(((x138 * x519) * x522))
result[(1, 6, 9)] = numpy.sum(((x202 * x32) * x508))
result[(1, 6, 10)] = numpy.sum(((x408 * x526) * x527))
result[(1, 6, 11)] = numpy.sum(((x156 * x521) * x528))
result[(1, 6, 12)] = numpy.sum(((x194 * x518) * x75))
result[(1, 6, 13)] = numpy.sum(((x202 * x515) * x75))
result[(1, 6, 14)] = numpy.sum(((x209 * x508) * x527))
result[(1, 7, 0)] = numpy.sum(((x469 * x501) * x512))
result[(1, 7, 1)] = numpy.sum(((x473 * x498) * x511))
result[(1, 7, 2)] = numpy.sum(((x219 * x469) * x511))
result[(1, 7, 3)] = numpy.sum(((x213 * x486) * x529))
result[(1, 7, 4)] = numpy.sum(((x269 * x34) * x473))
result[(1, 7, 5)] = numpy.sum(((x266 * x34) * x469))
result[(1, 7, 6)] = numpy.sum(((x213 * x484) * x523))
result[(1, 7, 7)] = numpy.sum(((x269 * x32) * x476))
result[(1, 7, 8)] = numpy.sum(((x32 * x473) * x500))
result[(1, 7, 9)] = numpy.sum(((x270 * x32) * x469))
result[(1, 7, 10)] = numpy.sum(((x213 * x492) * x530))
result[(1, 7, 11)] = numpy.sum(((x219 * x484) * x75))
result[(1, 7, 12)] = numpy.sum(((x266 * x476) * x75))
result[(1, 7, 13)] = numpy.sum(((x228 * x473) * x531))
result[(1, 7, 14)] = numpy.sum(((x274 * x469) * x527))
result[(1, 8, 0)] = numpy.sum(((x331 * x443) * x512))
result[(1, 8, 1)] = numpy.sum(((x332 * x446) * x511))
result[(1, 8, 2)] = numpy.sum(((x281 * x511) * x532))
result[(1, 8, 3)] = numpy.sum(((x333 * x450) * x529))
result[(1, 8, 4)] = numpy.sum(((x34 * x445) * x533))
result[(1, 8, 5)] = numpy.sum(((x334 * x34) * x442))
result[(1, 8, 6)] = numpy.sum(((x332 * x456) * x522))
result[(1, 8, 7)] = numpy.sum(((x32 * x450) * x533))
result[(1, 8, 8)] = numpy.sum(((x287 * x445) * x534))
result[(1, 8, 9)] = numpy.sum(((x292 * x32) * x532))
result[(1, 8, 10)] = numpy.sum(((x331 * x460) * x527))
result[(1, 8, 11)] = numpy.sum(((x281 * x456) * x531))
result[(1, 8, 12)] = numpy.sum(((x334 * x450) * x75))
result[(1, 8, 13)] = numpy.sum(((x292 * x445) * x531))
result[(1, 8, 14)] = numpy.sum(((x297 * x496) * x75))
result[(1, 9, 0)] = numpy.sum(((x336 * x432) * x512))
result[(1, 9, 1)] = numpy.sum(((x337 * x406) * x511))
result[(1, 9, 2)] = numpy.sum(((x341 * x413) * x511))
result[(1, 9, 3)] = numpy.sum(((x34 * x384) * x416))
result[(1, 9, 4)] = numpy.sum(((x34 * x347) * x462))
result[(1, 9, 5)] = numpy.sum(((x34 * x345) * x413))
result[(1, 9, 6)] = numpy.sum(((x32 * x337) * x422))
result[(1, 9, 7)] = numpy.sum(((x341 * x416) * x535))
result[(1, 9, 8)] = numpy.sum(((x344 * x462) * x535))
result[(1, 9, 9)] = numpy.sum(((x349 * x413) * x522))
result[(1, 9, 10)] = numpy.sum(((x336 * x438) * x527))
result[(1, 9, 11)] = numpy.sum(((x341 * x422) * x75))
result[(1, 9, 12)] = numpy.sum(((x345 * x416) * x75))
result[(1, 9, 13)] = numpy.sum(((x349 * x462) * x75))
result[(1, 9, 14)] = numpy.sum(((x413 * x527) * x536))
result[(1, 10, 0)] = numpy.sum(((x155 * x537) * x540))
result[(1, 10, 1)] = numpy.sum(((x430 * x509) * x541))
result[(1, 10, 2)] = numpy.sum(((x439 * x509) * x537))
result[(1, 10, 3)] = numpy.sum(((x362 * x543) * x544))
result[(1, 10, 4)] = numpy.sum(((x354 * x431) * x541))
result[(1, 10, 5)] = numpy.sum(((x140 * x354) * x537))
result[(1, 10, 6)] = numpy.sum(((x408 * x545) * x546))
result[(1, 10, 7)] = numpy.sum(((x156 * x543) * x547))
result[(1, 10, 8)] = numpy.sum(((x160 * x541) * x546))
result[(1, 10, 9)] = numpy.sum(((x163 * x537) * x546))
result[(1, 10, 10)] = numpy.sum((x10 * x549))
result[(1, 10, 11)] = numpy.sum(((x545 * x550) * x551))
result[(1, 10, 12)] = numpy.sum(((x140 * x22) * x543))
result[(1, 10, 13)] = numpy.sum(((x163 * x541) * x552))
result[(1, 10, 14)] = numpy.sum(((x22 * x440) * x537))
result[(1, 11, 0)] = numpy.sum(((x465 * x540) * x553))
result[(1, 11, 1)] = numpy.sum(((x374 * x509) * x515))
result[(1, 11, 2)] = numpy.sum(((x217 * x508) * x509))
result[(1, 11, 3)] = numpy.sum(((x213 * x518) * x554))
result[(1, 11, 4)] = numpy.sum(((x219 * x354) * x515))
result[(1, 11, 5)] = numpy.sum(((x223 * x354) * x508))
result[(1, 11, 6)] = numpy.sum(((x213 * x521) * x555))
result[(1, 11, 7)] = numpy.sum(((x13 * x219) * x518))
result[(1, 11, 8)] = numpy.sum(((x222 * x519) * x555))
result[(1, 11, 9)] = numpy.sum(((x228 * x508) * x555))
result[(1, 11, 10)] = numpy.sum(((x211 * x550) * x556))
result[(1, 11, 11)] = numpy.sum(((x217 * x22) * x521))
result[(1, 11, 12)] = numpy.sum(((x22 * x223) * x518))
result[(1, 11, 13)] = numpy.sum(((x22 * x229) * x515))
result[(1, 11, 14)] = numpy.sum(((x232 * x552) * x553))
result[(1, 12, 0)] = numpy.sum(((x278 * x469) * x540))
result[(1, 12, 1)] = numpy.sum(((x279 * x473) * x509))
result[(1, 12, 2)] = numpy.sum(((x281 * x474) * x509))
result[(1, 12, 3)] = numpy.sum(((x333 * x354) * x476))
result[(1, 12, 4)] = numpy.sum(((x284 * x473) * x557))
result[(1, 12, 5)] = numpy.sum(((x288 * x354) * x469))
result[(1, 12, 6)] = numpy.sum(((x13 * x279) * x484))
result[(1, 12, 7)] = numpy.sum(((x13 * x285) * x476))
result[(1, 12, 8)] = numpy.sum(((x13 * x334) * x473))
result[(1, 12, 9)] = numpy.sum(((x13 * x292) * x474))
result[(1, 12, 10)] = numpy.sum(((x22 * x278) * x492))
result[(1, 12, 11)] = numpy.sum(((x281 * x484) * x558))
result[(1, 12, 12)] = numpy.sum(((x22 * x288) * x476))
result[(1, 12, 13)] = numpy.sum(((x292 * x473) * x558))
result[(1, 12, 14)] = numpy.sum(((x22 * x470) * x504))
result[(1, 13, 0)] = numpy.sum(((x336 * x443) * x540))
result[(1, 13, 1)] = numpy.sum(((x337 * x445) * x509))
result[(1, 13, 2)] = numpy.sum(((x341 * x442) * x509))
result[(1, 13, 3)] = numpy.sum(((x354 * x384) * x450))
result[(1, 13, 4)] = numpy.sum(((x342 * x354) * x445))
result[(1, 13, 5)] = numpy.sum(((x345 * x354) * x442))
result[(1, 13, 6)] = numpy.sum(((x13 * x337) * x456))
result[(1, 13, 7)] = numpy.sum(((x13 * x342) * x450))
result[(1, 13, 8)] = numpy.sum(((x344 * x445) * x559))
result[(1, 13, 9)] = numpy.sum(((x349 * x442) * x555))
result[(1, 13, 10)] = numpy.sum(((x336 * x460) * x552))
result[(1, 13, 11)] = numpy.sum(((x22 * x341) * x456))
result[(1, 13, 12)] = numpy.sum(((x22 * x345) * x450))
result[(1, 13, 13)] = numpy.sum(((x22 * x349) * x446))
result[(1, 13, 14)] = numpy.sum(((x22 * x443) * x536))
result[(1, 14, 0)] = numpy.sum(((x413 * x540) * x560))
result[(1, 14, 1)] = numpy.sum(((x387 * x407) * x509))
result[(1, 14, 2)] = numpy.sum(((x432 * x509) * x561))
result[(1, 14, 3)] = numpy.sum(((x390 * x416) * x544))
result[(1, 14, 4)] = numpy.sum(((x354 * x391) * x407))
result[(1, 14, 5)] = numpy.sum(((x394 * x413) * x544))
result[(1, 14, 6)] = numpy.sum(((x387 * x422) * x546))
result[(1, 14, 7)] = numpy.sum(((x391 * x416) * x546))
result[(1, 14, 8)] = numpy.sum(((x13 * x393) * x418))
result[(1, 14, 9)] = numpy.sum(((x413 * x546) * x562))
result[(1, 14, 10)] = numpy.sum(((x22 * x438) * x560))
result[(1, 14, 11)] = numpy.sum(((x422 * x552) * x561))
result[(1, 14, 12)] = numpy.sum(((x22 * x394) * x417))
result[(1, 14, 13)] = numpy.sum(((x22 * x407) * x562))
result[(1, 14, 14)] = numpy.sum(((x396 * x397) * x566))
result[(2, 0, 0)] = numpy.sum((x403 * x567))
result[(2, 0, 1)] = numpy.sum(((x111 * x404) * x568))
result[(2, 0, 2)] = numpy.sum(((x404 * x571) * x572))
result[(2, 0, 3)] = numpy.sum(((x133 * x412) * x573))
result[(2, 0, 4)] = numpy.sum(((x159 * x412) * x574))
result[(2, 0, 5)] = numpy.sum(((x392 * x412) * x578))
result[(2, 0, 6)] = numpy.sum(((x154 * x429) * x579))
result[(2, 0, 7)] = numpy.sum(((x157 * x429) * x571))
result[(2, 0, 8)] = numpy.sum(((x429 * x577) * x580))
result[(2, 0, 9)] = numpy.sum(((x429 * x584) * x585))
result[(2, 0, 10)] = numpy.sum(((x166 * x436) * x579))
result[(2, 0, 11)] = numpy.sum(((x154 * x436) * x571))
result[(2, 0, 12)] = numpy.sum(((x132 * x436) * x578))
result[(2, 0, 13)] = numpy.sum(((x388 * x436) * x586))
result[(2, 0, 14)] = numpy.sum(((x164 * x436) * x588))
result[(2, 1, 0)] = numpy.sum(((x175 * x402) * x568))
result[(2, 1, 1)] = numpy.sum(((x181 * x573) * x66))
result[(2, 1, 2)] = numpy.sum(((x177 * x589) * x66))
result[(2, 1, 3)] = numpy.sum(((x191 * x411) * x573))
result[(2, 1, 4)] = numpy.sum(((x193 * x411) * x570))
result[(2, 1, 5)] = numpy.sum(((x177 * x411) * x590))
result[(2, 1, 6)] = numpy.sum(((x198 * x428) * x591))
result[(2, 1, 7)] = numpy.sum(((x188 * x458) * x570))
result[(2, 1, 8)] = numpy.sum(((x181 * x457) * x577))
result[(2, 1, 9)] = numpy.sum(((x385 * x428) * x584))
result[(2, 1, 10)] = numpy.sum(((x204 * x464) * x579))
result[(2, 1, 11)] = numpy.sum(((x198 * x461) * x570))
result[(2, 1, 12)] = numpy.sum(((x188 * x424) * x590))
result[(2, 1, 13)] = numpy.sum(((x181 * x424) * x584))
result[(2, 1, 14)] = numpy.sum(((x464 * x588) * x592))
result[(2, 2, 0)] = numpy.sum(((x402 * x572) * x595))
result[(2, 2, 1)] = numpy.sum(((x159 * x596) * x66))
result[(2, 2, 2)] = numpy.sum(((x128 * x599) * x66))
result[(2, 2, 3)] = numpy.sum(((x218 * x411) * x594))
result[(2, 2, 4)] = numpy.sum(((x159 * x411) * x600))
result[(2, 2, 5)] = numpy.sum(((x282 * x411) * x603))
result[(2, 2, 6)] = numpy.sum(((x224 * x428) * x594))
result[(2, 2, 7)] = numpy.sum(((x131 * x458) * x598))
result[(2, 2, 8)] = numpy.sum(((x159 * x458) * x603))
result[(2, 2, 9)] = numpy.sum(((x428 * x608) * x609))
result[(2, 2, 10)] = numpy.sum(((x230 * x424) * x595))
result[(2, 2, 11)] = numpy.sum(((x153 * x461) * x598))
result[(2, 2, 12)] = numpy.sum(((x218 * x424) * x603))
result[(2, 2, 13)] = numpy.sum(((x159 * x461) * x608))
result[(2, 2, 14)] = numpy.sum(((x424 * x585) * x611))
result[(2, 3, 0)] = numpy.sum(((x237 * x466) * x573))
result[(2, 3, 1)] = numpy.sum(((x239 * x612) * x64))
result[(2, 3, 2)] = numpy.sum(((x241 * x570) * x64))
result[(2, 3, 3)] = numpy.sum(((x245 * x36) * x573))
result[(2, 3, 4)] = numpy.sum(((x247 * x477) * x570))
result[(2, 3, 5)] = numpy.sum(((x235 * x36) * x613))
result[(2, 3, 6)] = numpy.sum(((x147 * x252) * x612))
result[(2, 3, 7)] = numpy.sum(((x245 * x485) * x570))
result[(2, 3, 8)] = numpy.sum(((x239 * x485) * x613))
result[(2, 3, 9)] = numpy.sum(((x147 * x241) * x584))
result[(2, 3, 10)] = numpy.sum(((x258 * x493) * x614))
result[(2, 3, 11)] = numpy.sum(((x252 * x494) * x570))
result[(2, 3, 12)] = numpy.sum(((x144 * x243) * x613))
result[(2, 3, 13)] = numpy.sum(((x239 * x494) * x584))
result[(2, 3, 14)] = numpy.sum(((x144 * x237) * x588))
result[(2, 4, 0)] = numpy.sum(((x177 * x466) * x615))
result[(2, 4, 1)] = numpy.sum(((x193 * x594) * x64))
result[(2, 4, 2)] = numpy.sum(((x177 * x600) * x64))
result[(2, 4, 3)] = numpy.sum(((x262 * x477) * x594))
result[(2, 4, 4)] = numpy.sum(((x264 * x36) * x598))
result[(2, 4, 5)] = numpy.sum(((x177 * x603) * x616))
result[(2, 4, 6)] = numpy.sum(((x147 * x267) * x596))
result[(2, 4, 7)] = numpy.sum(((x147 * x188) * x617))
result[(2, 4, 8)] = numpy.sum(((x147 * x264) * x603))
result[(2, 4, 9)] = numpy.sum(((x147 * x608) * x618))
result[(2, 4, 10)] = numpy.sum(((x144 * x204) * x615))
result[(2, 4, 11)] = numpy.sum(((x144 * x267) * x599))
result[(2, 4, 12)] = numpy.sum(((x144 * x262) * x619))
result[(2, 4, 13)] = numpy.sum(((x144 * x193) * x608))
result[(2, 4, 14)] = numpy.sum(((x144 * x611) * x620))
result[(2, 5, 0)] = numpy.sum(((x466 * x624) * x625))
result[(2, 5, 1)] = numpy.sum(((x159 * x626) * x64))
result[(2, 5, 2)] = numpy.sum(((x282 * x628) * x64))
result[(2, 5, 3)] = numpy.sum(((x283 * x36) * x623))
result[(2, 5, 4)] = numpy.sum(((x159 * x616) * x628))
result[(2, 5, 5)] = numpy.sum(((x128 * x477) * x630))
result[(2, 5, 6)] = numpy.sum(((x147 * x289) * x624))
result[(2, 5, 7)] = numpy.sum(((x283 * x485) * x628))
result[(2, 5, 8)] = numpy.sum(((x159 * x485) * x631))
result[(2, 5, 9)] = numpy.sum(((x147 * x282) * x637))
result[(2, 5, 10)] = numpy.sum(((x144 * x293) * x624))
result[(2, 5, 11)] = numpy.sum(((x144 * x628) * x638))
result[(2, 5, 12)] = numpy.sum(((x144 * x283) * x630))
result[(2, 5, 13)] = numpy.sum(((x159 * x494) * x637))
result[(2, 5, 14)] = numpy.sum(((x392 * x493) * x643))
result[(2, 6, 0)] = numpy.sum(((x302 * x512) * x579))
result[(2, 6, 1)] = numpy.sum(((x305 * x511) * x591))
result[(2, 6, 2)] = numpy.sum(((x307 * x511) * x570))
result[(2, 6, 3)] = numpy.sum(((x34 * x375) * x573))
result[(2, 6, 4)] = numpy.sum(((x311 * x34) * x570))
result[(2, 6, 5)] = numpy.sum(((x301 * x34) * x590))
result[(2, 6, 6)] = numpy.sum(((x313 * x522) * x573))
result[(2, 6, 7)] = numpy.sum(((x309 * x523) * x570))
result[(2, 6, 8)] = numpy.sum(((x311 * x32) * x577))
result[(2, 6, 9)] = numpy.sum(((x307 * x32) * x584))
result[(2, 6, 10)] = numpy.sum(((x318 * x527) * x644))
result[(2, 6, 11)] = numpy.sum(((x313 * x528) * x570))
result[(2, 6, 12)] = numpy.sum(((x309 * x590) * x75))
result[(2, 6, 13)] = numpy.sum(((x305 * x528) * x584))
result[(2, 6, 14)] = numpy.sum(((x302 * x527) * x588))
result[(2, 7, 0)] = numpy.sum(((x235 * x512) * x615))
result[(2, 7, 1)] = numpy.sum(((x239 * x511) * x645))
result[(2, 7, 2)] = numpy.sum(((x325 * x511) * x599))
result[(2, 7, 3)] = numpy.sum(((x245 * x529) * x594))
result[(2, 7, 4)] = numpy.sum(((x239 * x34) * x617))
result[(2, 7, 5)] = numpy.sum(((x235 * x529) * x619))
result[(2, 7, 6)] = numpy.sum(((x252 * x535) * x596))
result[(2, 7, 7)] = numpy.sum(((x243 * x534) * x598))
result[(2, 7, 8)] = numpy.sum(((x239 * x534) * x603))
result[(2, 7, 9)] = numpy.sum(((x325 * x522) * x608))
result[(2, 7, 10)] = numpy.sum(((x258 * x530) * x594))
result[(2, 7, 11)] = numpy.sum(((x252 * x531) * x598))
result[(2, 7, 12)] = numpy.sum(((x326 * x603) * x75))
result[(2, 7, 13)] = numpy.sum(((x239 * x531) * x608))
result[(2, 7, 14)] = numpy.sum(((x235 * x530) * x611))
result[(2, 8, 0)] = numpy.sum(((x512 * x620) * x623))
result[(2, 8, 1)] = numpy.sum(((x193 * x511) * x623))
result[(2, 8, 2)] = numpy.sum(((x511 * x618) * x628))
result[(2, 8, 3)] = numpy.sum(((x263 * x34) * x623))
result[(2, 8, 4)] = numpy.sum(((x264 * x34) * x628))
result[(2, 8, 5)] = numpy.sum(((x177 * x529) * x631))
result[(2, 8, 6)] = numpy.sum(((x267 * x522) * x623))
result[(2, 8, 7)] = numpy.sum(((x188 * x534) * x628))
result[(2, 8, 8)] = numpy.sum(((x264 * x32) * x630))
result[(2, 8, 9)] = numpy.sum(((x177 * x523) * x637))
result[(2, 8, 10)] = numpy.sum(((x204 * x530) * x623))
result[(2, 8, 11)] = numpy.sum(((x198 * x531) * x628))
result[(2, 8, 12)] = numpy.sum(((x263 * x630) * x75))
result[(2, 8, 13)] = numpy.sum(((x193 * x637) * x75))
result[(2, 8, 14)] = numpy.sum(((x177 * x530) * x643))
result[(2, 9, 0)] = numpy.sum(((x512 * x585) * x649))
result[(2, 9, 1)] = numpy.sum(((x159 * x511) * x650))
result[(2, 9, 2)] = numpy.sum(((x511 * x609) * x653))
result[(2, 9, 3)] = numpy.sum(((x218 * x34) * x649))
result[(2, 9, 4)] = numpy.sum(((x159 * x34) * x654))
result[(2, 9, 5)] = numpy.sum(((x282 * x34) * x656))
result[(2, 9, 6)] = numpy.sum(((x224 * x32) * x649))
result[(2, 9, 7)] = numpy.sum(((x131 * x523) * x653))
result[(2, 9, 8)] = numpy.sum(((x159 * x523) * x656))
result[(2, 9, 9)] = numpy.sum(((x128 * x522) * x658))
result[(2, 9, 10)] = numpy.sum(((x230 * x527) * x649))
result[(2, 9, 11)] = numpy.sum(((x224 * x653) * x75))
result[(2, 9, 12)] = numpy.sum(((x218 * x656) * x75))
result[(2, 9, 13)] = numpy.sum(((x159 * x528) * x658))
result[(2, 9, 14)] = numpy.sum(((x527 * x572) * x661))
result[(2, 10, 0)] = numpy.sum(((x352 * x540) * x579))
result[(2, 10, 1)] = numpy.sum(((x358 * x579) * x662))
result[(2, 10, 2)] = numpy.sum(((x360 * x509) * x571))
result[(2, 10, 3)] = numpy.sum((((x127 * x363) * x544) * x573))
result[(2, 10, 4)] = numpy.sum(((x354 * x365) * x571))
result[(2, 10, 5)] = numpy.sum(((x352 * x544) * x578))
result[(2, 10, 6)] = numpy.sum(((x366 * x546) * x644))
result[(2, 10, 7)] = numpy.sum(((x363 * x547) * x570))
result[(2, 10, 8)] = numpy.sum(((x365 * x546) * x577))
result[(2, 10, 9)] = numpy.sum(((x360 * x546) * x584))
result[(2, 10, 10)] = numpy.sum(((x370 * x550) * x567))
result[(2, 10, 11)] = numpy.sum(((x366 * x571) * x663))
result[(2, 10, 12)] = numpy.sum(((x22 * x364) * x578))
result[(2, 10, 13)] = numpy.sum(((x358 * x552) * x586))
result[(2, 10, 14)] = numpy.sum(((x352 * x552) * x588))
result[(2, 11, 0)] = numpy.sum(((x302 * x540) * x595))
result[(2, 11, 1)] = numpy.sum(((x305 * x509) * x596))
result[(2, 11, 2)] = numpy.sum(((x307 * x509) * x598))
result[(2, 11, 3)] = numpy.sum(((x309 * x554) * x594))
result[(2, 11, 4)] = numpy.sum(((x311 * x354) * x598))
result[(2, 11, 5)] = numpy.sum(((x301 * x554) * x603))
result[(2, 11, 6)] = numpy.sum(((x313 * x555) * x594))
result[(2, 11, 7)] = numpy.sum(((x309 * x559) * x598))
result[(2, 11, 8)] = numpy.sum(((x310 * x555) * x603))
result[(2, 11, 9)] = numpy.sum(((x13 * x307) * x608))
result[(2, 11, 10)] = numpy.sum(((x318 * x595) * x663))
result[(2, 11, 11)] = numpy.sum(((x22 * x313) * x599))
result[(2, 11, 12)] = numpy.sum(((x22 * x375) * x603))
result[(2, 11, 13)] = numpy.sum(((x305 * x608) * x664))
result[(2, 11, 14)] = numpy.sum(((x302 * x552) * x611))
result[(2, 12, 0)] = numpy.sum(((x237 * x540) * x623))
result[(2, 12, 1)] = numpy.sum(((x239 * x509) * x626))
result[(2, 12, 2)] = numpy.sum(((x241 * x509) * x628))
result[(2, 12, 3)] = numpy.sum(((x243 * x557) * x623))
result[(2, 12, 4)] = numpy.sum(((x247 * x557) * x628))
result[(2, 12, 5)] = numpy.sum(((x235 * x557) * x630))
result[(2, 12, 6)] = numpy.sum(((x13 * x252) * x626))
result[(2, 12, 7)] = numpy.sum(((x13 * x326) * x628))
result[(2, 12, 8)] = numpy.sum(((x13 * x247) * x631))
result[(2, 12, 9)] = numpy.sum(((x13 * x241) * x637))
result[(2, 12, 10)] = numpy.sum(((x22 * x258) * x665))
result[(2, 12, 11)] = numpy.sum(((x252 * x558) * x628))
result[(2, 12, 12)] = numpy.sum(((x22 * x245) * x630))
result[(2, 12, 13)] = numpy.sum(((x239 * x558) * x637))
result[(2, 12, 14)] = numpy.sum(((x22 * x237) * x643))
result[(2, 13, 0)] = numpy.sum(((x540 * x592) * x666))
result[(2, 13, 1)] = numpy.sum(((x181 * x509) * x649))
result[(2, 13, 2)] = numpy.sum(((x385 * x509) * x653))
result[(2, 13, 3)] = numpy.sum(((x188 * x554) * x649))
result[(2, 13, 4)] = numpy.sum(((x193 * x354) * x653))
result[(2, 13, 5)] = numpy.sum(((x177 * x554) * x656))
result[(2, 13, 6)] = numpy.sum(((x198 * x555) * x649))
result[(2, 13, 7)] = numpy.sum(((x188 * x559) * x653))
result[(2, 13, 8)] = numpy.sum(((x13 * x193) * x656))
result[(2, 13, 9)] = numpy.sum(((x177 * x555) * x658))
result[(2, 13, 10)] = numpy.sum(((x204 * x552) * x666))
result[(2, 13, 11)] = numpy.sum(((x198 * x653) * x664))
result[(2, 13, 12)] = numpy.sum(((x191 * x22) * x656))
result[(2, 13, 13)] = numpy.sum(((x181 * x22) * x658))
result[(2, 13, 14)] = numpy.sum(((x175 * x566) * x667))
result[(2, 14, 0)] = numpy.sum(((x164 * x540) * x668))
result[(2, 14, 1)] = numpy.sum(((x388 * x662) * x668))
result[(2, 14, 2)] = numpy.sum(((x509 * x585) * x669))
result[(2, 14, 3)] = numpy.sum(((x132 * x354) * x670))
result[(2, 14, 4)] = numpy.sum(((x354 * x580) * x669))
result[(2, 14, 5)] = numpy.sum(((x544 * x625) * x672))
result[(2, 14, 6)] = numpy.sum(((x154 * x546) * x668))
result[(2, 14, 7)] = numpy.sum(((x157 * x546) * x669))
result[(2, 14, 8)] = numpy.sum(((x159 * x547) * x672))
result[(2, 14, 9)] = numpy.sum(((x546 * x572) * x673))
result[(2, 14, 10)] = numpy.sum(((x166 * x552) * x668))
result[(2, 14, 11)] = numpy.sum(((x154 * x552) * x669))
result[(2, 14, 12)] = numpy.sum(((x133 * x22) * x672))
result[(2, 14, 13)] = numpy.sum(((x566 * x673) * x674))
result[(2, 14, 14)] = numpy.sum((x10 * x675))
result[(3, 0, 0)] = numpy.sum(((x126 * x677) * x680))
result[(3, 0, 1)] = numpy.sum(((x408 * x681) * x684))
result[(3, 0, 2)] = numpy.sum(((x156 * x681) * x685))
result[(3, 0, 3)] = numpy.sum(((x688 * x689) * x690))
result[(3, 0, 4)] = numpy.sum(((x156 * x689) * x691))
result[(3, 0, 5)] = numpy.sum(((x140 * x679) * x689))
result[(3, 0, 6)] = numpy.sum(((x430 * x692) * x694))
result[(3, 0, 7)] = numpy.sum(((x431 * x688) * x694))
result[(3, 0, 8)] = numpy.sum(((x160 * x684) * x694))
result[(3, 0, 9)] = numpy.sum(((x163 * x680) * x694))
result[(3, 0, 10)] = numpy.sum(((x155 * x695) * x696))
result[(3, 0, 11)] = numpy.sum(((x361 * x692) * x697))
result[(3, 0, 12)] = numpy.sum(((x140 * x688) * x695))
result[(3, 0, 13)] = numpy.sum(((x163 * x684) * x695))
result[(3, 0, 14)] = numpy.sum(((x174 * x680) * x695))
result[(3, 1, 0)] = numpy.sum(((x401 * x408) * x700))
result[(3, 1, 1)] = numpy.sum(((x126 * x58) * x703))
result[(3, 1, 2)] = numpy.sum(((x156 * x58) * x704))
result[(3, 1, 3)] = numpy.sum(((x240 * x410) * x707))
result[(3, 1, 4)] = numpy.sum(((x156 * x410) * x708))
result[(3, 1, 5)] = numpy.sum(((x194 * x410) * x699))
result[(3, 1, 6)] = numpy.sum(((x199 * x427) * x712))
result[(3, 1, 7)] = numpy.sum(((x156 * x707) * x713))
result[(3, 1, 8)] = numpy.sum(((x427 * x703) * x714))
result[(3, 1, 9)] = numpy.sum(((x202 * x427) * x699))
result[(3, 1, 10)] = numpy.sum(((x155 * x717) * x718))
result[(3, 1, 11)] = numpy.sum(((x156 * x712) * x719))
result[(3, 1, 12)] = numpy.sum(((x194 * x435) * x707))
result[(3, 1, 13)] = numpy.sum(((x202 * x435) * x702))
result[(3, 1, 14)] = numpy.sum(((x209 * x435) * x700))
result[(3, 2, 0)] = numpy.sum(((x213 * x401) * x685))
result[(3, 2, 1)] = numpy.sum(((x374 * x58) * x683))
result[(3, 2, 2)] = numpy.sum(((x217 * x58) * x679))
result[(3, 2, 3)] = numpy.sum(((x213 * x688) * x720))
result[(3, 2, 4)] = numpy.sum(((x219 * x410) * x683))
result[(3, 2, 5)] = numpy.sum(((x223 * x410) * x679))
result[(3, 2, 6)] = numpy.sum(((x374 * x427) * x692))
result[(3, 2, 7)] = numpy.sum(((x219 * x427) * x688))
result[(3, 2, 8)] = numpy.sum(((x222 * x683) * x713))
result[(3, 2, 9)] = numpy.sum(((x229 * x427) * x679))
result[(3, 2, 10)] = numpy.sum(((x465 * x696) * x718))
result[(3, 2, 11)] = numpy.sum(((x217 * x435) * x692))
result[(3, 2, 12)] = numpy.sum(((x223 * x435) * x688))
result[(3, 2, 13)] = numpy.sum(((x229 * x435) * x683))
result[(3, 2, 14)] = numpy.sum(((x232 * x435) * x685))
result[(3, 3, 0)] = numpy.sum(((x690 * x723) * x724))
result[(3, 3, 1)] = numpy.sum(((x240 * x56) * x726))
result[(3, 3, 2)] = numpy.sum(((x156 * x56) * x727))
result[(3, 3, 3)] = numpy.sum(((x126 * x729) * x730))
result[(3, 3, 4)] = numpy.sum(((x156 * x726) * x731))
result[(3, 3, 5)] = numpy.sum(((x249 * x46) * x723))
result[(3, 3, 6)] = numpy.sum(((x145 * x240) * x734))
result[(3, 3, 7)] = numpy.sum(((x156 * x729) * x736))
result[(3, 3, 8)] = numpy.sum(((x249 * x726) * x735))
result[(3, 3, 9)] = numpy.sum(((x145 * x487) * x723))
result[(3, 3, 10)] = numpy.sum(((x126 * x740) * x742))
result[(3, 3, 11)] = numpy.sum(((x156 * x734) * x743))
result[(3, 3, 12)] = numpy.sum(((x249 * x433) * x729))
result[(3, 3, 13)] = numpy.sum(((x433 * x487) * x726))
result[(3, 3, 14)] = numpy.sum(((x495 * x723) * x741))
result[(3, 4, 0)] = numpy.sum(((x272 * x700) * x724))
result[(3, 4, 1)] = numpy.sum(((x213 * x56) * x708))
result[(3, 4, 2)] = numpy.sum(((x219 * x56) * x699))
result[(3, 4, 3)] = numpy.sum(((x213 * x707) * x731))
result[(3, 4, 4)] = numpy.sum(((x269 * x46) * x702))
result[(3, 4, 5)] = numpy.sum(((x265 * x699) * x730))
result[(3, 4, 6)] = numpy.sum(((x145 * x498) * x712))
result[(3, 4, 7)] = numpy.sum(((x145 * x269) * x707))
result[(3, 4, 8)] = numpy.sum(((x145 * x500) * x702))
result[(3, 4, 9)] = numpy.sum(((x145 * x270) * x699))
result[(3, 4, 10)] = numpy.sum(((x433 * x501) * x717))
result[(3, 4, 11)] = numpy.sum(((x219 * x433) * x712))
result[(3, 4, 12)] = numpy.sum(((x266 * x433) * x707))
result[(3, 4, 13)] = numpy.sum(((x270 * x433) * x702))
result[(3, 4, 14)] = numpy.sum(((x274 * x433) * x700))
result[(3, 5, 0)] = numpy.sum(((x278 * x679) * x724))
result[(3, 5, 1)] = numpy.sum(((x279 * x56) * x683))
result[(3, 5, 2)] = numpy.sum(((x281 * x56) * x744))
result[(3, 5, 3)] = numpy.sum(((x333 * x46) * x688))
result[(3, 5, 4)] = numpy.sum(((x284 * x683) * x730))
result[(3, 5, 5)] = numpy.sum(((x288 * x46) * x679))
result[(3, 5, 6)] = numpy.sum(((x145 * x279) * x692))
result[(3, 5, 7)] = numpy.sum(((x145 * x285) * x688))
result[(3, 5, 8)] = numpy.sum(((x145 * x334) * x683))
result[(3, 5, 9)] = numpy.sum(((x145 * x292) * x744))
result[(3, 5, 10)] = numpy.sum(((x278 * x433) * x696))
result[(3, 5, 11)] = numpy.sum(((x281 * x692) * x743))
result[(3, 5, 12)] = numpy.sum(((x288 * x433) * x688))
result[(3, 5, 13)] = numpy.sum(((x292 * x683) * x743))
result[(3, 5, 14)] = numpy.sum(((x297 * x741) * x745))
result[(3, 6, 0)] = numpy.sum(((x430 * x746) * x747))
result[(3, 6, 1)] = numpy.sum(((x126 * x750) * x751))
result[(3, 6, 2)] = numpy.sum(((x156 * x746) * x751))
result[(3, 6, 3)] = numpy.sum(((x126 * x753) * x754))
result[(3, 6, 4)] = numpy.sum(((x156 * x21) * x755))
result[(3, 6, 5)] = numpy.sum(((x194 * x21) * x746))
result[(3, 6, 6)] = numpy.sum(((x126 * x757) * x758))
result[(3, 6, 7)] = numpy.sum(((x156 * x753) * x759))
result[(3, 6, 8)] = numpy.sum(((x714 * x750) * x758))
result[(3, 6, 9)] = numpy.sum(((x19 * x202) * x746))
result[(3, 6, 10)] = numpy.sum((x762 * x763))
result[(3, 6, 11)] = numpy.sum(((x15 * x184) * x757))
result[(3, 6, 12)] = numpy.sum(((x16 * x194) * x753))
result[(3, 6, 13)] = numpy.sum(((x16 * x202) * x750))
result[(3, 6, 14)] = numpy.sum(((x209 * x746) * x764))
result[(3, 7, 0)] = numpy.sum(((x501 * x723) * x747))
result[(3, 7, 1)] = numpy.sum(((x213 * x726) * x765))
result[(3, 7, 2)] = numpy.sum(((x219 * x510) * x723))
result[(3, 7, 3)] = numpy.sum(((x213 * x729) * x767))
result[(3, 7, 4)] = numpy.sum(((x21 * x269) * x726))
result[(3, 7, 5)] = numpy.sum(((x21 * x266) * x723))
result[(3, 7, 6)] = numpy.sum(((x213 * x734) * x759))
result[(3, 7, 7)] = numpy.sum(((x19 * x269) * x729))
result[(3, 7, 8)] = numpy.sum(((x19 * x500) * x726))
result[(3, 7, 9)] = numpy.sum(((x19 * x270) * x723))
result[(3, 7, 10)] = numpy.sum((((x134 * x211) * x740) * x763))
result[(3, 7, 11)] = numpy.sum(((x16 * x219) * x734))
result[(3, 7, 12)] = numpy.sum(((x16 * x266) * x729))
result[(3, 7, 13)] = numpy.sum(((x16 * x270) * x726))
result[(3, 7, 14)] = numpy.sum(((x274 * x723) * x764))
result[(3, 8, 0)] = numpy.sum(((x331 * x700) * x747))
result[(3, 8, 1)] = numpy.sum(((x332 * x510) * x703))
result[(3, 8, 2)] = numpy.sum(((x281 * x699) * x765))
result[(3, 8, 3)] = numpy.sum(((x333 * x707) * x766))
result[(3, 8, 4)] = numpy.sum(((x21 * x533) * x702))
result[(3, 8, 5)] = numpy.sum(((x21 * x334) * x699))
result[(3, 8, 6)] = numpy.sum(((x332 * x712) * x758))
result[(3, 8, 7)] = numpy.sum(((x19 * x533) * x707))
result[(3, 8, 8)] = numpy.sum(((x287 * x702) * x768))
result[(3, 8, 9)] = numpy.sum(((x292 * x699) * x759))
result[(3, 8, 10)] = numpy.sum(((x331 * x717) * x764))
result[(3, 8, 11)] = numpy.sum(((x281 * x712) * x769))
result[(3, 8, 12)] = numpy.sum(((x16 * x334) * x707))
result[(3, 8, 13)] = numpy.sum(((x16 * x292) * x708))
result[(3, 8, 14)] = numpy.sum((((x134 * x16) * x297) * x700))
result[(3, 9, 0)] = numpy.sum(((x336 * x680) * x747))
result[(3, 9, 1)] = numpy.sum(((x337 * x510) * x683))
result[(3, 9, 2)] = numpy.sum(((x341 * x510) * x679))
result[(3, 9, 3)] = numpy.sum(((x21 * x384) * x688))
result[(3, 9, 4)] = numpy.sum(((x21 * x342) * x683))
result[(3, 9, 5)] = numpy.sum(((x21 * x345) * x679))
result[(3, 9, 6)] = numpy.sum(((x19 * x337) * x692))
result[(3, 9, 7)] = numpy.sum(((x19 * x342) * x688))
result[(3, 9, 8)] = numpy.sum(((x344 * x683) * x759))
result[(3, 9, 9)] = numpy.sum(((x349 * x679) * x758))
result[(3, 9, 10)] = numpy.sum(((x336 * x696) * x764))
result[(3, 9, 11)] = numpy.sum(((x16 * x341) * x692))
result[(3, 9, 12)] = numpy.sum(((x16 * x345) * x688))
result[(3, 9, 13)] = numpy.sum(((x349 * x683) * x770))
result[(3, 9, 14)] = numpy.sum(((x16 * x351) * x685))
result[(3, 10, 0)] = numpy.sum(((x155 * x771) * x772))
result[(3, 10, 1)] = numpy.sum(((x155 * x773) * x774))
result[(3, 10, 2)] = numpy.sum(((x361 * x772) * x774))
result[(3, 10, 3)] = numpy.sum(((x126 * x775) * x777))
result[(3, 10, 4)] = numpy.sum(((x431 * x538) * x773))
result[(3, 10, 5)] = numpy.sum(((x140 * x538) * x772))
result[(3, 10, 6)] = numpy.sum((x778 * x779))
result[(3, 10, 7)] = numpy.sum((((x116 * x548) * x775) * x780))
result[(3, 10, 8)] = numpy.sum(((x160 * x773) * x781))
result[(3, 10, 9)] = numpy.sum(((x163 * x772) * x781))
result[(3, 10, 10)] = numpy.sum((x548 * ((x0 * (((((2.0 * x524) + (2.0 * x525)) + (7.0 * x738)) + (3.0 * x739)) + (4.0 * x756))) + (x175 * x761))))
result[(3, 10, 11)] = numpy.sum((x551 * x779))
result[(3, 10, 12)] = numpy.sum(((x140 * x775) * x8))
result[(3, 10, 13)] = numpy.sum(((x163 * x773) * x782))
result[(3, 10, 14)] = numpy.sum(((x174 * x772) * x782))
result[(3, 11, 0)] = numpy.sum(((x465 * x746) * x783))
result[(3, 11, 1)] = numpy.sum(((x213 * x750) * x784))
result[(3, 11, 2)] = numpy.sum(((x217 * x539) * x746))
result[(3, 11, 3)] = numpy.sum(((x213 * x753) * x785))
result[(3, 11, 4)] = numpy.sum(((x219 * x538) * x750))
result[(3, 11, 5)] = numpy.sum(((x223 * x538) * x746))
result[(3, 11, 6)] = numpy.sum(((x212 * x757) * x786))
result[(3, 11, 7)] = numpy.sum(((x11 * x219) * x753))
result[(3, 11, 8)] = numpy.sum(((x11 * x222) * x755))
result[(3, 11, 9)] = numpy.sum(((x11 * x229) * x746))
result[(3, 11, 10)] = numpy.sum(((x211 * x548) * x762))
result[(3, 11, 11)] = numpy.sum(((x217 * x757) * x8))
result[(3, 11, 12)] = numpy.sum(((x223 * x753) * x8))
result[(3, 11, 13)] = numpy.sum(((x229 * x750) * x8))
result[(3, 11, 14)] = numpy.sum(((x232 * x746) * x787))
result[(3, 12, 0)] = numpy.sum(((x278 * x723) * x771))
result[(3, 12, 1)] = numpy.sum(((x279 * x539) * x726))
result[(3, 12, 2)] = numpy.sum(((x281 * x723) * x788))
result[(3, 12, 3)] = numpy.sum(((x333 * x538) * x729))
result[(3, 12, 4)] = numpy.sum(((x284 * x726) * x789))
result[(3, 12, 5)] = numpy.sum(((x288 * x538) * x723))
result[(3, 12, 6)] = numpy.sum(((x11 * x279) * x734))
result[(3, 12, 7)] = numpy.sum(((x11 * x285) * x729))
result[(3, 12, 8)] = numpy.sum(((x11 * x334) * x726))
result[(3, 12, 9)] = numpy.sum(((x11 * x292) * x727))
result[(3, 12, 10)] = numpy.sum(((x278 * x740) * x8))
result[(3, 12, 11)] = numpy.sum(((x281 * x734) * x790))
result[(3, 12, 12)] = numpy.sum(((x288 * x729) * x8))
result[(3, 12, 13)] = numpy.sum(((x292 * x726) * x790))
result[(3, 12, 14)] = numpy.sum((((x127 * x297) * x723) * x791))
result[(3, 13, 0)] = numpy.sum(((x336 * x700) * x771))
result[(3, 13, 1)] = numpy.sum(((x337 * x539) * x702))
result[(3, 13, 2)] = numpy.sum(((x341 * x539) * x699))
result[(3, 13, 3)] = numpy.sum(((x384 * x538) * x707))
result[(3, 13, 4)] = numpy.sum(((x342 * x538) * x702))
result[(3, 13, 5)] = numpy.sum(((x345 * x538) * x699))
result[(3, 13, 6)] = numpy.sum(((x11 * x337) * x712))
result[(3, 13, 7)] = numpy.sum(((x11 * x342) * x707))
result[(3, 13, 8)] = numpy.sum(((x11 * x344) * x708))
result[(3, 13, 9)] = numpy.sum(((x11 * x349) * x704))
result[(3, 13, 10)] = numpy.sum(((x336 * x717) * x782))
result[(3, 13, 11)] = numpy.sum(((x341 * x712) * x8))
result[(3, 13, 12)] = numpy.sum(((x345 * x707) * x8))
result[(3, 13, 13)] = numpy.sum(((x349 * x703) * x8))
result[(3, 13, 14)] = numpy.sum(((x351 * x700) * x792))
result[(3, 14, 0)] = numpy.sum(((x386 * x680) * x771))
result[(3, 14, 1)] = numpy.sum(((x387 * x539) * x684))
result[(3, 14, 2)] = numpy.sum(((x389 * x539) * x685))
result[(3, 14, 3)] = numpy.sum(((x390 * x688) * x776))
result[(3, 14, 4)] = numpy.sum(((x391 * x538) * x684))
result[(3, 14, 5)] = numpy.sum(((x393 * x745) * x793))
result[(3, 14, 6)] = numpy.sum(((x387 * x692) * x781))
result[(3, 14, 7)] = numpy.sum(((x391 * x688) * x781))
result[(3, 14, 8)] = numpy.sum(((x11 * x393) * x691))
result[(3, 14, 9)] = numpy.sum(((x11 * x395) * x685))
result[(3, 14, 10)] = numpy.sum(((x386 * x696) * x782))
result[(3, 14, 11)] = numpy.sum(((x389 * x692) * x787))
result[(3, 14, 12)] = numpy.sum(((x394 * x688) * x791))
result[(3, 14, 13)] = numpy.sum(((x395 * x684) * x792))
result[(3, 14, 14)] = numpy.sum(((x396 * x680) * x8))
result[(4, 0, 0)] = numpy.sum((((x109 * x397) * x567) * x677))
result[(4, 0, 1)] = numpy.sum(((x407 * x644) * x681))
result[(4, 0, 2)] = numpy.sum(((x571 * x681) * x794))
result[(4, 0, 3)] = numpy.sum(((x417 * x573) * x795))
result[(4, 0, 4)] = numpy.sum(((x418 * x570) * x689))
result[(4, 0, 5)] = numpy.sum((((x104 * x413) * x578) * x689))
result[(4, 0, 6)] = numpy.sum(((x579 * x694) * x796))
result[(4, 0, 7)] = numpy.sum(((x416 * x574) * x694))
result[(4, 0, 8)] = numpy.sum(((x418 * x577) * x694))
result[(4, 0, 9)] = numpy.sum(((x432 * x586) * x694))
result[(4, 0, 10)] = numpy.sum(((x438 * x579) * x695))
result[(4, 0, 11)] = numpy.sum(((x422 * x571) * x697))
result[(4, 0, 12)] = numpy.sum(((x417 * x578) * x695))
result[(4, 0, 13)] = numpy.sum(((x407 * x584) * x697))
result[(4, 0, 14)] = numpy.sum(((x432 * x588) * x695))
result[(4, 1, 0)] = numpy.sum(((x401 * x443) * x644))
result[(4, 1, 1)] = numpy.sum(((x446 * x573) * x58))
result[(4, 1, 2)] = numpy.sum(((x447 * x570) * x58))
result[(4, 1, 3)] = numpy.sum(((x410 * x450) * x612))
result[(4, 1, 4)] = numpy.sum(((x410 * x451) * x570))
result[(4, 1, 5)] = numpy.sum(((x410 * x442) * x590))
result[(4, 1, 6)] = numpy.sum(((x427 * x456) * x591))
result[(4, 1, 7)] = numpy.sum(((x450 * x570) * x713))
result[(4, 1, 8)] = numpy.sum(((x427 * x451) * x577))
result[(4, 1, 9)] = numpy.sum(((x427 * x447) * x584))
result[(4, 1, 10)] = numpy.sum(((x460 * x579) * x718))
result[(4, 1, 11)] = numpy.sum(((x456 * x570) * x719))
result[(4, 1, 12)] = numpy.sum(((x435 * x450) * x590))
result[(4, 1, 13)] = numpy.sum(((x445 * x584) * x719))
result[(4, 1, 14)] = numpy.sum(((x443 * x588) * x718))
result[(4, 2, 0)] = numpy.sum(((x401 * x595) * x794))
result[(4, 2, 1)] = numpy.sum(((x462 * x58) * x594))
result[(4, 2, 2)] = numpy.sum(((x413 * x58) * x599))
result[(4, 2, 3)] = numpy.sum(((x410 * x463) * x594))
result[(4, 2, 4)] = numpy.sum(((x410 * x598) * x797))
result[(4, 2, 5)] = numpy.sum(((x410 * x502) * x603))
result[(4, 2, 6)] = numpy.sum(((x422 * x427) * x596))
result[(4, 2, 7)] = numpy.sum(((x416 * x427) * x600))
result[(4, 2, 8)] = numpy.sum(((x427 * x603) * x797))
result[(4, 2, 9)] = numpy.sum((((x182 * x413) * x427) * x608))
result[(4, 2, 10)] = numpy.sum(((x438 * x595) * x718))
result[(4, 2, 11)] = numpy.sum(((x422 * x598) * x719))
result[(4, 2, 12)] = numpy.sum(((x435 * x463) * x603))
result[(4, 2, 13)] = numpy.sum(((x435 * x462) * x608))
result[(4, 2, 14)] = numpy.sum(((x432 * x611) * x718))
result[(4, 3, 0)] = numpy.sum(((x470 * x614) * x724))
result[(4, 3, 1)] = numpy.sum(((x473 * x56) * x612))
result[(4, 3, 2)] = numpy.sum(((x474 * x56) * x570))
result[(4, 3, 3)] = numpy.sum(((x476 * x573) * x730))
result[(4, 3, 4)] = numpy.sum(((x473 * x570) * x731))
result[(4, 3, 5)] = numpy.sum(((x46 * x469) * x613))
result[(4, 3, 6)] = numpy.sum(((x145 * x484) * x612))
result[(4, 3, 7)] = numpy.sum(((x486 * x570) * x735))
result[(4, 3, 8)] = numpy.sum(((x473 * x613) * x735))
result[(4, 3, 9)] = numpy.sum(((x145 * x474) * x584))
result[(4, 3, 10)] = numpy.sum(((x492 * x573) * x742))
result[(4, 3, 11)] = numpy.sum(((x484 * x570) * x743))
result[(4, 3, 12)] = numpy.sum(((x433 * x476) * x613))
result[(4, 3, 13)] = numpy.sum(((x473 * x584) * x743))
result[(4, 3, 14)] = numpy.sum(((x469 * x588) * x742))
result[(4, 4, 0)] = numpy.sum(((x496 * x594) * x724))
result[(4, 4, 1)] = numpy.sum(((x445 * x56) * x645))
result[(4, 4, 2)] = numpy.sum(((x532 * x56) * x598))
result[(4, 4, 3)] = numpy.sum(((x450 * x594) * x731))
result[(4, 4, 4)] = numpy.sum(((x445 * x46) * x617))
result[(4, 4, 5)] = numpy.sum(((x442 * x603) * x731))
result[(4, 4, 6)] = numpy.sum(((x145 * x456) * x645))
result[(4, 4, 7)] = numpy.sum(((x145 * x450) * x617))
result[(4, 4, 8)] = numpy.sum(((x145 * x603) * x798))
result[(4, 4, 9)] = numpy.sum(((x145 * x532) * x608))
result[(4, 4, 10)] = numpy.sum(((x433 * x460) * x615))
result[(4, 4, 11)] = numpy.sum(((x433 * x456) * x600))
result[(4, 4, 12)] = numpy.sum(((x433 * x497) * x619))
result[(4, 4, 13)] = numpy.sum(((x433 * x451) * x608))
result[(4, 4, 14)] = numpy.sum(((x433 * x496) * x611))
result[(4, 5, 0)] = numpy.sum(((x413 * x665) * x724))
result[(4, 5, 1)] = numpy.sum(((x406 * x56) * x626))
result[(4, 5, 2)] = numpy.sum(((x502 * x56) * x628))
result[(4, 5, 3)] = numpy.sum(((x46 * x503) * x623))
result[(4, 5, 4)] = numpy.sum(((x406 * x628) * x731))
result[(4, 5, 5)] = numpy.sum(((x413 * x630) * x730))
result[(4, 5, 6)] = numpy.sum(((x145 * x422) * x626))
result[(4, 5, 7)] = numpy.sum(((x503 * x628) * x735))
result[(4, 5, 8)] = numpy.sum(((x406 * x631) * x735))
result[(4, 5, 9)] = numpy.sum(((x145 * x502) * x637))
result[(4, 5, 10)] = numpy.sum(((x438 * x624) * x741))
result[(4, 5, 11)] = numpy.sum(((x422 * x628) * x743))
result[(4, 5, 12)] = numpy.sum(((x433 * x503) * x630))
result[(4, 5, 13)] = numpy.sum(((x406 * x637) * x743))
result[(4, 5, 14)] = numpy.sum(((x413 * x643) * x742))
result[(4, 6, 0)] = numpy.sum(((x553 * x579) * x747))
result[(4, 6, 1)] = numpy.sum(((x515 * x573) * x751))
result[(4, 6, 2)] = numpy.sum(((x510 * x516) * x570))
result[(4, 6, 3)] = numpy.sum(((x518 * x573) * x754))
result[(4, 6, 4)] = numpy.sum(((x21 * x519) * x589))
result[(4, 6, 5)] = numpy.sum(((x21 * x508) * x590))
result[(4, 6, 6)] = numpy.sum(((x521 * x573) * x758))
result[(4, 6, 7)] = numpy.sum(((x518 * x570) * x759))
result[(4, 6, 8)] = numpy.sum(((x519 * x577) * x758))
result[(4, 6, 9)] = numpy.sum(((x508 * x584) * x758))
result[(4, 6, 10)] = numpy.sum(((x556 * x567) * x763))
result[(4, 6, 11)] = numpy.sum(((x16 * x521) * x589))
result[(4, 6, 12)] = numpy.sum(((x16 * x518) * x590))
result[(4, 6, 13)] = numpy.sum(((x515 * x584) * x770))
result[(4, 6, 14)] = numpy.sum(((x553 * x588) * x764))
result[(4, 7, 0)] = numpy.sum(((x469 * x615) * x747))
result[(4, 7, 1)] = numpy.sum(((x473 * x510) * x645))
result[(4, 7, 2)] = numpy.sum(((x469 * x510) * x600))
result[(4, 7, 3)] = numpy.sum(((x486 * x594) * x766))
result[(4, 7, 4)] = numpy.sum(((x21 * x473) * x617))
result[(4, 7, 5)] = numpy.sum(((x469 * x619) * x766))
result[(4, 7, 6)] = numpy.sum(((x19 * x484) * x645))
result[(4, 7, 7)] = numpy.sum(((x19 * x476) * x617))
result[(4, 7, 8)] = numpy.sum(((x473 * x603) * x768))
result[(4, 7, 9)] = numpy.sum(((x469 * x608) * x759))
result[(4, 7, 10)] = numpy.sum(((x16 * x492) * x615))
result[(4, 7, 11)] = numpy.sum(((x16 * x484) * x600))
result[(4, 7, 12)] = numpy.sum((((x16 * x246) * x476) * x619))
result[(4, 7, 13)] = numpy.sum(((x473 * x608) * x769))
result[(4, 7, 14)] = numpy.sum(((x469 * x611) * x799))
result[(4, 8, 0)] = numpy.sum(((x496 * x623) * x747))
result[(4, 8, 1)] = numpy.sum(((x451 * x510) * x623))
result[(4, 8, 2)] = numpy.sum(((x510 * x532) * x628))
result[(4, 8, 3)] = numpy.sum(((x450 * x623) * x767))
result[(4, 8, 4)] = numpy.sum(((x21 * x628) * x798))
result[(4, 8, 5)] = numpy.sum(((x442 * x631) * x766))
result[(4, 8, 6)] = numpy.sum(((x456 * x623) * x759))
result[(4, 8, 7)] = numpy.sum(((x450 * x628) * x768))
result[(4, 8, 8)] = numpy.sum(((x445 * x630) * x768))
result[(4, 8, 9)] = numpy.sum(((x442 * x637) * x759))
result[(4, 8, 10)] = numpy.sum(((x460 * x623) * x799))
result[(4, 8, 11)] = numpy.sum(((x456 * x628) * x769))
result[(4, 8, 12)] = numpy.sum(((x16 * x497) * x631))
result[(4, 8, 13)] = numpy.sum(((x16 * x451) * x637))
result[(4, 8, 14)] = numpy.sum(((x16 * x496) * x643))
result[(4, 9, 0)] = numpy.sum(((x432 * x666) * x747))
result[(4, 9, 1)] = numpy.sum(((x462 * x510) * x649))
result[(4, 9, 2)] = numpy.sum(((x413 * x653) * x751))
result[(4, 9, 3)] = numpy.sum(((x21 * x463) * x649))
result[(4, 9, 4)] = numpy.sum(((x21 * x653) * x797))
result[(4, 9, 5)] = numpy.sum(((x413 * x656) * x754))
result[(4, 9, 6)] = numpy.sum(((x422 * x649) * x758))
result[(4, 9, 7)] = numpy.sum(((x416 * x653) * x759))
result[(4, 9, 8)] = numpy.sum(((x19 * x656) * x797))
result[(4, 9, 9)] = numpy.sum(((x413 * x658) * x758))
result[(4, 9, 10)] = numpy.sum(((x438 * x666) * x764))
result[(4, 9, 11)] = numpy.sum(((x422 * x653) * x770))
result[(4, 9, 12)] = numpy.sum(((x16 * x463) * x656))
result[(4, 9, 13)] = numpy.sum(((x16 * x462) * x658))
result[(4, 9, 14)] = numpy.sum(((x397 * x667) * x800))
result[(4, 10, 0)] = numpy.sum(((x537 * x579) * x771))
result[(4, 10, 1)] = numpy.sum(((x541 * x579) * x774))
result[(4, 10, 2)] = numpy.sum(((x537 * x571) * x774))
result[(4, 10, 3)] = numpy.sum(((x543 * x573) * x777))
result[(4, 10, 4)] = numpy.sum(((x538 * x541) * x574))
result[(4, 10, 5)] = numpy.sum(((x537 * x578) * x776))
result[(4, 10, 6)] = numpy.sum((((x545 * x548) * x567) * x778))
result[(4, 10, 7)] = numpy.sum(((x11 * x543) * x574))
result[(4, 10, 8)] = numpy.sum(((x541 * x577) * x801))
result[(4, 10, 9)] = numpy.sum(((x537 * x586) * x781))
result[(4, 10, 10)] = numpy.sum((x549 * x567))
result[(4, 10, 11)] = numpy.sum(((x545 * x571) * x792))
result[(4, 10, 12)] = numpy.sum(((x543 * x578) * x791))
result[(4, 10, 13)] = numpy.sum(((x541 * x584) * x787))
result[(4, 10, 14)] = numpy.sum(((x537 * x588) * x782))
result[(4, 11, 0)] = numpy.sum(((x508 * x595) * x783))
result[(4, 11, 1)] = numpy.sum(((x515 * x539) * x596))
result[(4, 11, 2)] = numpy.sum(((x516 * x539) * x598))
result[(4, 11, 3)] = numpy.sum(((x518 * x594) * x785))
result[(4, 11, 4)] = numpy.sum(((x519 * x538) * x599))
result[(4, 11, 5)] = numpy.sum(((x508 * x603) * x785))
result[(4, 11, 6)] = numpy.sum(((x11 * x521) * x596))
result[(4, 11, 7)] = numpy.sum(((x11 * x518) * x600))
result[(4, 11, 8)] = numpy.sum(((x519 * x603) * x802))
result[(4, 11, 9)] = numpy.sum(((x11 * x516) * x608))
result[(4, 11, 10)] = numpy.sum(((x526 * x595) * x792))
result[(4, 11, 11)] = numpy.sum(((x521 * x599) * x8))
result[(4, 11, 12)] = numpy.sum(((x518 * x603) * x790))
result[(4, 11, 13)] = numpy.sum(((x515 * x608) * x803))
result[(4, 11, 14)] = numpy.sum(((x508 * x611) * x787))
result[(4, 12, 0)] = numpy.sum(((x470 * x624) * x771))
result[(4, 12, 1)] = numpy.sum(((x473 * x539) * x626))
result[(4, 12, 2)] = numpy.sum(((x474 * x539) * x628))
result[(4, 12, 3)] = numpy.sum(((x476 * x623) * x789))
result[(4, 12, 4)] = numpy.sum(((x478 * x628) * x789))
result[(4, 12, 5)] = numpy.sum(((x469 * x630) * x789))
result[(4, 12, 6)] = numpy.sum(((x11 * x484) * x626))
result[(4, 12, 7)] = numpy.sum((((x11 * x246) * x486) * x628))
result[(4, 12, 8)] = numpy.sum(((x11 * x478) * x631))
result[(4, 12, 9)] = numpy.sum(((x11 * x474) * x637))
result[(4, 12, 10)] = numpy.sum(((x492 * x624) * x804))
result[(4, 12, 11)] = numpy.sum(((x484 * x628) * x790))
result[(4, 12, 12)] = numpy.sum(((x476 * x631) * x8))
result[(4, 12, 13)] = numpy.sum(((x473 * x637) * x790))
result[(4, 12, 14)] = numpy.sum(((x470 * x643) * x791))
result[(4, 13, 0)] = numpy.sum(((x443 * x649) * x783))
result[(4, 13, 1)] = numpy.sum(((x445 * x649) * x784))
result[(4, 13, 2)] = numpy.sum(((x447 * x539) * x653))
result[(4, 13, 3)] = numpy.sum(((x450 * x649) * x785))
result[(4, 13, 4)] = numpy.sum(((x451 * x538) * x653))
result[(4, 13, 5)] = numpy.sum(((x442 * x656) * x785))
result[(4, 13, 6)] = numpy.sum(((x11 * x456) * x650))
result[(4, 13, 7)] = numpy.sum(((x11 * x450) * x654))
result[(4, 13, 8)] = numpy.sum(((x11 * x451) * x656))
result[(4, 13, 9)] = numpy.sum(((x11 * x447) * x658))
result[(4, 13, 10)] = numpy.sum(((x460 * x649) * x787))
result[(4, 13, 11)] = numpy.sum(((x456 * x653) * x803))
result[(4, 13, 12)] = numpy.sum(((x450 * x656) * x790))
result[(4, 13, 13)] = numpy.sum(((x446 * x658) * x8))
result[(4, 13, 14)] = numpy.sum(((x443 * x661) * x792))
result[(4, 14, 0)] = numpy.sum(((x432 * x668) * x771))
result[(4, 14, 1)] = numpy.sum(((x407 * x668) * x774))
result[(4, 14, 2)] = numpy.sum(((x432 * x669) * x774))
result[(4, 14, 3)] = numpy.sum(((x416 * x670) * x776))
result[(4, 14, 4)] = numpy.sum(((x418 * x538) * x669))
result[(4, 14, 5)] = numpy.sum(((x413 * x672) * x777))
result[(4, 14, 6)] = numpy.sum(((x668 * x781) * x796))
result[(4, 14, 7)] = numpy.sum(((x416 * x669) * x801))
result[(4, 14, 8)] = numpy.sum(((x11 * x418) * x672))
result[(4, 14, 9)] = numpy.sum((((x397 * x565) * x673) * x778))
result[(4, 14, 10)] = numpy.sum(((x438 * x668) * x782))
result[(4, 14, 11)] = numpy.sum(((x422 * x669) * x787))
result[(4, 14, 12)] = numpy.sum(((x417 * x672) * x804))
result[(4, 14, 13)] = numpy.sum(((x407 * x673) * x792))
result[(4, 14, 14)] = numpy.sum((x397 * x675))
result[(5, 0, 0)] = numpy.sum(((x128 * x677) * x807))
result[(5, 0, 1)] = numpy.sum(((x159 * x681) * x808))
result[(5, 0, 2)] = numpy.sum(((x572 * x681) * x811))
result[(5, 0, 3)] = numpy.sum(((x133 * x689) * x806))
result[(5, 0, 4)] = numpy.sum(((x159 * x689) * x812))
result[(5, 0, 5)] = numpy.sum(((x392 * x795) * x815))
result[(5, 0, 6)] = numpy.sum(((x154 * x694) * x807))
result[(5, 0, 7)] = numpy.sum(((x157 * x694) * x811))
result[(5, 0, 8)] = numpy.sum(((x580 * x694) * x815))
result[(5, 0, 9)] = numpy.sum(((x585 * x694) * x816))
result[(5, 0, 10)] = numpy.sum(((x166 * x695) * x807))
result[(5, 0, 11)] = numpy.sum(((x154 * x695) * x811))
result[(5, 0, 12)] = numpy.sum(((x133 * x695) * x815))
result[(5, 0, 13)] = numpy.sum(((x388 * x697) * x816))
result[(5, 0, 14)] = numpy.sum(((x164 * x695) * x817))
result[(5, 1, 0)] = numpy.sum(((x177 * x401) * x808))
result[(5, 1, 1)] = numpy.sum(((x181 * x58) * x806))
result[(5, 1, 2)] = numpy.sum(((x385 * x58) * x810))
result[(5, 1, 3)] = numpy.sum(((x191 * x410) * x806))
result[(5, 1, 4)] = numpy.sum(((x193 * x410) * x810))
result[(5, 1, 5)] = numpy.sum(((x177 * x720) * x815))
result[(5, 1, 6)] = numpy.sum(((x198 * x427) * x818))
result[(5, 1, 7)] = numpy.sum(((x188 * x713) * x810))
result[(5, 1, 8)] = numpy.sum(((x193 * x427) * x815))
result[(5, 1, 9)] = numpy.sum(((x385 * x427) * x816))
result[(5, 1, 10)] = numpy.sum(((x204 * x718) * x807))
result[(5, 1, 11)] = numpy.sum(((x198 * x719) * x810))
result[(5, 1, 12)] = numpy.sum(((x191 * x435) * x815))
result[(5, 1, 13)] = numpy.sum(((x181 * x435) * x816))
result[(5, 1, 14)] = numpy.sum(((x592 * x718) * x817))
result[(5, 2, 0)] = numpy.sum(((x401 * x572) * x821))
result[(5, 2, 1)] = numpy.sum(((x159 * x58) * x822))
result[(5, 2, 2)] = numpy.sum(((x58 * x609) * x824))
result[(5, 2, 3)] = numpy.sum(((x218 * x410) * x820))
result[(5, 2, 4)] = numpy.sum(((x410 * x824) * x825))
result[(5, 2, 5)] = numpy.sum(((x282 * x410) * x828))
result[(5, 2, 6)] = numpy.sum(((x224 * x427) * x820))
result[(5, 2, 7)] = numpy.sum(((x131 * x713) * x824))
result[(5, 2, 8)] = numpy.sum(((x159 * x713) * x828))
result[(5, 2, 9)] = numpy.sum(((x427 * x609) * x832))
result[(5, 2, 10)] = numpy.sum(((x230 * x435) * x821))
result[(5, 2, 11)] = numpy.sum(((x224 * x435) * x824))
result[(5, 2, 12)] = numpy.sum(((x218 * x435) * x828))
result[(5, 2, 13)] = numpy.sum(((x159 * x719) * x832))
result[(5, 2, 14)] = numpy.sum(((x164 * x718) * x835))
result[(5, 3, 0)] = numpy.sum(((x237 * x724) * x806))
result[(5, 3, 1)] = numpy.sum(((x239 * x56) * x836))
result[(5, 3, 2)] = numpy.sum(((x241 * x56) * x810))
result[(5, 3, 3)] = numpy.sum(((x243 * x730) * x806))
result[(5, 3, 4)] = numpy.sum(((x247 * x730) * x810))
result[(5, 3, 5)] = numpy.sum(((x235 * x730) * x815))
result[(5, 3, 6)] = numpy.sum(((x145 * x252) * x836))
result[(5, 3, 7)] = numpy.sum(((x145 * x326) * x810))
result[(5, 3, 8)] = numpy.sum(((x145 * x248) * x815))
result[(5, 3, 9)] = numpy.sum(((x145 * x241) * x816))
result[(5, 3, 10)] = numpy.sum(((x258 * x742) * x806))
result[(5, 3, 11)] = numpy.sum(((x252 * x743) * x810))
result[(5, 3, 12)] = numpy.sum(((x245 * x433) * x815))
result[(5, 3, 13)] = numpy.sum(((x239 * x743) * x816))
result[(5, 3, 14)] = numpy.sum(((x237 * x433) * x817))
result[(5, 4, 0)] = numpy.sum(((x177 * x724) * x837))
result[(5, 4, 1)] = numpy.sum(((x193 * x56) * x820))
result[(5, 4, 2)] = numpy.sum(((x56 * x618) * x824))
result[(5, 4, 3)] = numpy.sum(((x262 * x730) * x820))
result[(5, 4, 4)] = numpy.sum(((x264 * x46) * x824))
result[(5, 4, 5)] = numpy.sum(((x177 * x731) * x828))
result[(5, 4, 6)] = numpy.sum(((x145 * x268) * x820))
result[(5, 4, 7)] = numpy.sum(((x145 * x188) * x838))
result[(5, 4, 8)] = numpy.sum(((x145 * x264) * x828))
result[(5, 4, 9)] = numpy.sum(((x145 * x618) * x832))
result[(5, 4, 10)] = numpy.sum(((x204 * x433) * x837))
result[(5, 4, 11)] = numpy.sum(((x268 * x433) * x824))
result[(5, 4, 12)] = numpy.sum(((x263 * x433) * x828))
result[(5, 4, 13)] = numpy.sum(((x193 * x433) * x832))
result[(5, 4, 14)] = numpy.sum(((x433 * x620) * x835))
result[(5, 5, 0)] = numpy.sum(((x625 * x724) * x842))
result[(5, 5, 1)] = numpy.sum(((x159 * x56) * x843))
result[(5, 5, 2)] = numpy.sum(((x282 * x56) * x845))
result[(5, 5, 3)] = numpy.sum(((x283 * x46) * x841))
result[(5, 5, 4)] = numpy.sum(((x159 * x731) * x845))
result[(5, 5, 5)] = numpy.sum(((x128 * x730) * x847))
result[(5, 5, 6)] = numpy.sum(((x145 * x638) * x841))
result[(5, 5, 7)] = numpy.sum(((x283 * x735) * x845))
result[(5, 5, 8)] = numpy.sum(((x159 * x736) * x847))
result[(5, 5, 9)] = numpy.sum(((x145 * x282) * x850))
result[(5, 5, 10)] = numpy.sum(((x293 * x433) * x842))
result[(5, 5, 11)] = numpy.sum(((x433 * x638) * x845))
result[(5, 5, 12)] = numpy.sum(((x283 * x433) * x847))
result[(5, 5, 13)] = numpy.sum(((x159 * x743) * x850))
result[(5, 5, 14)] = numpy.sum(((x128 * x742) * x854))
result[(5, 6, 0)] = numpy.sum(((x302 * x747) * x807))
result[(5, 6, 1)] = numpy.sum(((x305 * x510) * x818))
result[(5, 6, 2)] = numpy.sum(((x307 * x510) * x810))
result[(5, 6, 3)] = numpy.sum(((x21 * x309) * x836))
result[(5, 6, 4)] = numpy.sum(((x21 * x311) * x810))
result[(5, 6, 5)] = numpy.sum(((x301 * x754) * x815))
result[(5, 6, 6)] = numpy.sum(((x313 * x758) * x806))
result[(5, 6, 7)] = numpy.sum(((x309 * x759) * x810))
result[(5, 6, 8)] = numpy.sum(((x310 * x758) * x815))
result[(5, 6, 9)] = numpy.sum(((x19 * x307) * x816))
result[(5, 6, 10)] = numpy.sum(((x16 * x318) * x808))
result[(5, 6, 11)] = numpy.sum(((x313 * x770) * x810))
result[(5, 6, 12)] = numpy.sum(((x16 * x375) * x815))
result[(5, 6, 13)] = numpy.sum(((x305 * x770) * x816))
result[(5, 6, 14)] = numpy.sum(((x302 * x764) * x817))
result[(5, 7, 0)] = numpy.sum(((x235 * x747) * x837))
result[(5, 7, 1)] = numpy.sum(((x239 * x765) * x820))
result[(5, 7, 2)] = numpy.sum(((x325 * x751) * x824))
result[(5, 7, 3)] = numpy.sum(((x21 * x326) * x820))
result[(5, 7, 4)] = numpy.sum(((x21 * x239) * x838))
result[(5, 7, 5)] = numpy.sum(((x235 * x767) * x828))
result[(5, 7, 6)] = numpy.sum(((x252 * x759) * x820))
result[(5, 7, 7)] = numpy.sum(((x243 * x768) * x824))
result[(5, 7, 8)] = numpy.sum(((x239 * x768) * x828))
result[(5, 7, 9)] = numpy.sum(((x325 * x758) * x832))
result[(5, 7, 10)] = numpy.sum(((x16 * x258) * x837))
result[(5, 7, 11)] = numpy.sum(((x252 * x769) * x824))
result[(5, 7, 12)] = numpy.sum(((x16 * x326) * x828))
result[(5, 7, 13)] = numpy.sum(((x239 * x769) * x832))
result[(5, 7, 14)] = numpy.sum(((x235 * x799) * x835))
result[(5, 8, 0)] = numpy.sum(((x620 * x747) * x841))
result[(5, 8, 1)] = numpy.sum(((x193 * x510) * x841))
result[(5, 8, 2)] = numpy.sum(((x177 * x765) * x845))
result[(5, 8, 3)] = numpy.sum(((x21 * x263) * x841))
result[(5, 8, 4)] = numpy.sum(((x21 * x264) * x845))
result[(5, 8, 5)] = numpy.sum(((x177 * x767) * x847))
result[(5, 8, 6)] = numpy.sum(((x267 * x758) * x841))
result[(5, 8, 7)] = numpy.sum(((x188 * x768) * x845))
result[(5, 8, 8)] = numpy.sum(((x19 * x264) * x847))
result[(5, 8, 9)] = numpy.sum(((x177 * x759) * x850))
result[(5, 8, 10)] = numpy.sum(((x204 * x799) * x841))
result[(5, 8, 11)] = numpy.sum(((x16 * x268) * x845))
result[(5, 8, 12)] = numpy.sum(((x16 * x263) * x847))
result[(5, 8, 13)] = numpy.sum(((x16 * x193) * x850))
result[(5, 8, 14)] = numpy.sum((((x134 * x175) * x800) * x854))
result[(5, 9, 0)] = numpy.sum(((x585 * x747) * x855))
result[(5, 9, 1)] = numpy.sum(((x159 * x751) * x855))
result[(5, 9, 2)] = numpy.sum(((x128 * x751) * x858))
result[(5, 9, 3)] = numpy.sum(((x21 * x218) * x855))
result[(5, 9, 4)] = numpy.sum(((x21 * x825) * x858))
result[(5, 9, 5)] = numpy.sum(((x128 * x754) * x860))
result[(5, 9, 6)] = numpy.sum(((x19 * x224) * x855))
result[(5, 9, 7)] = numpy.sum(((x131 * x759) * x858))
result[(5, 9, 8)] = numpy.sum(((x159 * x759) * x860))
result[(5, 9, 9)] = numpy.sum(((x128 * x758) * x862))
result[(5, 9, 10)] = numpy.sum(((x230 * x764) * x855))
result[(5, 9, 11)] = numpy.sum(((x16 * x224) * x858))
result[(5, 9, 12)] = numpy.sum(((x16 * x218) * x860))
result[(5, 9, 13)] = numpy.sum(((x111 * x15) * x863))
result[(5, 9, 14)] = numpy.sum((x800 * x866))
result[(5, 10, 0)] = numpy.sum(((x352 * x771) * x807))
result[(5, 10, 1)] = numpy.sum(((x358 * x774) * x807))
result[(5, 10, 2)] = numpy.sum(((x360 * x539) * x811))
result[(5, 10, 3)] = numpy.sum(((x363 * x777) * x806))
result[(5, 10, 4)] = numpy.sum(((x365 * x538) * x811))
result[(5, 10, 5)] = numpy.sum(((x352 * x777) * x815))
result[(5, 10, 6)] = numpy.sum(((x11 * x366) * x808))
result[(5, 10, 7)] = numpy.sum(((x11 * x363) * x812))
result[(5, 10, 8)] = numpy.sum(((x365 * x781) * x815))
result[(5, 10, 9)] = numpy.sum(((x360 * x781) * x816))
result[(5, 10, 10)] = numpy.sum(((x370 * x8) * x807))
result[(5, 10, 11)] = numpy.sum(((x366 * x792) * x811))
result[(5, 10, 12)] = numpy.sum(((x364 * x804) * x815))
result[(5, 10, 13)] = numpy.sum(((x358 * x787) * x816))
result[(5, 10, 14)] = numpy.sum(((x352 * x782) * x817))
result[(5, 11, 0)] = numpy.sum(((x302 * x771) * x821))
result[(5, 11, 1)] = numpy.sum(((x305 * x784) * x820))
result[(5, 11, 2)] = numpy.sum(((x307 * x539) * x824))
result[(5, 11, 3)] = numpy.sum(((x309 * x785) * x820))
result[(5, 11, 4)] = numpy.sum(((x311 * x538) * x824))
result[(5, 11, 5)] = numpy.sum(((x301 * x785) * x828))
result[(5, 11, 6)] = numpy.sum(((x11 * x313) * x822))
result[(5, 11, 7)] = numpy.sum(((x309 * x824) * x867))
result[(5, 11, 8)] = numpy.sum(((x11 * x311) * x828))
result[(5, 11, 9)] = numpy.sum(((x11 * x307) * x832))
result[(5, 11, 10)] = numpy.sum(((x318 * x792) * x821))
result[(5, 11, 11)] = numpy.sum(((x313 * x803) * x824))
result[(5, 11, 12)] = numpy.sum(((x309 * x790) * x828))
result[(5, 11, 13)] = numpy.sum(((x305 * x803) * x832))
result[(5, 11, 14)] = numpy.sum(((x302 * x782) * x835))
result[(5, 12, 0)] = numpy.sum(((x237 * x771) * x841))
result[(5, 12, 1)] = numpy.sum(((x239 * x788) * x841))
result[(5, 12, 2)] = numpy.sum(((x241 * x539) * x845))
result[(5, 12, 3)] = numpy.sum(((x243 * x789) * x841))
result[(5, 12, 4)] = numpy.sum(((x247 * x789) * x845))
result[(5, 12, 5)] = numpy.sum(((x235 * x789) * x847))
result[(5, 12, 6)] = numpy.sum(((x11 * x252) * x843))
result[(5, 12, 7)] = numpy.sum(((x11 * x326) * x845))
result[(5, 12, 8)] = numpy.sum(((x11 * x248) * x847))
result[(5, 12, 9)] = numpy.sum(((x11 * x241) * x850))
result[(5, 12, 10)] = numpy.sum(((x258 * x804) * x842))
result[(5, 12, 11)] = numpy.sum(((x252 * x790) * x845))
result[(5, 12, 12)] = numpy.sum(((x245 * x8) * x847))
result[(5, 12, 13)] = numpy.sum(((x239 * x790) * x850))
result[(5, 12, 14)] = numpy.sum(((x237 * x8) * x854))
result[(5, 13, 0)] = numpy.sum(((x592 * x783) * x855))
result[(5, 13, 1)] = numpy.sum(((x181 * x539) * x855))
result[(5, 13, 2)] = numpy.sum(((x177 * x784) * x858))
result[(5, 13, 3)] = numpy.sum(((x188 * x785) * x855))
result[(5, 13, 4)] = numpy.sum(((x193 * x538) * x858))
result[(5, 13, 5)] = numpy.sum(((x177 * x785) * x860))
result[(5, 13, 6)] = numpy.sum(((x198 * x802) * x855))
result[(5, 13, 7)] = numpy.sum(((x188 * x858) * x867))
result[(5, 13, 8)] = numpy.sum(((x11 * x193) * x860))
result[(5, 13, 9)] = numpy.sum(((x175 * x786) * x863))
result[(5, 13, 10)] = numpy.sum(((x204 * x787) * x855))
result[(5, 13, 11)] = numpy.sum(((x198 * x803) * x858))
result[(5, 13, 12)] = numpy.sum(((x191 * x8) * x860))
result[(5, 13, 13)] = numpy.sum(((x181 * x8) * x862))
result[(5, 13, 14)] = numpy.sum(((x175 * x565) * x866))
result[(5, 14, 0)] = numpy.sum(((x164 * x771) * x868))
result[(5, 14, 1)] = numpy.sum(((x388 * x774) * x868))
result[(5, 14, 2)] = numpy.sum(((x164 * x774) * x869))
result[(5, 14, 3)] = numpy.sum(((x132 * x793) * x868))
result[(5, 14, 4)] = numpy.sum(((x538 * x580) * x869))
result[(5, 14, 5)] = numpy.sum(((x128 * x777) * x870))
result[(5, 14, 6)] = numpy.sum(((x154 * x781) * x868))
result[(5, 14, 7)] = numpy.sum(((x157 * x781) * x869))
result[(5, 14, 8)] = numpy.sum((((x111 * x565) * x780) * x870))
result[(5, 14, 9)] = numpy.sum((x778 * x871))
result[(5, 14, 10)] = numpy.sum(((x166 * x782) * x868))
result[(5, 14, 11)] = numpy.sum(((x154 * x782) * x869))
result[(5, 14, 12)] = numpy.sum(((x133 * x8) * x870))
result[(5, 14, 13)] = numpy.sum((x674 * x871))
result[(5, 14, 14)] = numpy.sum((x565 * ((x0 * (((((2.0 * x659) + (2.0 * x660)) + (7.0 * x852)) + (3.0 * x853)) + (4.0 * x861))) + (x211 * x865))))
return result |
def test_get_exceptions_with_intersections(tmp_path: Path):
exceptions = {'tests/': {'pyflakes': ['+*']}, '**/test.py': {'pycodestyle': ['+*']}}
tests_dir = (tmp_path / 'tests')
tests_dir.mkdir()
test_file_path = (tests_dir / 'test.py')
test_file_path.touch()
result = get_exceptions(path=test_file_path, exceptions=exceptions, root=tmp_path)
assert (result == {'pyflakes': ['+*'], 'pycodestyle': ['+*']}) |
class BudgetTestBase(unittest.TestCase):
def setUp(self):
super(BudgetTestBase, self).setUp()
from stalker import Status
self.status_wfd = Status(name='Waiting For Dependency', code='WFD')
self.status_rts = Status(name='Ready To Start', code='RTS')
self.status_wip = Status(name='Work In Progress', code='WIP')
self.status_prev = Status(name='Pending Review', code='PREV')
self.status_hrev = Status(name='Has Revision', code='HREV')
self.status_drev = Status(name='Dependency Has Revision', code='DREV')
self.status_oh = Status(name='On Hold', code='OH')
self.status_stop = Status(name='Stopped', code='STOP')
self.status_cmpl = Status(name='Completed', code='CMPL')
self.status_new = Status(name='New', code='NEW')
self.status_app = Status(name='Approved', code='APP')
from stalker import StatusList
self.budget_status_list = StatusList(name='Budget Statuses', target_entity_type='Budget', statuses=[self.status_new, self.status_prev, self.status_app])
self.task_status_list = StatusList(statuses=[self.status_wfd, self.status_rts, self.status_wip, self.status_prev, self.status_hrev, self.status_drev, self.status_cmpl], target_entity_type='Task')
self.test_project_status_list = StatusList(name='Project Statuses', statuses=[self.status_wip, self.status_prev, self.status_cmpl], target_entity_type='Project')
from stalker import Type
self.test_movie_project_type = Type(name='Movie Project', code='movie', target_entity_type='Project')
self.test_repository_type = Type(name='Test Repository Type', code='test', target_entity_type='Repository')
from stalker import Repository
self.test_repository = Repository(name='Test Repository', code='TR', type=self.test_repository_type, linux_path='/mnt/T/', windows_path='T:/', osx_path='/Volumes/T/')
from stalker import User
self.test_user1 = User(name='User1', login='user1', email='.com', password='1234')
self.test_user2 = User(name='User2', login='user2', email='.com', password='1234')
self.test_user3 = User(name='User3', login='user3', email='.com', password='1234')
self.test_user4 = User(name='User4', login='user4', email='.com', password='1234')
self.test_user5 = User(name='User5', login='user5', email='.com', password='1234')
from stalker import Project
self.test_project = Project(name='Test Project1', code='tp1', type=self.test_movie_project_type, status_list=self.test_project_status_list, repository=self.test_repository)
self.kwargs = {'project': self.test_project, 'name': 'Test Budget 1', 'status_list': self.budget_status_list}
self.test_budget = Budget(**self.kwargs)
from stalker import Good
self.test_good = Good(name='Some Good', cost=100, msrp=120, unit='$') |
def speedMenu():
while True:
try:
clear()
print('\n At what speed would you like the AI to play?')
print('\n 1. Slow enough to watch the game')
print(' 2. Full speed ahead')
n = input('\n Option: ')
choices(n)
except ValueError:
print('\n Please choose an option.')
print('\n Press Enter to continue.')
input('')
continue
if ((not n.isdigit()) or (int(n) < 1) or (int(n) > 2)):
print('\n Please choose an option.')
print('\n Press Enter to continue.')
input('')
continue
else:
break
if (int(n) == 1):
globVar.slow_speed = True
else:
globVar.slow_speed = False |
class table_desc_stats_reply(stats_reply):
version = 6
type = 19
stats_type = 14
def __init__(self, xid=None, flags=None, entries=None):
if (xid != None):
self.xid = xid
else:
self.xid = None
if (flags != None):
self.flags = flags
else:
self.flags = 0
if (entries != None):
self.entries = entries
else:
self.entries = []
return
def pack(self):
packed = []
packed.append(struct.pack('!B', self.version))
packed.append(struct.pack('!B', self.type))
packed.append(struct.pack('!H', 0))
packed.append(struct.pack('!L', self.xid))
packed.append(struct.pack('!H', self.stats_type))
packed.append(struct.pack('!H', self.flags))
packed.append(('\x00' * 4))
packed.append(loxi.generic_util.pack_list(self.entries))
length = sum([len(x) for x in packed])
packed[2] = struct.pack('!H', length)
return ''.join(packed)
def unpack(reader):
obj = table_desc_stats_reply()
_version = reader.read('!B')[0]
assert (_version == 6)
_type = reader.read('!B')[0]
assert (_type == 19)
_length = reader.read('!H')[0]
orig_reader = reader
reader = orig_reader.slice(_length, 4)
obj.xid = reader.read('!L')[0]
_stats_type = reader.read('!H')[0]
assert (_stats_type == 14)
obj.flags = reader.read('!H')[0]
reader.skip(4)
obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_desc.unpack)
return obj
def __eq__(self, other):
if (type(self) != type(other)):
return False
if (self.xid != other.xid):
return False
if (self.flags != other.flags):
return False
if (self.entries != other.entries):
return False
return True
def pretty_print(self, q):
q.text('table_desc_stats_reply {')
with q.group():
with q.indent(2):
q.breakable()
q.text('xid = ')
if (self.xid != None):
q.text(('%#x' % self.xid))
else:
q.text('None')
q.text(',')
q.breakable()
q.text('flags = ')
value_name_map = {1: 'OFPSF_REPLY_MORE'}
q.text(util.pretty_flags(self.flags, value_name_map.values()))
q.text(',')
q.breakable()
q.text('entries = ')
q.pp(self.entries)
q.breakable()
q.text('}') |
def blockedwell_from_roxar(project, gname, bwname, wname, lognames=None, ijk=True, realisation=0):
obj = BlockedWell(*([0.0] * 3), '', pd.DataFrame({_AttrName.XNAME.value: [], _AttrName.YNAME.value: [], _AttrName.ZNAME.value: []}))
_blockedwell_roxapi.import_bwell_roxapi(obj, project, gname, bwname, wname, lognames=lognames, ijk=ijk, realisation=realisation)
obj._ensure_consistency()
return obj |
('func_name, func, value, expected', [param('foo_1', F.foo1, 'foo_1(10)', 'int:10', id='foo_1(10)'), param('foo_1', F.foo1, 'foo_1(value=10)', 'int:10', id='foo_1(value=10)'), param('foo_2', F.foo2, "foo_2('10',10)", 'str:10,int:10', id="foo_2('10',10)"), param('empty', F.empty, 'empty()', 10, id='empty()'), param('sum', F.sum, 'sum()', 0, id='sum()'), param('sum', F.sum, 'sum(1)', 1, id='sum(1)'), param('sum', F.sum, 'sum(1,2,3)', 6, id='sum(1,2,3)'), param('range', F.range, 'range(10,20)', 'res:range(start=10,stop=20,step=1)', id='range(10,20)'), param('range', F.range, 'range(10,20,5)', 'res:range(start=10,stop=20,step=5)', id='range(10,20,5)'), param('range', F.range, 'range(10,20,step=5)', 'res:range(start=10,stop=20,step=5)', id='range(10,20,step=5)'), param('range', F.range, 'range(start=10,stop=20,step=5)', 'res:range(start=10,stop=20,step=5)', id='range(start=10,stop=20,step=5)'), param('range', F.range, 'range(step=5,start=10,stop=20)', 'res:range(start=10,stop=20,step=5)', id='range(step=5,start=10,stop=20)'), param('range', F.range, 'range(10,step=5,stop=20)', 'res:range(start=10,stop=20,step=5)', id='range(10,step=5,stop=20)'), param('sort', F.sort, 'sort(10,1,5)', [1, 5, 10], id='sort(10,1,5)'), param('sort', F.sort, 'sort(10,1,5,reverse=true)', [10, 5, 1], id='sort(10,1,5,reverse=true)')])
def test_eval(func_name: str, func: Callable[(..., Any)], value: str, expected: Any) -> None:
functions = Functions()
functions.register(name=func_name, func=func)
parser = OverridesParser(functions)
assert (parser.parse_rule(value, 'function') == expected) |
class InsertConsts2(SqlStatement):
table: Id
cols: List[str]
tuples: list
def _compile(self, qb):
assert self.tuples, self
if (get_db().target == oracle):
values_q = join_sep([((['SELECT '] + join_comma(([t] for t in tpl))) + [' FROM dual']) for tpl in self.tuples], ' UNION ALL ')
else:
values_q = (['VALUES '] + join_comma((parens(join_comma(([t] for t in tpl))) for tpl in self.tuples)))
cols = [quote_name(c) for c in self.cols]
q = (['INSERT INTO ', quote_id(self.table), '(', ', '.join(cols), ')'] + values_q)
return q |
class HelpForParameters(object):
header = attr.ib()
footer = attr.ib()
sections = attr.ib()
after = attr.ib()
def blank_from_signature(cls, signature):
s = util.OrderedDict(((LABEL_POS, util.OrderedDict()), (LABEL_OPT, util.OrderedDict()), (LABEL_ALT, util.OrderedDict())))
for p in _filter_undocumented(signature.positional):
s[LABEL_POS][_pname(p)] = (p, '')
for p in sorted(_filter_undocumented(signature.named), key=_pname):
s[LABEL_OPT][_pname(p)] = (p, '')
for p in _filter_undocumented(signature.alternate):
s[LABEL_ALT][_pname(p)] = (p, '')
return cls([], [], s, {})
def _has_options(self):
if self.sections[LABEL_OPT]:
return True
return any(((title not in (LABEL_POS, LABEL_OPT, LABEL_ALT)) for title in self.sections))
def _all_params(self):
return (param for (title, section) in self.sections.items() for (param, _) in section.values())
def _params_for_usage(self):
for (title, section) in self.sections.items():
if (title not in (LABEL_POS, LABEL_ALT)):
for (param, _) in section.values():
(yield param)
for (param, _) in self.sections[LABEL_POS].values():
(yield param)
def _alternate_params(self):
return (param for (param, _) in self.sections[LABEL_ALT].values())
def show_usage(self, name):
ret = ['Usage:', name]
if self._has_options:
ret.append('[OPTIONS]')
ret.extend((str(param) for (param, _) in self.sections[LABEL_POS].values()))
return (' '.join(ret),)
def _alternate_usages(self):
return _alternate_usages(self._alternate_params)
def usages(self):
(yield ' '.join((str(param) for param in self._params_for_usage)))
for usage in self._alternate_usages():
(yield usage)
def show_full_usage(self, name):
for usage in self.usages():
(yield ((name + ' ') + usage))
def _show_parameters(self):
f = util.Formatter()
with f.columns(indent=2) as cols:
for (label, section) in self.sections.items():
if (not section):
continue
f.new_paragraph()
f.append((label + ':'))
for (argname, (param, text)) in section.items():
self._show_parameter(param, text, self.after.get(argname, ()), f, cols)
return f
def _show_parameter(self, param, desc, after, f, cols):
ret = param.show_help(desc, after, f, cols)
if (ret is not None):
cols.append(*ret)
if after:
f.new_paragraph()
f.extend(after)
f.new_paragraph()
def show_help(self, name):
f = util.Formatter()
f.extend(self.show_usage(name))
f.new_paragraph()
f.extend(_lines_to_paragraphs(self.header))
f.new_paragraph()
f.extend(self._show_parameters())
f.new_paragraph()
f.extend(_lines_to_paragraphs(self.footer))
return f |
def test_perm_logarithmic_map(tmpdir, generate_plot):
mysurf = xtgeo.surface_from_file(SFILE2)
myplot = Map()
myplot.canvas(title='PERMX normal scale')
myplot.colormap = 'rainbow'
myplot.plot_surface(mysurf, minvalue=0, maxvalue=6000, xlabelrotation=45, logarithmic=True)
if generate_plot:
myplot.savefig(join(tmpdir, 'permx_normal.png'), last=True)
else:
myplot.close() |
class OldFalconDecoderLayer(Module):
def __init__(self, layer_config: TransformerLayerConfig, *, device: Optional[torch.device]=None):
super().__init__()
attention_config = layer_config.attention
if (attention_config.rotary_embeddings is None):
raise ValueError('Falcon attention config does not contain rotary embedding parameters')
self.use_parallel_attention = attention_config.use_parallel_attention
hidden_width = layer_config.feedforward.hidden_width
n_attention_heads = attention_config.n_query_heads
attention_biases = (AttentionLinearBiases(n_attention_heads=attention_config.n_query_heads, is_causal=True, is_inverted=True) if attention_config.use_alibi else None)
rotary_embeds = (QueryKeyRotaryEmbeddings(fraction=attention_config.rotary_embeddings.rotary_fraction, base=attention_config.rotary_embeddings.rotary_base, head_width=(hidden_width // n_attention_heads)) if (not attention_config.use_alibi) else None)
self.mha = SelfAttention(attention_scorer=ScaledDotProductAttention(dropout_prob=attention_config.dropout_prob, linear_biases=attention_biases), hidden_width=hidden_width, attention_heads=AttentionHeads.key_value_broadcast(n_query_heads=attention_config.n_query_heads, n_key_value_heads=attention_config.n_key_value_heads), rotary_embeds=rotary_embeds, qkv_mode=(QkvMode.MERGED_SPLIT_AFTER if (attention_config.n_key_value_heads == 1) else QkvMode.MERGED_SPLIT_BEFORE), use_bias=attention_config.use_bias, device=device)
self.attn_output_dropout = torch.nn.Dropout(p=layer_config.dropout_prob)
self.attn_layer_norm = torch.nn.LayerNorm(hidden_width, eps=layer_config.layer_norm_eps, device=device)
if (not self.use_parallel_attention):
self.ffn_layer_norm = torch.nn.LayerNorm(hidden_width, eps=layer_config.layer_norm_eps, device=device)
self.ffn = PointwiseFeedForward(activation=layer_config.feedforward.activation.module(), hidden_width=hidden_width, intermediate_width=layer_config.feedforward.intermediate_width, use_bias=layer_config.feedforward.use_bias, use_gate=layer_config.feedforward.use_gate, device=device)
self.ffn_output_dropout = torch.nn.Dropout(p=layer_config.dropout_prob)
def forward(self, input: Tensor, attention_mask: AttentionMask, *, cache: Optional[KeyValueCache]=None, positions: Optional[Tensor]=None, store_cache: bool=False) -> Tuple[(Tensor, Optional[KeyValueCache])]:
residual = input
attn_layer_norm = self.attn_layer_norm(input)
(attn_out, cache) = self.mha(attn_layer_norm, attention_mask, cache=cache, store_cache=store_cache, positions=positions, use_causal_mask=True)
if self.use_parallel_attention:
ffn_layer_norm = attn_layer_norm
else:
residual = (residual + self.attn_output_dropout(attn_out))
ffn_layer_norm = self.ffn_layer_norm(residual)
ffn_out = self.ffn(ffn_layer_norm)
if self.use_parallel_attention:
ffn_out += attn_out
return ((residual + self.ffn_output_dropout(ffn_out)), cache) |
class RichMediaElement(AbstractObject):
def __init__(self, api=None):
super(RichMediaElement, self).__init__()
self._isRichMediaElement = True
self._api = api
class Field(AbstractObject.Field):
element = 'element'
element_type = 'element_type'
name = 'name'
_field_types = {'element': 'Object', 'element_type': 'string', 'name': 'string'}
def _get_field_enum_info(cls):
field_enum_info = {}
return field_enum_info |
def _function_over_one_var(repr_func, raw_func, x, out=None, out_like=None, sizing='optimal', method='raw', optimal_size=None, **kwargs):
if (not isinstance(x, Fxp)):
x = Fxp(x)
(signed, _, n_int, n_frac) = _get_sizing([x], sizing=sizing, method=method, optimal_size=optimal_size)
if (out is not None):
if isinstance(out, tuple):
out = out[0]
if (not isinstance(out, Fxp)):
raise TypeError('`out` must be a Fxp object!')
if ((not out.signed) and signed):
raise ValueError('Signed addition can not be stored in unsigned `out` object!')
n_frac = out.n_frac
config = None
elif (out_like is not None):
if (not isinstance(out_like, Fxp)):
raise TypeError('`out_like` must be a Fxp object!')
if ((not out_like.signed) and signed):
raise ValueError('Signed addition can not be stored in unsigned `out_like` object!')
signed = None
n_frac = None
n_int = None
config = None
else:
config = x.config
if ((method == 'repr') or x.scaled or (n_frac is None)):
raw = False
val = repr_func(x.get_val(), **kwargs)
elif (method == 'raw'):
raw = True
kwargs['n_frac'] = n_frac
val = raw_func(x, **kwargs)
else:
raise ValueError('method {} is not valid. Valid methods: raw, repr'.format(method))
if (out is not None):
z = out.set_val(val, raw=raw)
else:
z = Fxp(val, signed=signed, n_int=n_int, n_frac=n_frac, like=out_like, raw=raw)
return z |
.asyncio
.workspace_host
class TestGetPermission():
async def test_unauthorized(self, unauthorized_api_assertions: HTTPXResponseAssertion, test_client_api: test_data: TestData):
permission = test_data['permissions']['castles:create']
response = (await test_client_api.get(f'/permissions/{permission.id}'))
unauthorized_api_assertions(response)
.authenticated_admin
async def test_not_existing(self, test_client_api: not_existing_uuid: uuid.UUID):
response = (await test_client_api.get(f'/permissions/{not_existing_uuid}'))
assert (response.status_code == status.HTTP_404_NOT_FOUND)
.authenticated_admin
async def test_valid(self, test_client_api: test_data: TestData):
permission = test_data['permissions']['castles:create']
response = (await test_client_api.get(f'/permissions/{permission.id}'))
assert (response.status_code == status.HTTP_200_OK) |
.parametrize('rule, source, expected', [pytest.param(UseFunctionLevelImports, '\n from functools import reduce\n from operator import add\n import dataclass\n\n def something():\n a = reduce(x, y)\n b = add(a, a)\n return b\n\n def other_thing():\n return dataclass(something(1, 2))\n ', '\n from functools import reduce\n from operator import add\n import dataclass\n\n def something():\n from functools import reduce\n from operator import add\n a = reduce(x, y)\n b = add(a, a)\n return b\n\n def other_thing():\n import dataclass\n return dataclass(something(1, 2))\n ', id='UseFunctionLevelImports | SUCCESS | general'), pytest.param(UseFunctionLevelImports, '\n from airflow.decorators import dag, task\n from operator import add\n\n ()\n def my_dag():\n ()\n def my_task():\n add(1, 2)\n ', '\n from airflow.decorators import dag, task\n from operator import add\n\n ()\n def my_dag():\n ()\n def my_task():\n from operator import add\n add(1, 2)\n ', id='UseFunctionLevelImports | SKIP | dag decorator'), pytest.param(UseFunctionLevelImports, '\n from airflow.decorators import dag, task\n from operator import add\n\n ()\n def my_dag():\n ()\n def my_task():\n add(1, 2)\n add(1, 2)\n ', '\n from airflow.decorators import dag, task\n from operator import add\n\n ()\n def my_dag():\n ()\n def my_task():\n from operator import add\n add(1, 2)\n add(1, 2)\n ', id='UseFunctionLevelImports | SUCCESS | unique'), pytest.param(UseFunctionLevelImports, "\n import random\n from airflow import DAG\n from airflow.decorators import task\n\n with DAG() as dag:\n ()\n def random_choice():\n return random.choice(['task_1', 'task_2'])\n ", "\n import random\n from airflow import DAG\n from airflow.decorators import task\n\n with DAG() as dag:\n ()\n def random_choice():\n import random\n return random.choice(['task_1', 'task_2'])\n ", id='UseFunctionLevelImports | SKIP | function decorators'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo=Variable.get("FOO"))\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo=\'{{ var.value.FOO }}\')\n ', id='UseJinjaVariableGet | SUCCESS | direct assignment with key'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from airflow.providers.cncf.kubernetes.operators.kubernetes_pod import KubernetesPodOperator\n\n KubernetesPodOperator(task_id="fake", image=Variable.get("FOO"))\n ', '\n from airflow.models import Variable\n from airflow.providers.cncf.kubernetes.operators.kubernetes_pod import KubernetesPodOperator\n\n KubernetesPodOperator(task_id="fake", image=Variable.get("FOO"))\n ', id='UseJinjaVariableGet | SKIP | cannot import module'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n\n def foo():\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo=Variable.get("FOO"))\n ', '\n from airflow.models import Variable\n\n def foo():\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo=Variable.get("FOO"))\n ', id='UseJinjaVariableGet | SKIP | cannot reach import'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", fizz=Variable.get("FOO"))\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", fizz=Variable.get("FOO"))\n ', id='UseJinjaVariableGet | SKIP | keyword not in template_fields'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = Variable.get("FOO")\n\n FakeOperator(task_id="fake", foo=var)\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = \'{{ var.value.FOO }}\'\n\n FakeOperator(task_id="fake", foo=var)\n ', id='UseJinjaVariableGet | SUCCESS | variable assignment'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n def foo():\n var = Variable.get("FOO")\n\n FakeOperator(task_id="fake", foo=var)\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n def foo():\n var = Variable.get("FOO")\n\n FakeOperator(task_id="fake", foo=var)\n ', id='UseJinjaVariableGet | SKIP | cannot reach variable'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = Variable.get("FOO")\n\n FakeOperator(task_id="fake", foo=var, bar=var)\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = \'{{ var.value.FOO }}\'\n\n FakeOperator(task_id="fake", foo=var, bar=var)\n ', id='UseJinjaVariableGet | SUCCESS | variable assignment with multiple keywords'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = Variable.get("FOO")\n\n FakeOperator(task_id="fake", foo=var, fizz=var)\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = Variable.get("FOO")\n\n FakeOperator(task_id="fake", foo=var, fizz=var)\n ', id='UseJinjaVariableGet | SKIP | variable assignment at least one keyword not in template_fields'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = Variable.get("FOO")\n\n FakeOperator(task_id="fake", foo=var)\n FakeOperator(task_id="fake2", fizz=var)\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = Variable.get("FOO")\n\n FakeOperator(task_id="fake", foo=var)\n FakeOperator(task_id="fake2", fizz=var)\n ', id='UseJinjaVariableGet | SKIP | variable assignment for multiple calls where at least one keyword is not in template_fields'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = Variable.get("FOO")\n\n FakeOperator(task_id="fake", foo=var)\n FakeOperator(task_id="fake2", foo=var)\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n var = \'{{ var.value.FOO }}\'\n\n FakeOperator(task_id="fake", foo=var)\n FakeOperator(task_id="fake2", foo=var)\n ', id='UseJinjaVariableGet | SUCCESS | variable assignment for multiple calls'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", fizz=str(Variable.get("FOO")))\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", fizz=str(Variable.get("FOO")))\n ', id='UseJinjaVariableGet | SKIP | direct assignment with unimplemented parent type'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo=Variable.get("FOO", deserialize_json=True))\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo=\'{{ var.json.FOO }}\')\n ', id='UseJinjaVariableGet | SUCCESS | direct assignment with key and deserialize_json keyword'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo=Variable.get("FOO", default_var="BAR"))\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo="{{ var.value.get(\'FOO\', \'BAR\') }}")\n ', id='UseJinjaVariableGet | SUCCESS | direct assignment with key and default_var keyword'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo=Variable.get("FOO", default_var=None))\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo="{{ var.value.get(\'FOO\', None) }}")\n ', id='UseJinjaVariableGet | SUCCESS | direct assignment with key and default_var=None keyword'), pytest.param(UseJinjaVariableGet, '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo=Variable.get("FOO", deserialize_json=True, default_var="BAR"))\n ', '\n from airflow.models import Variable\n from operators.fake import FakeOperator\n\n FakeOperator(task_id="fake", foo="{{ var.json.get(\'FOO\', \'BAR\') }}")\n ', id='UseJinjaVariableGet | SUCCESS | direct assignment with key, deserialize_json and default_var keywords')])
def test_rules(rule, source, expected):
source = textwrap.dedent(source)
expected = textwrap.dedent(expected)
session = Session(rules=[rule])
assert (session.run(source) == expected) |
_after
def scaffold_item(ctx: Context, item_type: str, item_name: str) -> None:
validate_package_name(item_name)
author_name = ctx.agent_config.author
loader = getattr(ctx, f'{item_type}_loader')
default_config_filename = globals()[f'DEFAULT_{item_type.upper()}_CONFIG_FILE']
item_type_plural = (item_type + 's')
existing_ids = getattr(ctx.agent_config, f'{item_type}s')
existing_ids_only_author_and_name = map((lambda x: (x.author, x.name)), existing_ids)
if ((author_name, item_name) in existing_ids_only_author_and_name):
raise click.ClickException(f"A {item_type} with name '{item_name}' already exists. Aborting...")
agent_name = ctx.agent_config.agent_name
click.echo(f"Adding {item_type} scaffold '{item_name}' to the agent '{agent_name}'...")
Path(item_type_plural).mkdir(exist_ok=True)
dest = os.path.join(item_type_plural, item_name)
if os.path.exists(dest):
raise click.ClickException(f'A {item_type} with this name already exists. Please choose a different name and try again.')
ctx.clean_paths.append(str(dest))
try:
src = Path(os.path.join(AEA_DIR, item_type_plural, 'scaffold'))
logger.debug(f'Copying {item_type} modules. src={src} dst={dest}')
shutil.copytree(src, dest)
logger.debug(f'Registering the {item_type} into {DEFAULT_AEA_CONFIG_FILE}')
new_public_id = PublicId(author_name, item_name, DEFAULT_VERSION)
existing_ids.add(new_public_id)
with open_file(os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE), 'w') as fp:
ctx.agent_loader.dump(ctx.agent_config, fp)
config_filepath = Path(ctx.cwd, item_type_plural, item_name, default_config_filename)
with open_file(config_filepath) as fp:
config = loader.load(fp)
config.name = item_name
config.author = author_name
with open_file(config_filepath, 'w') as fp:
loader.dump(config, fp)
for file_name in ['__init__.py', 'connection.py']:
file_path = (Path(dest) / file_name)
if (not file_path.exists()):
continue
py_file = Path(file_path)
py_file.write_text(re.sub(SCAFFOLD_PUBLIC_ID, str(new_public_id), py_file.read_text()))
fingerprint_item(ctx, item_type, new_public_id)
if ctx.config.get('with_symlinks', False):
click.echo('Adding symlinks from vendor to non-vendor and packages to vendor folders.')
create_symlink_vendor_to_local(ctx, item_type, new_public_id)
create_symlink_packages_to_vendor(ctx)
except ValidationError:
raise click.ClickException(f'Error when validating the {item_type} configuration file.')
except Exception as e:
raise click.ClickException(str(e)) |
class StructuredDataset(DataClassJSONMixin):
uri: typing.Optional[str] = field(default=None, metadata=config(mm_field=fields.String()))
file_format: typing.Optional[str] = field(default=GENERIC_FORMAT, metadata=config(mm_field=fields.String()))
def columns(cls) -> typing.Dict[(str, typing.Type)]:
return {}
def column_names(cls) -> typing.List[str]:
return [k for (k, v) in cls.columns().items()]
def __init__(self, dataframe: typing.Optional[typing.Any]=None, uri: typing.Optional[str]=None, metadata: typing.Optional[literals.StructuredDatasetMetadata]=None, **kwargs):
self._dataframe = dataframe
self.uri = uri
self.file_format = (kwargs['file_format'] if ('file_format' in kwargs) else GENERIC_FORMAT)
self._metadata = metadata
self._literal_sd: Optional[literals.StructuredDataset] = None
self._dataframe_type: Optional[DF] = None
self._already_uploaded = False
def dataframe(self) -> Optional[DF]:
return self._dataframe
def metadata(self) -> Optional[StructuredDatasetMetadata]:
return self._metadata
def literal(self) -> Optional[literals.StructuredDataset]:
return self._literal_sd
def open(self, dataframe_type: Type[DF]):
self._dataframe_type = dataframe_type
return self
def all(self) -> DF:
if (self._dataframe_type is None):
raise ValueError('No dataframe type set. Use open() to set the local dataframe type you want to use.')
ctx = FlyteContextManager.current_context()
return flyte_dataset_transformer.open_as(ctx, self.literal, self._dataframe_type, self.metadata)
def iter(self) -> Generator[(DF, None, None)]:
if (self._dataframe_type is None):
raise ValueError('No dataframe type set. Use open() to set the local dataframe type you want to use.')
ctx = FlyteContextManager.current_context()
return flyte_dataset_transformer.iter_as(ctx, self.literal, self._dataframe_type, updated_metadata=self.metadata) |
def THD(signal, fs):
signal = (np.asarray(signal) + 0.0)
signal -= mean(signal)
window = general_cosine(len(signal), flattops['HFT248D'])
windowed = (signal * window)
del signal
f = rfft(windowed)
i = argmax(abs(f))
true_i = parabolic(log(abs(f)), i)[0]
print(('Frequency: %f Hz' % (fs * (true_i / len(windowed)))))
print(('fundamental amplitude: %.3f' % abs(f[i])))
for x in range(2, 15):
print(('%.3f' % abs(f[(i * x)])), end=' ')
THD = (sum([abs(f[(i * x)]) for x in range(2, 15)]) / abs(f[i]))
print(('\nTHD: %f%%' % (THD * 100)))
return |
('cuda.index_select.func_decl')
def gen_function_decl(func_attrs) -> str:
backend_spec = CUDASpec()
x = func_attrs['inputs'][0]
input_type = backend_spec.dtype_to_backend_type(x._attrs['dtype'])
return FUNC_DECL_TEMPLATE.render(func_name=func_attrs['name'], input_type=input_type, index_type=backend_spec.index_type) |
def send_status(status: 'Status'):
global middlewares, master
if (status is None):
return
s: 'Optional[Status]' = status
for i in middlewares:
s = i.process_status(cast('Status', s))
if (s is None):
return
status = cast('Status', s)
status.verify()
status.destination_channel.send_status(status) |
_validator
def validate_build_nvrs(request, **kwargs):
for build in (request.validated.get('builds') or []):
try:
cache_nvrs(request, build)
if request.validated.get('from_tag'):
(n, v, r) = request.buildinfo[build]['nvr']
release = request.db.query(Release).filter(or_((Release.name == r), (Release.name == r.upper()), (Release.version == r))).first()
if (release and release.composed_by_bodhi):
request.errors.add('body', 'builds', f"Can't create update from tag for release '{release.name}' composed by Bodhi.")
except ValueError:
request.validated['builds'] = []
request.errors.add('body', 'builds', ('Build does not exist: %s' % build))
return
except koji.GenericError:
log.exception(('Error retrieving koji build for %s' % build))
request.validated['builds'] = []
request.errors.add('body', 'builds', ('Koji error getting build: %s' % build))
return |
(urls.RULE_TARGET_DETAIL, status_code=HTTP_200_OK, response_model=schemas.RuleTarget, dependencies=[Security(verify_oauth_client, scopes=[scope_registry.RULE_READ])])
def get_rule_target(*, policy_key: FidesKey, rule_key: FidesKey, rule_target_key: FidesKey, db: Session=Depends(deps.get_db)) -> RuleTarget:
return get_rule_target_or_error(db, policy_key, rule_key, rule_target_key) |
def load_ecdsa_signing_key(keyfile):
try:
sk = ecdsa.SigningKey.from_pem(keyfile.read())
except ValueError:
raise esptool.FatalError('Incorrect ECDSA private key specified. Please check algorithm and/or format.')
if (sk.curve not in [ecdsa.NIST192p, ecdsa.NIST256p]):
raise esptool.FatalError('Supports NIST192p and NIST256p keys only')
return sk |
class OptionSeriesHistogramSonificationDefaultinstrumentoptionsMappingFrequency(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
class TestExpr():
def __init__(self):
pass
def run(self):
for method in dir(self):
if method.startswith('test_'):
print(method, '...', end=' ')
getattr(self, method)()
print('OK!')
def test_free_variables(self):
assert (((x + y) + 1).free_variables() == set([x, y]))
assert ((Pi + 1).free_variables() == set())
assert ((x + Where(y, Def(y, 3))).free_variables() == set([x]))
assert ((x + Where(y, Def(y, y))).free_variables() == set([x, y]))
assert ((x + Where(y, Def(y, 3), Def(z, y))).free_variables() == set([x]))
assert (Sum(f(n), For(n, a, b)).free_variables() == set([f, a, b]))
assert (Sum(f(n), ForElement(n, S)).free_variables() == set([f, S]))
assert (Where((t + (y * u)), Def(Tuple(t, u), v)).free_variables() == set([y, v]))
assert (Where(f(b), Def(f(z), (z + a))).free_variables() == set([a, b]))
assert (Where(f(b), Def(f(z, x), ((z + x) - a))).free_variables() == set([a, b]))
assert (Where(f(b), Def(f(z, x), (((z + x) - a) + f))).free_variables() == set([a, b, f]))
assert (Where(Sum((a_(i) * b), For(i, 1, n)), Def(Tuple(a_(i), For(i, 1, n)), T)).free_variables() == set([T, b]))
assert (Where(((a * d) - (b * c)), Def(Matrix2x2(a, b, c, d), M)).free_variables() == set([M]))
def test_replace(self):
assert (((x + y) + 1).replace({x: z}) == ((z + y) + 1))
assert ((x + y).replace({x: y, y: x}) == (y + x))
assert (Where(y, Def(y, 3)).replace({y: 5}) == Where(5, Def(5, 3)))
assert (Where(y, Def(y, 3)).replace({y: 5}, semantic=True) == Where(y, Def(y, 3)))
assert (Where(y, Def(y, y)).replace({y: 5}, semantic=True) == Where(y, Def(y, 5)))
assert (Where(x, Def(x, y), Def(y, x)).replace({x: 5, y: 3}, semantic=True) == Where(x, Def(x, 3), Def(y, x)))
assert (Where((x + z), Def(x, y), Def(y, x)).replace({x: 5, y: 3, z: 2}, semantic=True) == Where((x + 2), Def(x, 3), Def(y, x)))
assert (Where((a + b), Def(Tuple(a, b, c), T(a))).replace({a: 2, T: S, b: 8}, semantic=True) == Where((a + b), Def(Tuple(a, b, c), S(2))))
assert (Where(Sum((a_(i) * b), For(i, 1, n)), Def(Tuple(a_(i), For(i, 1, n)), T)).replace({a_: f, i: 7, b: 5, n: 8, T: S}, semantic=True) == Where(Sum((a_(i) * 5), For(i, 1, n)), Def(Tuple(a_(i), For(i, 1, n)), S)))
assert (Where(f(b), Def(f(z), (z + a))).replace({f: g}, semantic=True) == Where(f(b), Def(f(z), (z + a))))
assert (Where(f(b), Def(f(z), (z + a))).replace({f: g, z: w}, semantic=True) == Where(f(b), Def(f(z), (z + a))))
assert (Where(f(b), Def(f(z), (z + a)), Def(b, f(a))).replace({f: g, z: w}, semantic=True) == Where(f(b), Def(f(z), (z + a)), Def(b, f(a))))
assert (Where(f(b), Def(f(z), (z + a))).replace({f: g, z: w, a: b, b: a}, semantic=True) == Where(f(a), Def(f(z), (z + b))))
assert (Where((((a * d) - (b * c)) + e), Def(Matrix2x2(a, b, c, d), M)).replace({a: 2, M: S, e: 7}, semantic=True) == Where((((a * d) - (b * c)) + 7), Def(Matrix2x2(a, b, c, d), S)))
assert (Sum(f(n), For(n, a, b)).replace({a: 1, b: 10}, semantic=True) == Sum(f(n), For(n, 1, 10)))
assert (Sum(f(n), For(n, a, b)).replace({a: 1, b: 10, f: g}, semantic=True) == Sum(g(n), For(n, 1, 10)))
assert (Sum(f(n), For(n, a, b)).replace({a: 1, b: 10, f: g, n: m}, semantic=True) == Sum(g(n), For(n, 1, 10)))
assert (Sum(f(n), For(n, a, b), Q(n, a)).replace({a: 1, b: 10, f: g, n: m, Q: R}, semantic=True) == Sum(g(n), For(n, 1, 10), R(n, 1)))
assert (Set((x + y), ForElement(x, S)).replace({x: y}, semantic=True) == Set((x + y), ForElement(x, S)))
assert (Set((x + y), ForElement(x, S), P(x)).replace({x: y}, semantic=True) == Set((x + y), ForElement(x, S), P(x)))
assert (Set((x + y), ForElement(x, S), P(x)).replace({x: y, S: x, P: Q, y: 5}, semantic=True) == Set((x + 5), ForElement(x, x), Q(x))) |
class WcRegexp(util.Immutable, Generic[AnyStr]):
_include: tuple[(Pattern[AnyStr], ...)]
_exclude: (tuple[(Pattern[AnyStr], ...)] | None)
_real: bool
_path: bool
_follow: bool
_hash: int
__slots__ = ('_include', '_exclude', '_real', '_path', '_follow', '_hash')
def __init__(self, include: tuple[(Pattern[AnyStr], ...)], exclude: (tuple[(Pattern[AnyStr], ...)] | None)=None, real: bool=False, path: bool=False, follow: bool=False):
super().__init__(_include=include, _exclude=exclude, _real=real, _path=path, _follow=follow, _hash=hash((type(self), type(include), include, type(exclude), exclude, type(real), real, type(path), path, type(follow), follow)))
def __hash__(self) -> int:
return self._hash
def __len__(self) -> int:
return (len(self._include) + (len(self._exclude) if (self._exclude is not None) else 0))
def __eq__(self, other: Any) -> bool:
return (isinstance(other, WcRegexp) and (self._include == other._include) and (self._exclude == other._exclude) and (self._real == other._real) and (self._path == other._path) and (self._follow == other._follow))
def __ne__(self, other: Any) -> bool:
return ((not isinstance(other, WcRegexp)) or (self._include != other._include) or (self._exclude != other._exclude) or (self._real != other._real) or (self._path != other._path) or (self._follow != other._follow))
def match(self, filename: AnyStr, root_dir: (AnyStr | None)=None, dir_fd: (int | None)=None) -> bool:
return _Match(filename, self._include, self._exclude, self._real, self._path, self._follow).match(root_dir=root_dir, dir_fd=dir_fd) |
.skipif(('pandas' not in sys.modules), reason='Pandas is not installed.')
def test_wf1_with_sql():
import pandas as pd
sql = SQLTask('my-query', query_template="SELECT * FROM hive.city.fact_airport_sessions WHERE ds = '{{ .Inputs.ds }}' LIMIT 10", inputs=kwtypes(ds=datetime.datetime), outputs=kwtypes(results=FlyteSchema), metadata=TaskMetadata(retries=2))
def t1() -> datetime.datetime:
return datetime.datetime.now()
def my_wf() -> FlyteSchema:
dt = t1()
return sql(ds=dt)
with task_mock(sql) as mock:
mock.return_value = pd.DataFrame(data={'x': [1, 2], 'y': ['3', '4']})
assert (my_wf().open().all() == pd.DataFrame(data={'x': [1, 2], 'y': ['3', '4']})).all().all()
assert (context_manager.FlyteContextManager.size() == 1) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.