id
stringlengths 3
8
| content
stringlengths 100
981k
|
|---|---|
436056
|
import tensorflow as tf
import numpy as np
import time
from tqdm import tqdm
from sklearn.model_selection import train_test_split
from scipy.stats import kendalltau
from contextual_decomposition import ContextualDecompositionExplainerTF
from gradients import GradientExplainerTF
from neural_interaction_detection import NeuralInteractionDetectionExplainerTF
from path_explain import PathExplainerTF, softplus_activation
def build_model(num_features,
units=[64, 64, 64],
activation_function=tf.keras.activations.relu,
output_units=1):
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Input(shape=(num_features,)))
for unit in units:
model.add(tf.keras.layers.Dense(unit))
model.add(tf.keras.layers.Activation(activation_function))
model.add(tf.keras.layers.Dense(output_units))
return model
def build_data(num_features=20,
num_interacting_pairs=10,
num_samples=5000):
x = np.random.randn(num_samples, num_features)
y = np.zeros(num_samples)
all_pairs = np.array(np.meshgrid(np.arange(num_features),
np.arange(num_features))).T.reshape(-1, 2)
all_pairs = all_pairs[all_pairs[:, 0] != all_pairs[:, 1]]
pair_indices = np.random.choice(all_pairs.shape[0],
size=num_interacting_pairs,
replace=False)
chosen_pairs = all_pairs[pair_indices]
for pair in chosen_pairs:
y += np.prod(x[:, pair], axis=1)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=0)
x_train = x_train.astype(np.float32)
x_test = x_test.astype(np.float32)
return x_train, y_train, x_test, y_test, chosen_pairs
def get_interactions(x_train, y_train, x_test, y_test, model):
num_features = x_train.shape[1]
###### Integrated and Expected Hessians ######
interpret_model = tf.keras.models.clone_model(model)
for layer in interpret_model.layers:
if isinstance(layer, tf.keras.layers.Activation):
layer.activation = softplus_activation(beta=10.0)
print(interpret_model.summary())
path_explainer = PathExplainerTF(interpret_model)
ih_interactions = path_explainer.interactions(inputs=x_test,
baseline=np.zeros((1, num_features)).astype(np.float32),
batch_size=100,
num_samples=200,
use_expectation=False,
output_indices=0,
verbose=True,
interaction_index=None)
eh_interactions = path_explainer.interactions(inputs=x_test,
baseline=x_train,
batch_size=100,
num_samples=200,
use_expectation=True,
output_indices=0,
verbose=True,
interaction_index=None)
###### Contextual Decomposition ######
cd_explainer = ContextualDecompositionExplainerTF(model)
cd_attr_beta, cd_attr_gamma = cd_explainer.attributions(inputs=x_test,
batch_size=100,
output_indices=0)
cd_group_beta, cd_group_gamma = cd_explainer.interactions(inputs=x_test,
batch_size=100,
output_indices=0)
#Subtract feature attributions from group attributions, as discussed in the original paper
cd_interactions_beta = cd_group_beta - cd_attr_beta[:, :, np.newaxis] - cd_attr_beta[:, np.newaxis, :]
cd_interactions_beta[:, np.arange(num_features), np.arange(num_features)] = cd_attr_beta
cd_interactions_gamma = cd_group_gamma - cd_attr_gamma[:, :, np.newaxis] - cd_attr_gamma[:, np.newaxis, :]
cd_interactions_gamma[:, np.arange(num_features), np.arange(num_features)] = cd_attr_gamma
###### Neural Interaction Detection ######
nid_explainer = NeuralInteractionDetectionExplainerTF(model)
nid_interactions = nid_explainer.interactions(output_index=0,
verbose=False,
inputs=x_test,
batch_size=100)
###### Input Hessian ######
grad_explainer = GradientExplainerTF(interpret_model)
hess_interactions = grad_explainer.interactions(inputs=x_test,
multiply_by_input=False,
batch_size=100,
output_index=0)
hess_times_inp_interactions = grad_explainer.interactions(inputs=x_test,
multiply_by_input=True,
batch_size=100,
output_index=0)
interaction_dict = {
'integrated_hessians': ih_interactions,
'expected_hessians': eh_interactions,
'contextual_decomposition_beta': cd_interactions_beta,
'contextual_decomposition_gamma': cd_interactions_gamma,
'neural_interaction_detection': nid_interactions,
'hessian': hess_interactions,
'hessian_times_input': hess_times_inp_interactions
}
# Zero diagonals
for key in interaction_dict:
interaction_dict[key][:, np.arange(num_features), np.arange(num_features)] = 0.0
return interaction_dict
def get_metrics(x_test,
interaction_dict,
chosen_pairs):
pair_interactions = []
for pair in chosen_pairs:
pair_interactions.append(np.prod(x_test[:, pair], axis=1))
pair_interactions = np.stack(pair_interactions, axis=1)
interaction_ordering = np.argsort(np.abs(pair_interactions), axis=1)
maximum_interaction_index = interaction_ordering[:, -1]
maximum_interaction_pair = chosen_pairs[maximum_interaction_index]
metric_dict = {}
for key in interaction_dict:
interaction = interaction_dict[key]
abs_interaction = np.abs(interaction)
current_max_pair = abs_interaction.reshape(abs_interaction.shape[0], -1).argmax(1)
current_max_pair = np.column_stack(np.unravel_index(current_max_pair,
abs_interaction[0].shape))
mask_pairs = (current_max_pair == maximum_interaction_pair)
top_1_accuracy = np.sum(np.sum(mask_pairs, axis=1) == 2) / len(mask_pairs)
metric_dict[key] = top_1_accuracy
return metric_dict
def train(x_train, y_train, x_test, y_test, model,
learning_rate=0.01, epochs=30, batch_size=100):
loss = tf.keras.losses.MeanSquaredError()
metrics = [tf.keras.metrics.MeanAbsoluteError()]
optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate)
model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1)
model.evaluate(x_test, y_test, batch_size=batch_size, verbose=1)
print('Variance of the test labels: {:.4f}'.format(np.var(y_test)))
def test_simple_multiplicative():
x_train, y_train, x_test, y_test, chosen_pairs = build_data(num_features=5,
num_interacting_pairs=2,
num_samples=5000)
model = build_model(num_features=x_train.shape[1])
train(x_train, y_train, x_test, y_test, model)
interaction_dict = get_interactions(x_train, y_train, x_test, y_test, model)
metric_dict = get_metrics(x_test,
interaction_dict,
chosen_pairs)
for key in metric_dict:
print('{}: {:.4f}'.format(key, metric_dict[key]))
if __name__ == '__main__':
test_simple_multiplicative()
|
436078
|
class Solution:
def maxArea(self, height):
left, right, mx = 0, len(height) - 1, 0
while left < right:
mx = max(mx, (right - left) * min(height[left], height[right]))
if height[left] < height[right]:
left += 1
else:
right -= 1
return mx
|
436086
|
from django.apps import AppConfig
class NewsHunterConfig(AppConfig):
name = 'apps.news_hunter'
|
436106
|
import dash
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd
from sqlalchemy import create_engine
# Create a simple database
engine = create_engine('sqlite:///sample.db')
df = pd.DataFrame({
'a': [1, 2, 3, 4, 5, 6],
'b': ['x', 'y', 'x', 'x', 'z', 'y']
})
df.to_sql('dataframe', engine, if_exists='replace')
# Dash
def generate_table(dataframe, max_rows=10):
return html.Table(
# Header
[html.Tr([html.Th(col) for col in dataframe.columns])] +
# Body
[html.Tr([
html.Td(dataframe.iloc[i][col]) for col in dataframe.columns
]) for i in range(min(len(dataframe), max_rows))]
)
app = dash.Dash()
app.layout = html.Div([
dcc.Dropdown(
id='dropdown',
options=[{'label': i, 'value': i} for i in df.b.unique()],
value='x',
clearable=False
),
html.Div(id='table-container')
])
@app.callback(
dash.dependencies.Output('table-container', 'children'),
[dash.dependencies.Input('dropdown', 'value')])
def sql(value):
dff = pd.read_sql_query(
'SELECT a, b FROM dataframe WHERE b = "{}"'.format(value),
engine
)
return generate_table(dff)
if __name__ == '__main__':
app.run_server(debug=True)
|
436115
|
import math
from PIL import Image
import torch.nn.functional as F
import torch
def unpadding(image, padding):
b, c, h ,w = image.shape
image = image[...,padding:h-padding, padding:w-padding]
return image
def preprocess(image:Image, padding=32, patch_size=1024, transform=None, cuda=True, square=False):
W, H = image.size
N = math.ceil(math.sqrt((W * H) / (patch_size ** 2)))
W_ = math.ceil(W / N) * N + 2 * padding
H_ = math.ceil(H / N) * N + 2 * padding
w = math.ceil(W / N) + 2 * padding
h = math.ceil(H / N) + 2 * padding
if square:
w = patch_size + 2 * padding
h = patch_size + 2 * padding
if transform is not None:
image = transform(image)
image = image.unsqueeze(0)
if cuda:
image = image.cuda()
p_left = (W_ - W) // 2
p_right = (W_ - W) - p_left
p_top = (H_ - H) // 2
p_bottom = (H_ - H) - p_top
image = F.pad(image, [p_left, p_right, p_top, p_bottom], mode="reflect")
b, c, _, _ = image.shape
images = F.unfold(image, kernel_size=(h, w), stride=(h-2*padding, w-2*padding))
B, C_kw_kw, L = images.shape
images = images.permute(0, 2, 1).contiguous()
images = images.view(B, L, c, h, w).squeeze(dim=0)
return images
def image_process(image):
image = image.permute(1, 2, 0).mul_(255.0).add_(0.5).clamp_(0, 255)
image = image.to(torch.uint8).cpu().data.numpy()
return image
|
436130
|
import rmc.shared.constants as c
import rmc.models as m
import rmc.data.evals.conversion as conv
import mongoengine as me
import sys
def import_all_critiques(eng_file):
m.CritiqueCourse.objects._collection.drop()
conv.import_engineering_critiques(eng_file)
if __name__ == '__main__':
if (len(sys.argv) < 2):
print 'Please pass the Eng data filename as the first Argument'
sys.exit()
me.connect(c.MONGO_DB_RMC, host=c.MONGO_HOST, port=c.MONGO_PORT)
eng_file = open(sys.argv[1], 'r')
import_all_critiques(eng_file)
|
436152
|
expected_output = {
"interfaces": {
"Ethernet1/1": {
"interface": "Ethernet1/1",
"statistics": {
"txreq": 0,
"rxlogoff": 0,
"txtotal": 3,
"txreqid": 0,
"lastrxsrcmac": "00:00:00:ff:00:00",
"rxinvalid": 0,
"rxrespid": 0,
"rxlenerr": 0,
"rxversion": 0,
"rxstart": 0,
"rxresp": 0,
"rxtotal": 0,
},
}
}
}
|
436164
|
from setuptools import setup, find_packages
setup(
name = "appJar",
version = "0.93",
packages = find_packages()
)
|
436185
|
import os
import re
WIKI_PATH = "../../../agk-steam-plugin.wiki/"
error_count = 0
"""
Page Tag Information:
@page The rest of the line is the page name/Steam class for the file. Additional lines are for the page description.
Method Tag Information
@desc The method description. Can be multiple lines.
@param First word is the parameter name. The rest is the description. One per parameter.
@param-url The url for the parameter. (optional)
@return The return description.
@return-url The reference url for the return value. Only one allowed. (optional)
@plugin-name The method name for Commands.txt. Used to create method overrides. (optional)
@callback-type Optional, but must be:
'list' - A callback that returns a list.
'bool' - A callback that is a boolean.
'callresult' - A callresult function.
@callback-getters Comma-delimited list of methods for getting callback information. Can be multiple lines.
@callbacks Obsolete.
@url Reference urls. Multiple tags allowed.
"""
_METHODS_WITH_NO_URL = [
"GetCommandLineArgsJSON",
"GetSteamPath",
"IsSteamEmulated",
"SetFileAttributes",
"DeleteCallResult",
"IsSteamIDValid",
"GetAccountID",
"GetSteamID64",
"GetHandleFromSteamID64",
]
def report_error(text):
global error_count
error_count += 1
print("ERROR:\t" + text)
class ExportedMethodLoader:
CPP_TO_TIER1_VAR_TYPES = {
'void': None,
'int': 'integer',
'float': 'float',
'char*': 'string',
'constchar*': 'string',
}
def __init__(self, path: str):
# self._filename = filename
self.pages = []
self.method_count = 0
for (root, _, filenames) in os.walk(path):
for filename in [f for f in filenames if f.endswith('.cpp') or f.endswith('.h')]:
with open(os.path.join(root, filename), 'r') as f:
# print(f"Loading {filename}...")
lines = ''.join(f.readlines())
pages = self._get_page_tags(lines)
methods = self._get_methods(lines)
if len(methods):
self.method_count += len(methods)
self._validate_callback_tags(methods)
self._assign_methods_to_pages(pages, methods)
# check urls
for method in methods:
if method["name"] in _METHODS_WITH_NO_URL:
if 'url' in method:
report_error(f"{method['name']} has an unexpected URL.")
else:
if 'url' not in method:
report_error(f"{method['name']} has no URL.")
self._merge_page_list(pages)
self.page_count = len(self.pages)
# Alphabetize the pages
self.pages.sort(key=lambda page: page['name'])
def _merge_page_list(self, pages):
for page in pages:
page_index = next((i for i, p in enumerate(self.pages) if p["name"] == page['name']), None)
if page_index is None:
self.pages.append(page)
else:
self.pages[page_index]['methods'].extend(page['methods'])
@classmethod
def _get_tier_1_var_type(cls, cpp_var_type):
return cls.CPP_TO_TIER1_VAR_TYPES[cpp_var_type.replace(' ', '')]
@classmethod
def _get_page_tags(cls, lines: str):
pages = []
for match in re.finditer(r'(?:/\*+\s*@page\s+)(?P<tag_info>(?:(?!\*+/).)*)\*+/',
lines, re.DOTALL | re.MULTILINE):
name, sep, desc = match.group('tag_info').partition('\n')
pages.append({
'name': name.strip(),
'desc': desc.strip(),
'start': match.start(),
'filename': f"{name.strip().replace(' ', '-')}.md",
})
return pages
@classmethod
def _get_methods(cls, lines: str):
type_pattern = r'void\s+|int\s+|(?:const\s+)?char\s*\*\s*|float\s+'
name_pattern = r'[A-Za-z0-9_]+'
methods = []
last_method_name = None
for match in re.finditer(r'(?:/\*+(?P<comment>(?:(?!\*+/).)*)\*+/\n)?'
r'^extern "C" DLL_EXPORT '
# type name (params)
r'(?P<type>{type_pattern})(?P<name>{id_name})\((?P<params>[^)]+?)?\)'
r';?'.format(type_pattern=type_pattern, id_name=name_pattern),
lines, re.DOTALL | re.MULTILINE):
# Parse method name and return type.
# method_declaration = declaration_pattern.match(match['method'])
# Skip methods with multiple definitions due to #ifdefs. ie: To remove parameters for Linux, etc.
if match['name'] == last_method_name:
continue
last_method_name = match['name']
method = {
'name': match['name'],
'start': match.start(),
'params': [],
}
return_type = cls._get_tier_1_var_type(match['type'])
if return_type:
method['return_type'] = return_type
# Parse parameter names and types.
if match['params']:
for param in match['params'].split(','):
param_match = re.match(r'(?P<type>{type_pattern})(?P<name>{name_pattern})'.
format(type_pattern=type_pattern, name_pattern=name_pattern),
param.strip())
method['params'].append({
'name': param_match['name'],
'type': cls._get_tier_1_var_type(param_match['type'])
})
# Parse comment tags
if cls._load_method_tags(method, match['comment']):
methods.append(method)
return methods
@classmethod
def _load_method_tags(cls, method, comment):
if not comment:
report_error(f"{method['name']} has no documentation.")
return True
if '@ignore' in comment:
# ignored export.
return False
def get_param_index(params, name):
return next((i for i, p in enumerate(params) if p["name"] == name), None)
def process_desc_tag(tag_text):
if 'desc' in method:
report_error(f"{method['name']} has multiple desc tags.")
return
method['desc'] = tag_text
def process_return_tag(tag_text):
if 'return_desc' in method:
report_error(f"{method['name']} has multiple return-desc tags.")
return
method['return_desc'] = tag_text
def process_return_url_tag(tag_text):
if 'return_url' in method:
report_error(f"{method['name']} has multiple return-url tags.")
return
method['return_url'] = tag_text
def process_param_tag(tag_text):
param_name, sep, tag_text = tag_text.partition(' ')
if not tag_text:
report_error(f"{method['name']} has an empty description for parameter: {param_name}")
return
index = get_param_index(method['params'], param_name)
if index is None:
report_error(f"{method['name']} has a description for an unknown parameter: {param_name}")
return
if 'desc' in method['params'][index]:
report_error(f"{method['name']} has multiple param tags for: {param_name}")
return
method['params'][index]['desc'] = tag_text
def process_param_url_tag(tag_text):
param_name, sep, tag_text = tag_text.partition(' ')
if not tag_text:
report_error(f"{method['name']} has an empty URL for parameter: {param_name}")
return
index = get_param_index(method['params'], param_name)
if index is None:
report_error(f"{method['name']} has a URL for an unknown parameter: {param_name}")
return
if 'url' in method['params'][index]:
report_error(f"{method['name']} has multiple param-url tags for: {param_name}")
return
method['params'][index]['url'] = tag_text
# def process_api_tag(tag_text):
# method['api'] = [api.strip() for api in tag_text.split(',')]
def process_url_tag(tag_text):
if ',' in tag_text or '\n' in tag_text:
report_error(f"{method['name']} had a url tag with multiple urls.")
return
if 'url' not in method:
method['url'] = []
if tag_text in method['url']:
report_error(f"{method['name']} had a duplicate url entry: {tag_text}")
return
method['url'].append(tag_text)
def process_plugin_name_tag(tag_text):
if 'plugin_name' in method:
report_error(f"{method['name']} already had a plugin-name tag.")
return
method['plugin_name'] = tag_text
def process_callback_type_tag(tag_text):
if tag_text not in ['list', 'bool', 'callresult']:
report_error("{} has an unknown callback type: {}".format(method['name'], tag_text))
return
if 'callback-type' in method:
report_error(f"{method['name']} has multiple callback-type tags.")
return
method['callback-type'] = tag_text
def process_callback_getters_tag(tag_text):
if 'callback-getters' in method:
report_error(f"{method['name']} has multiple callback-getters tags.")
return
method['callback-getters'] = [name.strip() for name in tag_text.split(',')]
def process_callbacks_tag(tag_text):
if 'callbacks' in method:
report_error(f"{method['name']} has multiple callbacks tags.")
return
# callbacks that fire as a result of the current method.
method['callbacks'] = [name.strip() for name in tag_text.split(',')]
method_apis = []
for tag in re.finditer(r'@(?P<name>[-a-z_0-9]+)\s+(?P<text>(?:(?!@).)*)', comment, re.DOTALL | re.MULTILINE):
tag_name = tag['name']
process_function = locals().get(f"process_{tag['name'].replace('-', '_')}_tag")
if process_function:
process_function(tag['text'].strip())
else:
report_error(f"{method['name']} has an unknown tag: {tag_name}")
# Final validation checks
if 'desc' not in method:
report_error(f"{method['name']} has no description.")
if 'return_type' in method:
if 'return_desc' not in method:
report_error(f"{method['name']} has a return type without a return description.")
else:
if 'return_desc' in method:
report_error(f"{method['name']} has a return description without a return type.")
for param in method['params']:
if 'desc' not in param:
report_error(f"{method['name']} has a parameter without a description: {param['name']}")
return True
@classmethod
def _validate_callback_tags(cls, methods):
for method in methods:
if 'callback-getters' in method:
if 'callback-type' not in method:
report_error(f"{method['name']} does not have a callback type.")
if method['callback-getters'] == '':
report_error(f"{method['name']} has an empty callback-getters tag.")
return
for getter in method['callback-getters']:
method_index = next((i for i, m in enumerate(methods) if m["name"] == getter), None)
if method_index is None:
report_error(f"{method['name']} has an unknown callback getter method: {getter}")
else:
if 'callback-parents' not in methods[method_index]:
methods[method_index]['callback-parents'] = []
methods[method_index]['callback-parents'].append(method['name'])
methods[method_index]['callback-parent-type'] = method['callback-type']
# callback parents attach their @url tags to each @callback-getters method.
if 'url' in method:
if 'url' not in methods[method_index]:
methods[method_index]['url'] = []
for url in method['url']:
if url not in methods[method_index]['url']:
methods[method_index]['url'].append(url)
@classmethod
def _assign_methods_to_pages(cls, pages, methods):
for page in pages:
page['methods'] = []
for method in methods:
try:
page = [p for p in pages if p['start'] <= method['start']][-1]
page['methods'].append(method)
method['page'] = page
except IndexError:
report_error(f"Could not find page for method: {method['name']}")
def write_commands_txt(self, out_file: str):
var_type_letter = {
None: '0',
'': '0',
'integer': 'I',
'float': 'F',
'string': 'S',
}
with open(out_file, 'w') as f:
f.write("#CommandName,ReturnType,ParameterTypes,Windows,Linux,Mac,Android,iOS,Windows64\n")
for page in [p for p in self.pages if p['methods']]:
# print(f"Page {page['name']} has {len(page['methods'])} methods")
f.write("#\n")
f.write(f"# {page['name']}\n")
f.write("#\n")
for method in page['methods']: # type: dict
param_types = ''.join([var_type_letter[v['type']] for v in method['params']]) \
if method['params'] else '0'
f.write('{plugin_method_name},{return_type},{param_types},'
'{windows},{linux},{mac},{android},{ios},{windows64}\n'
.format(plugin_method_name=method.get('plugin_name', method['name']),
return_type=var_type_letter[method.get('return_type')],
param_types=param_types,
windows=method['name'],
linux=method['name'],
mac='0',
android='0',
ios='0',
windows64=method['name'],
)
)
@classmethod
def _get_url_title(cls, url: str):
# TODO Handle this?
# [Downloadable Content (DLC)](https://partner.steamgames.com/doc/store/application/dlc)
# -> Downloadable Content (DLC)
base, sep, title = url.rpartition('/')
# base, sep, title = title.rpartition('#')
return title
@classmethod
def _create_comma_list(cls, text_list):
if len(text_list) == 0:
return ""
if len(text_list) == 1:
return text_list[0]
return ', '.join(text_list[0:-1]) + ' or ' + text_list[-1]
def _get_method_link(self, method_name):
for page in self.pages:
if method_name in [m['name'] for m in page['methods']]:
return '[{0}]({1}#{0})'.format(method_name, page['name'].replace(' ', '-'))
report_error("Could not generate method link for {}".format(method_name))
return method_name
def write_wiki_files(self, base_path: str):
for page in [p for p in self.pages if p['methods']]:
with open(base_path + page['filename'], 'w') as f:
if 'desc' in page:
f.write(page['desc'])
f.write('\n\n')
for method in page['methods']: # type: dict
public_method_name = method.get("plugin_name", method["name"])
params_list = ', '.join(
('[{name} as {type}]({url})' if 'url' in param else '{name} as {type}').format(
**param) for param in method['params'])
syntax = f'{public_method_name}({params_list})' \
f'{" as " + method["return_type"] if "return_type" in method else ""}'
# print(syntax)
# Output the method wiki.
wiki_entry = f'## {public_method_name}\n'
wiki_entry += f'> {syntax}\n'
if method['params']:
wiki_entry += ''.join(f'> * _{p["name"]}_ - {p["desc"]} \n' for p in method['params'])
wiki_entry += '\n'
if 'desc' in method:
wiki_entry += '{0}\n\n'.format(method['desc'])
if 'callback-parents' in method:
if method['callback-parent-type'] == 'callresult':
parent_links = [self._get_method_link(name) for name in method['callback-parents']]
comma_list = self._create_comma_list(parent_links)
wiki_entry += '_This method should only be used when the call result returned by {} has ' \
'reported a GetCallResultCode of 1._'.format(comma_list)
else:
# Only one callback parent for other types.
wiki_entry += '_This method should only be used ' \
'when {} has returned 1._'.format(method['callback-parents'][0])
wiki_entry += '\n\n'
if 'return_desc' in method:
if 'return_url' in method:
wiki_entry += '**Returns:** [{return_desc}]({return_url})\n\n'.format(**method)
else:
wiki_entry += '**Returns:** {return_desc}\n\n'.format(**method)
if 'callback-getters' in method:
wiki_entry += '**Associated Methods:** \n'
wiki_entry += ' \n'.join(self._get_method_link(name) for name in method['callback-getters'])
wiki_entry += '\n\n'
if 'url' in method:
wiki_entry += '**Reference:** \n'
wiki_entry += ' \n'.join(('[{0}]({1})'.format(self._get_url_title(url), url)
for url in method['url']))
wiki_entry += '\n\n'
f.write(wiki_entry)
# print(wiki_entry)
loader = ExportedMethodLoader('../../SteamPlugin/Common/')
loader.write_commands_txt('../../AGKPlugin/SteamPlugin/Commands.txt')
print("Error count: {}".format(error_count))
print("Page count: {}".format(len(loader.pages)))
print("Method count: {}".format(loader.method_count))
loader.write_wiki_files(WIKI_PATH)
|
436186
|
from flask import Flask, Response, stream_with_context, render_template, json, url_for
from kafka import KafkaConsumer
from settings import *
# create the flask object app
app = Flask(__name__)
def stream_template(template_name, **context):
print('template name =',template_name)
app.update_template_context(context)
t = app.jinja_env.get_template(template_name)
rv = t.stream(context)
rv.enable_buffering(5)
return rv
def is_suspicious(transaction: dict) -> bool:
"""Determine whether a transaction is suspicious."""
return transaction["amount"] >= 900
# this router will render the template named index.html and will pass the following parameters to it:
# title and Kafka stream
@app.route('/')
def index():
def g():
consumer = KafkaConsumer(
TRANSACTIONS_TOPIC
, bootstrap_servers=KAFKA_BROKER_URL
, value_deserializer=lambda value: json.loads(value)
,
)
for message in consumer:
transaction: dict = message.value
topic = FRAUD_TOPIC if is_suspicious(transaction) else LEGIT_TOPIC
print(topic, transaction) # DEBUG
yield topic, transaction
return Response(stream_template('index.html', title='Fraud Detector / Kafka',data=g()))
if __name__ == "__main__":
app.run(host="localhost" , debug=True)
|
436247
|
import pandas as pd
class ssoisPrecovery():
"""
This class is designed to use the Solar System Object Image Search (SSOIS) website provided by CADC
and accessible at this website: https://www.cadc-ccda.hia-iha.nrc-cnrc.gc.ca/en/ssois/index.html.
When using this we should make sure to include the attributions from the website:
`
For more information about the inner workings of SSOIS, please read the the following paper:
[<NAME> (2012)](http://adsabs.harvard.edu/abs/2012PASP..124..579G) .
Please cite this paper in your publications.
If you have used CADC facilities for your research,
please include the following acknowledgment in your publications:
*This research used the facilities of the Canadian Astronomy Data Centre operated by the
National Research Council of Canada with the support of the Canadian Space Agency.*
`
"""
def format_search_by_arc_url(self, mpc_file, start_year=1990,
start_month=1, start_day=1,
end_year=2020, end_month=8, end_day=1):
"""
Create the correct url for SSOIS query by arc
Inputs
------
mpc_file: str
Filename for mpc formatted file containing observations of object.
start_year ... end_day: int
The dates for the start and end windows of possible precovery imaging dates.
Note that the first date allowed is Jan. 1 1990.
Returns
-------
base_url: str
URL for the SSOIS that will return the desired search results.
"""
mpc_file_string_list = []
with open(mpc_file, 'r') as file:
for line in file:
mpc_file_string_list.append(line)
base_url = 'http://www.cadc-ccda.hia-iha.nrc-cnrc.gc.ca/cadcbin/ssos/ssosclf.pl?lang=en;obs='
for line in mpc_file_string_list:
for char in line:
if char == ' ':
base_url += '+'
elif char == '\n':
base_url += '%0D%0A'
else:
base_url += char
base_url += ';search=bern'
base_url += ';epoch1={}+{:02}+{:02}'.format(start_year, start_month, start_day)
base_url += ';epoch2={}+{:02}+{:02}'.format(end_year, end_month, end_day)
base_url += ';eunits=bern;extres=no;xyres=no;format=tsv'
return base_url
def query_ssois(self, url):
"""
Gathers results from SSOIS service and returns them in a pandas dataframe.
Input
-----
url: str
URL for search through SSOIS service
Returns
-------
results_df: pandas dataframe
Pandas dataframe containing search results
"""
results_df = pd.read_csv(url, delimiter='\t')
# Avoid problems querying column in pandas with '/' in name
results_df.rename(columns={'Telescope/Instrument':'Telescope_or_Instrument'}, inplace=True)
return results_df
|
436281
|
from rasa.engine.graph import GraphComponent
from rasa.engine.recipes.default_recipe import DefaultV1Recipe
@DefaultV1Recipe.register(
component_types=[DefaultV1Recipe.ComponentType.INTENT_CLASSIFIER],
is_trainable=True,
model_from="SpacyNLP",
)
class MyComponent(GraphComponent):
...
|
436287
|
from .time import Timer
def train_kfold(model, x_train, y_train, x_test=None, folds=5, metrics=None, predict_type='predict_proba', stratify=None, random_state=1337, skip_checks=False):
"""Trains a set of sklearn models with chosen parameters on a KFold split dataset, returning full out-of-fold
training set predictions (useful for stacking) as well as test set predictions and the models themselves.
Test set predictions are generated by averaging predictions from all the individual fold models - this means
1 model fewer has to be trained and from my experience performs better than retraining a single model on the full set.
Optionally, the split can be stratified along a passed array.
Keyword arguments:
model -- An instance of an (untrained) sklearn-style model with fit & predict methods
x_train -- The training set features
y_train -- The training set labels
x_test (optional) -- The test set features
metrics (optional) -- A metric or list of metric functions to use for evaluating the models
predict_type (default: 'predict_proba') -- Must be one of ['predict', 'predict_proba'], which prediction method to call on the trained sklearn models
folds (default: 5) -- The number of folds to perform
stratify (optional) -- An array to stratify the splits along
random_state (default: 1337) -- Random seed for splitting folds
skip_checks -- By default, this function tries to reorder the test set columns to match the order of the training set columns. Set this to disable this behaviour.
Returns:
models -- a list of trained xgboost.Booster objects
p_train -- Out-of-fold training set predictions (shaped like y_train)
p_test -- Mean of test set predictions from the models. Returns None if 'x_test' was not provided.
"""
from sklearn.model_selection import KFold, StratifiedKFold # Optional dependencies
from sklearn.base import clone
import numpy as np
assert predict_type in ['predict', 'predict_proba'], "predict_type must be set to one of ['predict', 'predict_proba']"
# If it's a dataframe, we can take column names, otherwise just use column indices.
if hasattr(x_train, 'columns'):
columns = x_train.columns.values
columns_exists = True
else:
columns_exists = False
x_train = np.asarray(x_train)
y_train = np.array(y_train)
if not hasattr(metrics, '__iter__'):
metrics = [metrics]
if x_test is not None:
if columns_exists and not skip_checks:
try:
x_test = x_test[columns]
except Exception as e:
print('[mlcrate] Could not coerce x_test columns to match x_train columns. Set skip_checks=True to run anyway.')
raise e
x_test = np.asarray(x_test)
if not skip_checks and x_test is not None:
assert x_train.shape[1] == x_test.shape[1], "x_train and x_test have different numbers of features."
print('[mlcrate] Training {} {}{} models on training set {} {}'.format(folds, 'stratified ' if stratify is not None else '', type(model),
x_train.shape, 'with test set {}'.format(x_test.shape) if x_test is not None else 'without a test set'))
# Init a timer to get fold durations
t = Timer()
if stratify is not None:
kf = StratifiedKFold(n_splits=folds, shuffle=True, random_state=random_state)
splits = kf.split(x_train, stratify)
else:
kf = KFold(n_splits=folds, shuffle=True, random_state=4242)
splits = kf.split(x_train)
p_train = np.zeros_like(y_train, dtype=np.float32)
ps_test = []
models = []
fold_i = 0
for train_kf, valid_kf in splits:
print('[mlcrate] Running fold {}, {} train samples, {} validation samples'.format(fold_i, len(train_kf), len(valid_kf)))
x_tr, y_tr = x_train[train_kf], y_train[train_kf]
x_va, y_va = x_train[valid_kf], y_train[valid_kf]
# Start a timer for the fold
t.add('fold{}'.format(fold_i))
mdl = clone(model)
mdl.fit(x_tr, y_tr)
if predict_type == 'predict':
p_va = model.predict(x_va)
if x_test:
p_test = model.predict(x_test)
else:
p_va = model.predict_proba(x_va)
if x_test:
p_test = model.predict_proba(x_test)
p_train[valid_kf] = p_va
if metrics:
valid_scores = [metric(y_va, p_va) for metric in metrics]
else:
valid_scores = 'Set metrics to see scores!'
print('[mlcrate] Finished training fold {} - took {} - scores: {}'.format(fold_i, t.format_elapsed('fold{}'.format(fold_i)), valid_scores))
if x_test:
ps_test.append(p_test)
models.append(mdl)
fold_i += 1
if metrics:
scores = [metric(y_train, p_train) for metric in metrics]
else:
scores = 'Set metrics to see scores!'
if x_test is not None:
p_test = np.mean(ps_test, axis=0)
else:
p_test = None
print('[mlcrate] Finished training {} models, took {} - CV scores: {}'.format(folds, t.format_elapsed(0), scores))
return models, p_train, p_test
|
436327
|
from dataclasses import dataclass
from collections import OrderedDict
from typing import Dict
from typing import List
from typing import Iterable
@dataclass
class Benchmark:
name: str
values: Dict[str, float]
is_nuisance: bool = False
is_reference: bool = False
@classmethod
def from_params(cls, name: str, param_names: Iterable[str], param_values: Iterable[float]):
"""
Creates an instance from lists of parameter names and values
Parameters
----------
name: str
param_names: list
param_values: list
Returns
-------
Benchmark
"""
return cls(
name=name,
values=OrderedDict(
(p_name, p_value)
for p_name, p_value in zip(param_names, param_values)
),
)
def __str__(self) -> str:
"""
Formats the benchmark in a nice way
Returns
-------
Formatted benchmark string
"""
return f"{self.name}: {', '.join(self._format_values())}"
def _format_values(self, precision: int = 2) -> List[str]:
"""
Formats the dictionary of parameter values
Parameters
----------
precision: int (optional)
Precision to be used when displaying the values. Default = 2
Returns
-------
formatted_pairs: list
List of string formatted name - value pairs
"""
lower_limit = (10.00 ** -precision) * 2.0
upper_limit = (10.00 ** +precision)
formatted_pairs = []
for parameter_name, parameter_value in self.values.items():
if lower_limit < parameter_value < upper_limit:
template = f"{{0:.{precision}f}}"
else:
template = f"{{0:.{precision}e}}"
formatted_pairs.append(
f"{parameter_name} = "
f"{template.format(parameter_value)}"
)
return formatted_pairs
@dataclass
class FiniteDiffBenchmark:
base_name: str
shift_names: Dict[str, str]
@classmethod
def from_params(cls, base_name: str, param_names: Iterable[str], shift_names: Iterable[str]):
"""
Creates an instance from lists of parameter names and shift names
Parameters
----------
base_name: str
param_names: list
shift_names: list
Returns
-------
Benchmark
"""
return cls(
base_name=base_name,
shift_names=OrderedDict(
(p_name, shift_name)
for p_name, shift_name in zip(param_names, shift_names)
),
)
|
436338
|
from django.contrib.auth.models import User
def get_user(username='testuser', password='<PASSWORD>', email='testuser@<EMAIL>'):
user = User.objects.get_or_create(username=username)[0]
user.set_password(password)
user.email = email
user.is_active = True
user.save()
return user
|
436357
|
import time
from tkinter import *
from tkinter import messagebox
# Creating the Tk window
root = Tk()
# Setting geometry of tk window
root.geometry("300x250")
# Using title() to display a message in the dialogue box of the message in the title bar.
root.title("Timer")
# Declaration of variables
hour=StringVar()
minute=StringVar()
second=StringVar()
# Setting the default value as 0
hour.set("00")
minute.set("00")
second.set("00")
# Using Entry class to take input from the user
hourEntry= Entry(root, width=3, font=("Arial",18,""),
textvariable=hour)
hourEntry.place(x=80,y=20)
minuteEntry= Entry(root, width=3, font=("Arial",18,""),
textvariable=minute)
minuteEntry.place(x=130,y=20)
secondEntry= Entry(root, width=3, font=("Arial",18,""),
textvariable=second)
secondEntry.place(x=180,y=20)
def submit():
try:
# The input provided by the user is stored here in this variable temp
temp = int(hour.get())*3600 + int(minute.get())*60 + int(second.get())
except:
print("Please input the right value")
while temp >-1:
# divmod(firstvalue = temp//60, secondvalue = temp%60)
mins,secs = divmod(temp,60)
# Converting the input entered in mins or secs to hours, mins ,secs
# (input = 110 min --> 120*60 = 6600 => 1hr : 50min: 0sec)
hours=0
if mins >60:
# divmod(firstvalue = temp//60, secondvalue = = temp%60)
hours, mins = divmod(mins, 60)
# Using the format() method to store the value up to two decimal places
hour.set("{0:2d}".format(hours))
minute.set("{0:2d}".format(mins))
second.set("{0:2d}".format(secs))
# Updating the GUI window after decrementing the temp value every time
root.update()
time.sleep(1)
# When the valur of temp = 0; then the messagebox pops up with a message: "Time's up"
if (temp == 0):
messagebox.showinfo("Timer", "Time's up!")
# After every one sec the value of temp will be decremented by one
temp -= 1
# Button widget
btn = Button(root, text='Start Timer', bd='5',
command= submit)
btn.place(x = 112,y = 120)
# Using infinite loop which to make sure the tkinter window is open until the user closes it
root.mainloop()
|
436378
|
import gtk
import gtk.glade
import sys
sys.path.append("../../pyjs/") # lkcl: quick hack
from pyjs import *
def clicked(widget=None):
code = buf1.get_text(*buf1.get_bounds())
output = cStringIO.StringIO()
mod = compiler.parse(code)
module = name.get_text()
t = Translator(module,mod,output)
buf2.set_text(output.getvalue())
xml = gtk.glade.XML('convert.glade')
t1 = xml.get_widget('textview1')
t2 = xml.get_widget('textview2')
btn = xml.get_widget('btnConvert')
buf1 = gtk.TextBuffer()
buf2 = gtk.TextBuffer()
t1.set_buffer(buf1)
t2.set_buffer(buf2)
name = xml.get_widget('entryname')
btn.connect('clicked',clicked)
window = xml.get_widget('window1')
import sys
window.connect('destroy',sys.exit)
window.show()
gtk.main()
|
436430
|
from cvtron.modeling.segmentor.ImageSegmentor import ImageSegmentor
from cvtron.trainers.segmentor.deeplab_trainer import DeepLabTrainer
from cvtron.utils.config_loader import MODEL_ZOO_PATH
config = {
'batch_norm_epsilon':1e-5,
'batch_norm_decay':0.9997,
'number_of_classes':21,
'l2_regularizer':0.0001,
'starting_learning_rate':0.00001,
'multi_grid':[1,2,4],
'output_stride':16,
'gpu_id':0,
'resnet_model':'resnet_v2_50',
'train_filename':'/home/sfermi/Documents/Programming/project/cv/tmp/train.tfrecords',
'train_buffer_size':500,
'batch_size':1,
'valid_filename':'/home/sfermi/Documents/Programming/project/cv/tmp/validation.tfrecords',
'valid_buffer_size':100,
'log_folder':'/home/sfermi/Documents/Programming/project/web/cvtron-serve/cvtron-serve/static/log',
'log_per_step':1,
'train_steps':100,
'eval_steps':100,
}
def get_segmentor(model_name='deeplabv3',
model_path=MODEL_ZOO_PATH):
if model_name not in ['deeplabv3']:
raise NotImplementedError
imageSegmentor = ImageSegmentor(MODEL_ZOO_PATH, config)
imageSegmentor._init_model_()
return imageSegmentor
def get_segmentor_trainer(config):
dlt = DeepLabTrainer(config)
return dlt
def get_defaultConfig():
return config
|
436468
|
from django.db import models
from wagtail.core.fields import StreamField
from wagtail.core.blocks import StructBlock, PageChooserBlock, TextBlock, ListBlock
from wagtail.admin.edit_handlers import FieldPanel, InlinePanel, StreamFieldPanel
from wagtail.snippets.edit_handlers import SnippetChooserPanel
from wagtail.images.edit_handlers import ImageChooserPanel
from base.forms import GuidePageForm
from pages.information_page.models import InformationPage
from pages.service_page.models import ServicePage
from snippets.contact.models import Contact
from base.models.translated_image import TranslatedImage
from base.models.widgets import countMe, countMeTextArea
from publish_preflight.requirements import FieldPublishRequirement, RelationPublishRequirement, StreamFieldPublishRequirement, ConditionalPublishRequirement, DepartmentPublishRequirement
from pages.topic_page.models import JanisBasePageWithTopics
def streamfield_has_pages(stream_value):
"""
Confirms the stream_value has data and the data contains both pages and an english section_heading
Used in publishing requirement
:return: boolean
"""
if stream_value:
stream_data = stream_value.stream_data
# check that we have any data in the streamfield
if stream_data:
struct_value = stream_data[0][1]
if struct_value.get('pages') and struct_value.get('section_heading_en'):
return True
return False
class GuidePage(JanisBasePageWithTopics):
"""
A guide page aggregates several pages together into a user-friendly view
Since the number of related pages in a section could be arbitrary, it's
implemented using Streamfields
"""
janis_url_page_type = "guide"
description = models.TextField(blank=True, verbose_name='Write a description of the guide')
image = models.ForeignKey(TranslatedImage, null=True, blank=True, on_delete=models.SET_NULL, related_name='+')
sections = StreamField(
[
('section', StructBlock(
[
('section_heading_en', TextBlock(label='Heading [en]')),
('section_heading_es', TextBlock(label='Heading [es]', required=False)),
('section_heading_ar', TextBlock(label='Heading [ar]', required=False)),
('section_heading_vi', TextBlock(label='Heading [vi]', required=False)),
('pages', ListBlock(
PageChooserBlock(label="Page", page_type=[InformationPage, ServicePage]),
help_text='Select existing pages in the order you want them \
to display within each heading.\
Pages should be added only once to any single guide.')
),
],
label="Section"
)),
],
verbose_name='Add a section header and pages to each section',
blank=True
)
contact = models.ForeignKey(Contact, related_name='+', blank=True, null=True, on_delete=models.SET_NULL)
base_form_class = GuidePageForm
publish_requirements = (
FieldPublishRequirement("description", message="A description is required for publishing", langs=["en"]),
FieldPublishRequirement("contact", message="A contact is required for publishing."),
StreamFieldPublishRequirement("sections", criteria=streamfield_has_pages),
ConditionalPublishRequirement(
RelationPublishRequirement("topics"),
"or",
DepartmentPublishRequirement(),
message="You must have at least 1 topic or 1 department selected.",
),
)
content_panels = [
FieldPanel('title_en', widget=countMe),
FieldPanel('title_es', widget=countMe),
FieldPanel('title_ar'),
FieldPanel('slug_en'),
FieldPanel('slug_es'),
FieldPanel('slug_ar'),
FieldPanel('slug_vi'),
FieldPanel('title_vi'),
FieldPanel('description', widget=countMeTextArea),
InlinePanel('topics', label='Topics'),
ImageChooserPanel('image'),
StreamFieldPanel('sections'),
SnippetChooserPanel('contact'),
]
|
436483
|
from enum import IntEnum, unique
import itertools
from color import Color32, remap_color
from utils import integer_to_bytes
@unique
class SpecialColor(IntEnum):
None_ = 0
Face = 1 # Uses the color of the face (based on a rainbow)
ColorWheel = 2 # Uses how hot the die is (based on how much its being shaken)
HeatCurrent = 3 # Uses the current 'heat' value to determine color
HeatStart = 4 # Evaluate the color based on heat only once at the start of the animation
@unique
class AnimationEvent(IntEnum):
None_ = 0
Hello = 1
Connected = 2
Disconnected = 3
LowBattery = 4
ChargingStart = 5
ChargingDone = 6
ChargingError = 7
Handling = 8
Rolling = 9
OnFace_Default = 10
OnFace_00 = 11
OnFace_01 = 12
OnFace_02 = 13
OnFace_03 = 14
OnFace_04 = 15
OnFace_05 = 16
OnFace_06 = 17
OnFace_07 = 18
OnFace_08 = 19
OnFace_09 = 20
OnFace_10 = 21
OnFace_11 = 22
OnFace_12 = 23
OnFace_13 = 24
OnFace_14 = 25
OnFace_15 = 26
OnFace_16 = 27
OnFace_17 = 28
OnFace_18 = 29
OnFace_19 = 30
Crooked = 31
Battle_ShowTeam = 32
Battle_FaceUp = 33
Battle_WaitingForBattle = 34
Battle_Duel = 35
Battle_DuelWin = 36
Battle_DuelLose = 37
Battle_DuelDraw = 38
Battle_TeamWin = 39
Battle_TeamLoose = 40
Battle_TeamDraw = 41
AttractMode = 42
Heat = 43
class Animation:
"""
ushort duration; // in ms
ushort tracksOffset; // offset into a global buffer of tracks
ushort trackCount;
byte animationEvent; // Die.AnimationEvent
byte specialColorType; // is really SpecialColor
"""
def __init__(self):
pass
def pack(self):
return bytes(
integer_to_bytes(self.duration, 2) +
integer_to_bytes(self.tracksOffset, 2) +
integer_to_bytes(self.trackCount, 2) +
integer_to_bytes(self.animationEvent, 1) +
integer_to_bytes(self.specialColorType, 1))
class AnimationTrack:
"""
ushort trackOffset; // offset into a global keyframe buffer
byte ledIndex; // 0 - 20
byte padding;
"""
def __init__(self):
pass
def pack(self):
return bytes(
integer_to_bytes(self.trackOffset, 2) +
integer_to_bytes(self.ledIndex, 1) +
[0]) # padding
class RGBTrack:
"""
ushort keyframesOffset; // offset into a global keyframe buffer
byte keyFrameCount; // Keyframe count
byte padding;
"""
def __init__(self):
pass
def __hash__(self):
return hash(tuple(self))
def __eq__(self, other):
return tuple(self) == tuple(other)
def __iter__(self):
yield self.keyframesOffset
yield self.keyFrameCount
def GetKeyframe(self, animSet, keyframeIndex):
assert(keyframeIndex < self.keyFrameCount)
return animSet.keyframes[self.keyframesOffset + keyframeIndex]
def pack(self):
return bytes(
integer_to_bytes(self.keyframesOffset, 2) +
integer_to_bytes(self.keyFrameCount, 1) +
[0]) # padding
class RGBKeyframe:
"""
ushort timeAndColor
"""
def __init__(self):
pass
def __hash__(self):
return hash(self.timeAndColor)
def __eq__(self, other):
return self.timeAndColor == other.timeAndColor
def pack(self):
return integer_to_bytes(self.timeAndColor, 2)
class EditKeyframe:
"""
float time = -1;
Color32 color;
"""
def __init__(self, json):
self.time = json['time']
self.color = Color32.create(json['color'])
def __hash__(self):
return hash(self.time, *tuple(self.color))
def __eq__(self, other):
return self.time == other.time and self.color == other.color
class EditTrack:
def __init__(self, json):
self.ledIndex = json['ledIndex'] if 'ledIndex' in json else -1
self.ledIndices = json['ledIndices'] if 'ledIndices' in json else []
self.keyframes = [EditKeyframe(t) for t in json['keyframes']] if 'keyframes' in json else []
@property
def empty(self):
return len(self.keyframes) == 0
@property
def duration(self):
return max(k.time for k in self.keyframes) if self.keyframes else 0
@property
def firstTime(self):
return self.keyframes[0].time if self.keyframes else 0
@property
def lastTime(self):
return self.keyframes[-1].time if self.keyframes else 0
class EditAnimation:
def __init__(self, json):
self.name = json['name'] if 'name' in json else ''
self.event = json['event'] if 'event' in json else 0
self.specialColorType = SpecialColor(json['specialColorType']) if 'specialColorType' in json else SpecialColor.None_
self.tracks = [EditTrack(t) for t in json['tracks']] if 'tracks' in json else []
@property
def empty(self):
return len(self.tracks) == 0
@property
def duration(self):
return 0 if self.empty else max(t.duration for t in self.tracks)
class AnimationSet:
MAX_COLOR_MAP_SIZE = 1 << 7
MAX_PALETTE_SIZE = MAX_COLOR_MAP_SIZE * 3
SPECIAL_COLOR_INDEX = MAX_COLOR_MAP_SIZE - 1
def __init__(self):
pass
@classmethod
def from_json_obj(cls, json):
anim = cls()
anim.assign_animations([EditAnimation(a) for a in json['animations']])
return anim
@classmethod
def from_json_file(cls, filename):
with open(filename) as f:
from json import load
anim = cls.from_json_obj(load(f))
print(f'Loaded {len(anim.animations)} animations from file: {filename}')
return anim
def assign_animations(self, animations):
# Collect all colors used and stuff them in the palette
colors = []
for anim in animations:
for animTrack in anim.tracks:
for keyframe in animTrack.keyframes:
color = keyframe.color
# Note: colors with alpha set to zero are special
if color.a != 0 and not color in colors:
colors.append(color)
# Copy r,g,b components in flat list
self.palette = [comp for color in [list(remap_color(c))[:3] for c in colors] for comp in color]
self.animations = []
self.tracks = []
self.rgb_tracks = []
self.keyframes = []
self.heat_track_index = -1
# Add animations
def ushort(i):
assert(i < 2**16)
return int(i)
def byte(i):
assert(i < 2**8)
return int(i)
currentTrackOffset = 0
currentKeyframeOffset = 0
for animIndex in range(len(animations)):
editAnim = animations[animIndex]
anim = Animation()
anim.duration = ushort(editAnim.duration * 1000)
anim.tracksOffset = ushort(currentTrackOffset)
anim.trackCount = ushort(sum(len(t.ledIndices) for t in editAnim.tracks))
anim.animationEvent = byte(editAnim.event)
anim.specialColorType = byte(editAnim.specialColorType)
self.animations.append(anim)
if editAnim.event == AnimationEvent.Heat:
self.heat_track_index = currentTrackOffset
# Now add tracks
for j in range(len(editAnim.tracks)):
editTrack = editAnim.tracks[j]
for led in editTrack.ledIndices:
track = AnimationTrack()
rgbTrack = RGBTrack()
rgbTrack.keyframesOffset = ushort(currentKeyframeOffset)
rgbTrack.keyFrameCount = byte(len(editTrack.keyframes))
track.trackOffset = ushort(len(self.rgb_tracks))
self.rgb_tracks.append(rgbTrack)
track.ledIndex = byte(led)
# Now add keyframes
for editKeyframe in editTrack.keyframes:
colorIndex = AnimationSet.SPECIAL_COLOR_INDEX
if editKeyframe.color.a != 0:
colorIndex = colors.index(editKeyframe.color)
keyframe = RGBKeyframe()
time = ushort(editKeyframe.time * 1000)
color = ushort(colorIndex)
keyframe.timeAndColor = ushort(((int(time / 20) & 0b111111111) << 7) | (int(colorIndex) & 0b1111111))
self.keyframes.append(keyframe)
currentKeyframeOffset += len(editTrack.keyframes)
self.tracks.append(track)
currentTrackOffset += sum(len(t.ledIndices) for t in editAnim.tracks)
self.compress()
def compress(self):
def ushort(i):
assert(i < 2**16)
return int(i)
# First try to find identical sets of keyframes in tracks
for t in range(len(self.rgb_tracks)):
trackT = self.rgb_tracks[t]
for r in range(t + 1, len(self.rgb_tracks)):
trackR = self.rgb_tracks[r]
# Only try to collapse tracks that are not exactly the same
if trackT != trackR:
if trackR.keyFrameCount == trackT.keyFrameCount:
# Compare actual keyframes
kfEquals = True
for k in range(trackR.keyFrameCount):
kfRk = trackR.GetKeyframe(self, k)
kfTk = trackT.GetKeyframe(self, k)
if kfRk != kfTk:
kfEquals = False
break
if kfEquals:
# Sweet, we can compress the keyframes
# Fix up any other tracks
for i in range(len(self.rgb_tracks)):
tr = self.rgb_tracks[i]
if tr.keyframesOffset > trackR.keyframesOffset:
tr.keyframesOffset -= trackR.keyFrameCount
self.rgb_tracks[i] = tr
# Remove the duplicate keyframes
newKeyframes = []
for i in range(trackR.keyframesOffset):
newKeyframes.append(self.keyframes[i])
for i in range(trackR.keyframesOffset + trackR.keyFrameCount, len(self.keyframes)):
newKeyframes.append(self.keyframes[i])
self.keyframes = newKeyframes
# And make R point to the keyframes of T
trackR.keyframesOffset = trackT.keyframesOffset
self.rgb_tracks[r] = trackR
# Then remove duplicate RGB tracks
t = 0
while t < len(self.rgb_tracks):
trackT = self.rgb_tracks[t]
r = t + 1
while r < len(self.rgb_tracks):
trackR = self.rgb_tracks[r]
if trackR == trackT:
# Remove track R and fix anim tracks
# Fix up other animation tracks
for j in range(len(self.tracks)):
trj = self.tracks[j]
if trj.trackOffset == r:
trj.trackOffset = ushort(t)
elif trj.trackOffset > r:
trj.trackOffset -= 1
if r == self.heat_track_index:
self.heat_track_index = ushort(t)
elif r < self.heat_track_index:
self.heat_track_index -= 1
# Remove the duplicate RGBTrack
newRGBTracks = []
for j in range(r):
newRGBTracks.append(self.rgb_tracks[j])
for j in range(r + 1, len(self.rgb_tracks)):
newRGBTracks.append(self.rgb_tracks[j])
self.rgb_tracks = newRGBTracks
r += 1
t += 1
# We should also remove duplicate anim tracks and animation
def pack(self):
data = []
data += self.palette
for kf in self.keyframes:
data += kf.pack()
for t in self.rgb_tracks:
data += t.pack()
for t in self.tracks:
data += t.pack()
for a in self.animations:
data += a.pack()
return data
if __name__ == "__main__":
AnimationSet.from_json_file('animation_set.json').pack()
AnimationSet.from_json_file('D20_animation_set.json').pack()
# with open("anim.bin", "wb") as f:
# f.write(bytearray(b))
|
436515
|
import sys
import csv
from search import search_string, description
res = []
def cloze_word(sentense, word, level="1"):
return sentense.lower().replace(word, "{{c"+level+"::"+word+"}}")
with open(sys.argv[1], 'r') as f:
contents = f.read()
items = contents.split("\n\n")
for item in items:
lines = item.split("\n")
word = lines[0]
exp = lines[1]
eg = lines[2:]
dct = search_string(word)
exp2 = cloze_word(description(word), word, "1")
for x in [{"sentence": cloze_word(x, word, "1"),"exp2": exp2, "exp": exp, "dict": dct } for x in eg]:
res.append(x)
with open('{0}.csv'.format(sys.argv[1]), 'w') as csv_file:
fieldnames = ['sentence','exp2', 'exp', 'dict']
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
for row in res:
print(row['sentence'])
writer.writerows(res)
|
436518
|
from crypto.identity.public_key import PublicKey
def test_private_key_from_passphrase(identity):
public_key = PublicKey.from_passphrase(identity['passphrase'])
assert public_key == identity['data']['public_key']
def test_private_key_from_hex(identity):
public_key = PublicKey.from_hex(identity['data']['public_key'])
assert isinstance(public_key, PublicKey)
assert public_key.to_hex() == identity['data']['public_key']
|
436526
|
from pymop.factory import get_problem, get_uniform_weights
# for some problems the pareto front does not need any parameters
pf = get_problem("tnk").pareto_front()
pf = get_problem("osy").pareto_front()
# for other problems the number of non-dominated points can be defined
pf = get_problem("zdt1").pareto_front(n_pareto_points=100)
# for DTLZ for example the reference direction should be provided, because the pareto front for the
# specific problem will depend on the factory for the reference lines
ref_dirs = get_uniform_weights(100, 3)
pf = get_problem("dtlz1", n_var=7, n_obj=3).pareto_front(ref_dirs)
|
436530
|
import sys
guards = []
for i, line in enumerate(sys.stdin):
if line.startswith("guard_"):
guards.append((i, line))
elif line.startswith("# bridge out of Guard"):
guardTag = line.split()[5]
for lineNo, guard in guards:
if guardTag in guard:
print "Guard", guardTag
print lineNo, guard
break
|
436531
|
import os
baseLoc = os.path.dirname(os.path.realpath(__file__)) + '/'
from gimpfu import *
import sys
sys.path.extend([baseLoc + 'gimpenv/lib/python2.7', baseLoc + 'gimpenv/lib/python2.7/site-packages',
baseLoc + 'gimpenv/lib/python2.7/site-packages/setuptools', baseLoc + 'MiDaS'])
from run import run_depth
from monodepth_net import MonoDepthNet
import MiDaS_utils as MiDaS_utils
import numpy as np
import cv2
import torch
def getMonoDepth(input_image,cFlag):
image = input_image / 255.0
out = run_depth(image, baseLoc+'weights/MiDaS/model.pt', MonoDepthNet, MiDaS_utils, target_w=640,f=cFlag)
out = np.repeat(out[:, :, np.newaxis], 3, axis=2)
d1,d2 = input_image.shape[:2]
out = cv2.resize(out,(d2,d1))
# cv2.imwrite("/Users/kritiksoman/PycharmProjects/new/out.png", out)
return out
def channelData(layer): # convert gimp image to numpy
region = layer.get_pixel_rgn(0, 0, layer.width, layer.height)
pixChars = region[:, :] # Take whole layer
bpp = region.bpp
# return np.frombuffer(pixChars,dtype=np.uint8).reshape(len(pixChars)/bpp,bpp)
return np.frombuffer(pixChars, dtype=np.uint8).reshape(layer.height, layer.width, bpp)
def createResultLayer(image, name, result):
rlBytes = np.uint8(result).tobytes();
rl = gimp.Layer(image, name, image.width, image.height, 0, 100, NORMAL_MODE)
region = rl.get_pixel_rgn(0, 0, rl.width, rl.height, True)
region[:, :] = rlBytes
image.add_layer(rl, 0)
gimp.displays_flush()
def MonoDepth(img, layer,cFlag):
imgmat = channelData(layer)
if imgmat.shape[0] != img.height or imgmat.shape[1] != img.width:
pdb.gimp_message(" Do (Layer -> Layer to Image Size) first and try again.")
else:
if torch.cuda.is_available() and not cFlag:
gimp.progress_init("(Using GPU) Generating disparity map for " + layer.name + "...")
else:
gimp.progress_init("(Using CPU) Generating disparity map for " + layer.name + "...")
if imgmat.shape[2] == 4: # get rid of alpha channel
imgmat = imgmat[:,:,0:3]
cpy = getMonoDepth(imgmat,cFlag)
createResultLayer(img, 'new_output', cpy)
register(
"MonoDepth",
"MonoDepth",
"Generate monocular disparity map based on deep learning.",
"<NAME>",
"Your",
"2020",
"MonoDepth...",
"*", # Alternately use RGB, RGB*, GRAY*, INDEXED etc.
[(PF_IMAGE, "image", "Input image", None),
(PF_DRAWABLE, "drawable", "Input drawable", None),
(PF_BOOL, "fcpu", "Force CPU", False)
],
[],
MonoDepth, menu="<Image>/Layer/GIML-ML")
main()
|
436533
|
import locale
# Convert a number for human consumption
#
# Divisor can be 1, 1000, 1024
#
# If the locale has been set before this
# function is called, then numbers appropriate to the
# locale will be retured. This is commonly done like:
# locale.setlocale(locale.LC_ALL,'')
#
# A divisor of 1 => the thousands seperator
# appropriate to ones locale is inserted.
#
# With other divisors the output is aligned
# in a 7 or 8 character column respectively,
# which one can strip() if the display is not
# using a fixed width font.
def number(num, divisor=1, power=""):
num=float(num)
if divisor == 1:
return locale.format("%.f",num,1)
elif divisor == 1000:
powers=[" ","K","M","G","T","P"]
elif divisor == 1024:
powers=[" ","Ki","Mi","Gi","Ti","Pi"]
else:
raise ValueError, "Invalid divisor"
if not power: power=powers[0]
while num >= 1000: #4 digits
num /= divisor
power=powers[powers.index(power)+1]
if power.strip():
num = locale.format("%6.1f",num,1)
else:
num = locale.format("%4.f ",num,1)
return "%s%s" % (num,power)
|
436560
|
FILE_TYPE_OPTIONS = {}
USAGE_RIGHT_OPTIONS = {}
ASPECT_RATIO_OPTIONS = {'tall': 't', 'square': 's', 'wide': 'w',
'panoramic': 'xw'}
IMAGE_SIZE_OPTIONS = {'any': '', 'icon': 'i', 'medium': 'm', 'large': 'l',
'exactly': 'ex', '400x300+': 'qsvga', '640x480+': 'vga',
'800x600+': 'svga', '1024x768+': 'xga', '2mp+': '2mp',
'4mp+': '4mp', '6mp+': '6mp', '8mp+': '8mp',
'10mp+': '10mp', '12mp+': '12mp', '15mp+': '15mp',
'20mp+': '20mp', '40mp+': '40mp', '70mp+': '70mp'}
def aspect_ratio_paramenter(option):
if not option:
return None
ASPECT_RATIO_PARAM = 'iar'
return ASPECT_RATIO_PARAM + ':' + ASPECT_RATIO_OPTIONS[option]
def image_size_parameter(option):
if not option:
return None
IMAGE_SIZE_PARAM = 'isz'
if isinstance(option, (tuple, list)):
width, height = option
values = ':{},iszw:{},iszh:{}'.format(IMAGE_SIZE_OPTIONS['exactly'],
width, height)
return IMAGE_SIZE_PARAM + values
else:
return IMAGE_SIZE_PARAM + ':' + IMAGE_SIZE_OPTIONS[option]
def image_aspect_parameters(aspect_ratio, image_size):
if any([aspect_ratio, image_size]) is False:
return None
else:
IMAGE_RELATED = 'tbs='
values = filter(lambda x: x is not None, [aspect_ratio, image_size])
options = ','.join(list(values))
return '{}{}'.format(IMAGE_RELATED, options)
def query_builder(query, image_size=None, aspect_ratio=None, page_number=0):
if query is None:
raise ValueError('query must have a value.')
SEARCH_TYPE = 'tbm'
IMAGES = 'isch'
SEARCH_TYPE_PARAM = '='.join([SEARCH_TYPE, IMAGES])
BASE_URL = 'https://www.google.com/search?' + SEARCH_TYPE_PARAM
# Add page number
PAGE_NUMBER = 'ijn'
page_number_param = '='.join([PAGE_NUMBER, str(page_number)])
URL = '&'.join([BASE_URL, page_number_param])
# Add query value
QUERY_TYPE = 'q'
query_param = '='.join([QUERY_TYPE, str(query)])
URL = '&'.join([URL, query_param])
# Add image aspects parameters
iar = aspect_ratio_paramenter(aspect_ratio)
isz = image_size_parameter(image_size)
image_aspect_param = image_aspect_parameters(iar, isz)
if image_aspect_param is not None:
URL = '&'.join([URL, image_aspect_param])
return URL
|
436631
|
import responses
import json
from .helpers import mock_file, ClientTestCase
class TestRefundRequestOrder(ClientTestCase):
def setUp(self):
super(TestRefundRequestOrder, self).setUp()
self.base_url = '{}/v2/refunds/'.format(self.base_url)
@responses.activate
def test_refund_request_order(self):
"""Test refund request order."""
init = mock_file('refund_request_order_payload')
result = mock_file('refund_request_order_response')
url = "https://stg-api.sandbox.paypay.ne.jp/v2/refunds"
responses.add(responses.POST, url, status=200, body=json.dumps(result))
self.assertEqual(self.client.Pending.refund_payment(init), result)
|
436665
|
from . import (augmenters, chroma, classify, data, experiment, features,
targets, test)
|
436676
|
from abc import abstractmethod
from ast import literal_eval
from collections import namedtuple
import contextlib
import csv
import logging
import urllib2
from StringIO import StringIO
from fabric.operations import sudo, put, run
from cgcloud.core.box import fabric_task
from cgcloud.core.init_box import UpstartBox, SystemdBox
from cgcloud.core.agent_box import AgentBox
from cgcloud.core.cloud_init_box import CloudInitBox
from cgcloud.core.package_manager_box import PackageManagerBox
from cgcloud.core.rc_local_box import RcLocalBox
from cgcloud.fabric.operations import remote_sudo_popen
from cgcloud.lib.util import heredoc
BASE_URL = 'http://cloud-images.ubuntu.com'
log = logging.getLogger( __name__ )
class UbuntuBox( AgentBox, CloudInitBox, RcLocalBox ):
"""
A box representing EC2 instances that boot from one of Ubuntu's cloud-image AMIs
"""
Release = namedtuple( 'Release', ('codename', 'version') )
@abstractmethod
def release( self ):
"""
:return: the code name of the Ubuntu release
:rtype: UbuntuBox.Release
"""
raise NotImplementedError( )
def _get_debconf_selections( self ):
"""
Override in concrete a subclass to add custom debconf selections.
:return: A list of lines to be piped to debconf-set-selections (no newline at the end)
:rtype: list[str]
"""
return [ ]
def admin_account( self ):
return 'ubuntu'
class TemplateDict( dict ):
def matches( self, other ):
return all( v == other.get( k ) for k, v in self.iteritems( ) )
def _base_image( self, virtualization_type ):
release = self.release( ).codename
template = self.TemplateDict( release=release, purpose='server', release_type='release',
storage_type='ebs', arch='amd64', region=self.ctx.region,
hypervisor=virtualization_type )
url = '%s/query/%s/server/released.current.txt' % (BASE_URL, release)
matches = [ ]
with contextlib.closing( urllib2.urlopen( url ) ) as stream:
images = csv.DictReader( stream,
fieldnames=[
'release', 'purpose', 'release_type', 'release_date',
'storage_type', 'arch', 'region', 'ami_id', 'aki_id',
'dont_know', 'hypervisor' ],
delimiter='\t' )
for image in images:
if template.matches( image ):
matches.append( image )
if len( matches ) < 1:
raise self.NoSuchImageException(
"Can't find Ubuntu AMI for release %s and virtualization type %s" % (
release, virtualization_type) )
if len( matches ) > 1:
raise RuntimeError( 'More than one matching image: %s' % matches )
image_info = matches[ 0 ]
image_id = image_info[ 'ami_id' ]
return self.ctx.ec2.get_image( image_id )
apt_get = 'DEBIAN_FRONTEND=readline apt-get -q -y'
@fabric_task
def _sync_package_repos( self ):
put( remote_path='/etc/apt/apt.conf.d/99timeout',
use_sudo=True,
local_path=StringIO( heredoc( """
Acquire::http::Timeout "10";
Acquire::ftp::Timeout "10"; """ ) ), )
for i in range( 5 ):
cmd = self.apt_get + ' update'
result = sudo( cmd, warn_only=True )
if result.succeeded: return
# https://bugs.launchpad.net/ubuntu/+source/apt/+bug/972077
# https://lists.debian.org/debian-dak/2012/05/threads.html#00006
if 'Hash Sum mismatch' in result:
log.warn( "Detected race condition during in '%s'" )
else:
raise RuntimeError( "Command '%s' failed" % cmd )
raise RuntimeError( "Command '%s' repeatedly failed with race condition. Giving up." )
@fabric_task
def _upgrade_installed_packages( self ):
sudo( '%s upgrade' % self.apt_get )
@fabric_task
def _install_packages( self, packages ):
packages = " ".join( packages )
sudo( '%s --no-install-recommends install %s' % (self.apt_get, packages) )
def _get_package_installation_command( self, package ):
return [ 'apt-get', 'install', '-y', '--no-install-recommends', '--force-yes' ] + list(
self._substitute_package( package ) )
def _pre_install_packages( self ):
super( UbuntuBox, self )._pre_install_packages( )
debconf_selections = self._get_debconf_selections( )
if debconf_selections:
self.__debconf_set_selections( debconf_selections )
@fabric_task
def __debconf_set_selections( self, debconf_selections ):
with remote_sudo_popen( 'debconf-set-selections' ) as f:
f.write( '\n'.join( debconf_selections ) )
def _ssh_service_name( self ):
return 'ssh'
class UpstartUbuntuBox( UbuntuBox, UpstartBox ):
pass
class SystemdUbuntuBox( UbuntuBox, SystemdBox ):
pass
class Python27UpdateUbuntuBox( UbuntuBox ):
"""
A mixin for retrieving 2.7.x updates of Python from <NAME>'s deadsnakes PPA (not the one
with old and new Pythons, but the one dedicated to 2.7 point updates.
https://launchpad.net/~fkrull/+archive/ubuntu/deadsnakes-python2.7
"""
@fabric_task
def _setup_package_repos( self ):
super( Python27UpdateUbuntuBox, self )._setup_package_repos( )
sudo( 'add-apt-repository -y ppa:fkrull/deadsnakes-python2.7' )
# FIXME: This should go some place else
@fabric_task
def _remote_python_version( self, python='python' ):
"""
Returns a version tuple for the Python installed on the instance represented by this box
:rtype: tuple
"""
return literal_eval( run( python + " -c 'import sys; print tuple(sys.version_info)'" ) )
|
436686
|
import pytest
from tests.functional.ucare_cli.helpers import arg_namespace
from pyuploadcare.ucare_cli.commands.delete_files import delete_files
def test_delete_parse_wait_arg():
args = arg_namespace("delete --wait 6c5e9526-b0fe-4739-8975-72e8d5ee6342")
assert args.wait
def test_delete_wait_is_true_by_default():
args = arg_namespace("delete 6c5e9526-b0fe-4739-8975-72e8d5ee6342")
assert args.wait
def test_delete_parse_no_wait_arg():
args = arg_namespace(
"delete --nowait 6c5e9526-b0fe-4739-8975-72e8d5ee6342"
)
assert not args.wait
@pytest.mark.vcr
def test_delete_one_file(uploadcare):
args = arg_namespace(
"delete --nowait 23762be6-cfe3-4d27-86be-9ed7d403dd43"
)
delete_files(args, uploadcare)
file = uploadcare.file("23762be6-cfe3-4d27-86be-9ed7d403dd43")
assert file.is_removed
@pytest.mark.vcr
def test_delete_several_files(uploadcare):
args = arg_namespace(
"delete --nowait 630a1322-a3b4-4873-a0a0-0ba6d6668eb5 "
"dda35f47-3add-4736-b406-f48af2548c5b"
)
delete_files(args, uploadcare)
for file_uuid in [
"630a1322-a3b4-4873-a0a0-0ba6d6668eb5",
"dda35f47-3add-4736-b406-f48af2548c5b",
]:
file = uploadcare.file(file_uuid)
assert file.is_removed
|
436715
|
from autograder.box_extractor import box_extraction
from autograder.character_predictor import predict
from autograder.spelling_corrector import fix_spellings
from autograder.text_similarity import check_similarity, get_marks
from fastapi import FastAPI, File, Form, HTTPException, UploadFile
from typing import List
import numpy as np
import cv2
app = FastAPI(
title="Auto-Grader",
version="1.0",
description="Automatically grades answer sheets",
)
def get_sentences_from_sheet(img):
answers, coordinates = box_extraction(img)
if len(answers) == 380:
locations = []
prev = 0
print(
answers.shape
) # 16 cells x 2 rows x 10 answers = 360 boxes x (28 x 28) pixels
sentences = []
for n in range(10): # all questions
sentence = ""
answer = answers[38 * n : 38 * (n + 1)] # individual answer(2 rows)
for i in range(38): # boxes of a answer
box = answer[i]
sum_pix = 0
for pixel in box: # pixel of the box
if pixel != 0:
sum_pix = sum_pix + 1
# do nothing when char is detected in the box, counter i will increase. When and empty
# box is detected after some character boxes, pix < 30
if sum_pix < 30 or i == 37:
word_array = answer[prev:i].reshape(-1, 28, 28, 1)
if word_array.shape[0] > 1:
try:
pred = predict(word_array)
if i < 16:
sentence = sentence + "".join(pred) + " "
else:
sentence = "".join(pred) + " " + sentence
except:
print(word_array.shape)
prev = i + 1
print(n + 1, sentence[::-1])
sentences.append(sentence[::-1])
return sentences
def find_marks(sentences, defined_answers, max_marks, bias):
n = 0
marks = []
for sentence in sentences:
new_words = []
for answer in defined_answers[n]:
words = answer.split()
for word in words:
new_words.append(word.lower())
query = fix_spellings(sentence.lower(), new_words)
if query != "":
print(query)
cos_scores = check_similarity(defined_answers[n], query)
m = get_marks(cos_scores, max_marks, bias)
print("Marks: ", "%.2f" % m)
marks.append(round(m, 4))
else:
print("Marks: ", "0.00")
marks.append(0.0)
n += 1
return marks
@app.get("/")
async def index():
return {"message": "Auto-Grader is online"}
@app.post("/grade/")
async def index(
ans1: List[str],
ans2: List[str],
ans3: List[str],
ans4: List[str],
ans5: List[str],
ans6: List[str],
ans7: List[str],
ans8: List[str],
ans9: List[str],
ans10: List[str],
max_marks: float,
lower_limit: float,
upper_limit: float,
file: UploadFile = File(...),
):
if lower_limit > 1.0 or lower_limit < 0.0 or upper_limit > 1.0 or upper_limit < 0.0:
raise HTTPException(status_code=400, detail="bias1 or bias2 not in range (0-1)")
if lower_limit > upper_limit:
raise HTTPException(
status_code=400, detail="lower_limit cannot be greater than upper_limit"
)
extension = file.filename.split(".")[-1] in ("jpg", "jpeg", "png", "JPG", "PNG")
if not extension:
raise HTTPException(
status_code=400, detail="File must be an image, in jpg or png format!"
)
image = await file.read()
nparr = np.fromstring(image, np.uint8)
img = cv2.imdecode(nparr, cv2.IMREAD_GRAYSCALE)
ans_list = [
ans1,
ans2,
ans3,
ans4,
ans5,
ans6,
ans7,
ans8,
ans9,
ans10,
]
sentences = get_sentences_from_sheet(img)
marks = find_marks(sentences, ans_list, max_marks, (lower_limit, upper_limit))
return {"marks": marks}
@app.post("/grade_text/")
async def index(
ans1: List[str],
ans2: List[str],
ans3: List[str],
ans4: List[str],
ans5: List[str],
ans6: List[str],
ans7: List[str],
ans8: List[str],
ans9: List[str],
ans10: List[str],
sheet_ans1: str,
sheet_ans2: str,
sheet_ans3: str,
sheet_ans4: str,
sheet_ans5: str,
sheet_ans6: str,
sheet_ans7: str,
sheet_ans8: str,
sheet_ans9: str,
sheet_ans10: str,
max_marks: float,
lower_limit: float,
upper_limit: float,
):
ans_list = [
ans1,
ans2,
ans3,
ans4,
ans5,
ans6,
ans7,
ans8,
ans9,
ans10,
]
sentences = [
[sheet_ans1],
[sheet_ans2],
[sheet_ans3],
[sheet_ans4],
[sheet_ans5],
[sheet_ans6],
[sheet_ans7],
[sheet_ans8],
[sheet_ans9],
[sheet_ans10],
]
for idx in range(len(sentences)):
sentences[idx] = " ".join(sentences[idx])
if lower_limit > 1.0 or lower_limit < 0.0 or upper_limit > 1.0 or upper_limit < 0.0:
raise HTTPException(status_code=400, detail="bias1 or bias2 not in range (0-1)")
if lower_limit > upper_limit:
raise HTTPException(
status_code=400, detail="lower_limit cannot be greater than upper_limit"
)
marks = find_marks(sentences, ans_list, max_marks, (lower_limit, upper_limit))
return {"marks": marks}
|
436722
|
import numpy as np
import theano
from foxhound.transforms import SeqPadded
from foxhound.utils import shuffle, iter_data
from foxhound.theano_utils import floatX, intX
from foxhound.rng import py_rng, np_rng
class Linear(object):
"""
size is the number of examples per minibatch
shuffle controls whether or not the order of examples is shuffled before iterating over
"""
def __init__(self, size=128, shuffle=True, trXt=floatX, teXt=floatX, trYt=floatX):
self.size = size
self.shuffle = shuffle
self.trXt = trXt
self.teXt = teXt
self.trYt = trYt
def iterX(self, X):
for xmb in iter_data(X, size=self.size):
xmb = self.teXt(xmb)
yield xmb
def iterXY(self, X, Y):
if self.shuffle:
X, Y = shuffle(X, Y)
for xmb, ymb in iter_data(X, Y, size=self.size):
xmb = self.trXt(xmb)
ymb = self.trYt(ymb)
yield xmb, ymb
class SortedPadded(object):
def __init__(self, size=128, shuffle=True, trXt=floatX, teXt=floatX, trYt=floatX):
self.size = size
self.shuffle = shuffle
self.trXt = trXt
self.teXt = teXt
self.trYt = trYt
def iterX(self, X):
for x_chunk, chunk_idxs in iter_data(X, np.arange(len(X)), size=self.size*20):
sort = np.argsort([len(x) for x in x_chunk])
x_chunk = [x_chunk[idx] for idx in sort]
chunk_idxs = [chunk_idxs[idx] for idx in sort]
for xmb, idxmb in iter_data(x_chunk, chunk_idxs, size=self.size):
xmb = self.teXt(xmb)
yield xmb, idxmb
def iterXY(self, X, Y):
if self.shuffle:
X, Y = shuffle(X, Y)
for x_chunk, y_chunk in iter_data(X, Y, size=self.size*20):
sort = np.argsort([len(x) for x in x_chunk])
x_chunk = [x_chunk[idx] for idx in sort]
y_chunk = [y_chunk[idx] for idx in sort]
mb_chunks = [[x_chunk[idx:idx+self.size], y_chunk[idx:idx+self.size]] for idx in range(len(x_chunk))[::self.size]]
py_rng.shuffle(mb_chunks)
for xmb, ymb in mb_chunks:
xmb = self.trXt(xmb)
ymb = self.trYt(ymb)
yield xmb, ymb
class Sampler(object):
def __init__(self, sampler, batches=128, size=128, trXt=floatX, teXt=floatX):
self.sampler = sampler
self.batches = batches
self.size = size
self.trXt = trXt
self.teXt = teXt
def predict(self, X):
for xmb in iter_data(X, size=self.size):
xmb = self.teXt(xmb)
yield xmb
def train(self, data):
for batch in range(self.batches):
xmb = self.sampler(data, size=self.size)
xmb = self.trXt(xmb)
yield xmb
|
436733
|
from openbiolink.edgeType import EdgeType
from openbiolink.graph_creation.metadata_infile.infileMetadata import InfileMetadata
from openbiolink.graph_creation.types.infileType import InfileType
from openbiolink.namespace import *
from openbiolink.nodeType import NodeType
class InMetaEdgeTnHpoDis(InfileMetadata):
CSV_NAME = "DB_Tn_HPO_disease_phenotype.csv"
USE_COLS = ["DOI", "HPO_ID", "evidence_code"]
NODE1_COL = 0
NODE2_COL = 1
QSCORE_COL = 2
SOURCE = "HPO"
NODE1_TYPE = NodeType.DIS
NODE1_NAMESPACE = Namespace(Namespaces.MULTI, mapping={"OMIM": "MIM", "PMID": "PUBMED"})
NODE2_TYPE = NodeType.PHENOTYPE
NODE2_NAMESPACE = Namespace(Namespaces.HPO)
EDGE_TYPE = EdgeType.DIS_PHENOTYPE
INFILE_TYPE = InfileType.IN_EDGE_TN_HPO_DIS
MAPPING_SEP = None
def __init__(self):
super().__init__(
csv_name=InMetaEdgeTnHpoDis.CSV_NAME, cols=self.USE_COLS, infileType=InMetaEdgeTnHpoDis.INFILE_TYPE
)
|
436750
|
from conans import ConanFile
from conans import tools
from conans.model.version import Version
class CESDKConan(ConanFile):
name = "cesdk"
settings = "os", "compiler", "arch"
description = "Develop 3D applications using the procedural geometry engine of Esri CityEngine."
url = "https://github.com/Esri/esri-cityengine-sdk"
license = "CityEngine EULA"
baseURL = "https://github.com/esri/esri-cityengine-sdk/releases/download/{}/esri_ce_sdk-{}-{}-{}-x86_64-rel-opt.zip"
def build(self):
if self.settings.os == "Windows":
toolchain = "vc142" if self.version >= Version("2.2.6332") else "vc141"
url = self.baseURL.format(self.version, self.version, "win10", toolchain)
elif self.settings.os == "Linux":
url = self.baseURL.format(self.version, self.version, "rhel7", "gcc63")
elif self.settings.os == "Macos":
url = self.baseURL.format(self.version, self.version, "osx12", "ac81")
else:
raise Exception("Unsupported configuration")
tools.get(url, verify=False)
def package(self):
self.copy("*", dst="esri_ce_sdk")
def package_info(self):
self.cpp_info.libs = tools.collect_libs(self)
|
436764
|
import logging
import math
import os
from pathlib import Path
import pandas as pd
from PIL import Image
from kale.loaddata.videos import VideoFrameDataset, VideoRecord
class BasicVideoDataset(VideoFrameDataset):
"""
Dataset for GTEA, ADL and KITCHEN.
Args:
root_path (string): The root path in which video folders lie.
annotationfile_path (string): The annotation file containing one row per video sample.
dataset_split (string): Split type (train or test)
image_modality (string): Image modality (RGB or Optical Flow)
num_segments (int): The number of segments the video should be divided into to sample frames from.
frames_per_segment (int): The number of frames that should be loaded per segment.
imagefile_template (string): The image filename template.
transform (Compose): Video transform.
random_shift (bool): Whether the frames from each segment should be taken consecutively starting from
the center(False) of the segment, or consecutively starting from
a random(True) location inside the segment range.
test_mode (bool): Whether this is a test dataset. If so, chooses frames from segments with random_shift=False.
n_classes (int): The number of classes.
"""
def __init__(
self,
root_path: str,
annotationfile_path: str,
dataset_split: str,
image_modality: str,
num_segments: int = 1,
frames_per_segment: int = 16,
imagefile_template: str = "img_{:010d}.jpg",
transform=None,
random_shift: bool = True,
test_mode: bool = False,
n_classes: int = 8,
):
self.root_path = Path(root_path)
self.image_modality = image_modality
self.dataset = dataset_split
self.n_classes = n_classes
self.img_path = self.root_path.joinpath(self.image_modality)
super(BasicVideoDataset, self).__init__(
root_path,
annotationfile_path,
image_modality,
num_segments,
frames_per_segment,
imagefile_template,
transform,
random_shift,
test_mode,
)
def _parse_list(self):
self.video_list = [VideoRecord(x, self.img_path) for x in list(self.make_dataset())]
def make_dataset(self):
"""
Load data from the EPIC-Kitchen list file and make them into the united format.
Different datasets correspond to a different number of classes.
Returns:
data (list): list of (video_name, start_frame, end_frame, label)
"""
data = []
i = 0
input_file = pd.read_pickle(self.annotationfile_path)
for line in input_file.values:
if 0 <= eval(line[5]) < self.n_classes:
data.append((line[0], eval(line[1]), eval(line[2]), eval(line[5])))
i = i + 1
logging.info("Number of {:5} action segments: {}".format(self.dataset, i))
return data
class EPIC(VideoFrameDataset):
"""
Dataset for EPIC-Kitchen.
"""
def __init__(
self,
root_path: str,
annotationfile_path: str,
dataset_split: str,
image_modality: str,
num_segments: int = 1,
frames_per_segment: int = 16,
imagefile_template: str = "img_{:010d}.jpg",
transform=None,
random_shift: bool = True,
test_mode: bool = False,
n_classes: int = 8,
):
self.root_path = Path(root_path)
self.image_modality = image_modality
self.dataset = dataset_split
self.n_classes = n_classes
self.img_path = self.root_path.joinpath(self.image_modality, self.dataset)
super(EPIC, self).__init__(
root_path,
annotationfile_path,
image_modality,
num_segments,
frames_per_segment,
imagefile_template,
transform,
random_shift,
test_mode,
)
def _parse_list(self):
self.video_list = [VideoRecord(x, self.img_path) for x in list(self.make_dataset())]
def _load_image(self, directory, idx):
if self.image_modality == "rgb":
return [Image.open(os.path.join(directory, self.imagefile_template.format(idx))).convert("RGB")]
elif self.image_modality == "flow":
idx = math.ceil(idx / 2) - 1 if idx > 2 else 1
u_img = Image.open(os.path.join(directory, "u", self.imagefile_template.format(idx))).convert("L")
v_img = Image.open(os.path.join(directory, "v", self.imagefile_template.format(idx))).convert("L")
return [u_img, v_img]
else:
raise RuntimeError("Input modality is not in [rgb, flow, joint]. Current is {}".format(self.image_modality))
def make_dataset(self):
"""
Load data from the EPIC-Kitchen list file and make them into the united format.
Because the original list files are not the same, inherit from class BasicVideoDataset and be modified.
"""
data = []
i = 0
input_file = pd.read_pickle(self.annotationfile_path)
for line in input_file.values:
if line[1] in ["P01", "P08", "P22"]:
if 0 <= line[9] < self.n_classes:
if line[7] - line[6] + 1 >= self.frames_per_segment:
label = line[9]
data.append((os.path.join(line[1], line[2]), line[6], line[7], label))
i = i + 1
logging.info("Number of {:5} action segments: {}".format(self.dataset, i))
return data
|
436773
|
import info
from Package.AutoToolsPackageBase import AutoToolsPackageBase
class subinfo(info.infoclass):
def registerOptions(self):
self.parent.package.categoryInfo.platforms = CraftCore.compiler.Platforms.NotMacOS
def setTargets(self):
""" """
for ver in ['0.2.1', '0.2.6', '0.2.7', '0.2.8']:
self.targets[ver] = "http://libspectre.freedesktop.org/releases/libspectre-" + ver + ".tar.gz"
self.targetInstSrc[ver] = "libspectre-" + ver
self.patchToApply["0.2.1"] = ("spectre-0.2.1-cmake.diff", 1)
self.patchToApply["0.2.6"] = ("libspectre-0.2.6-20101117.diff", 1)
if CraftCore.compiler.isWindows:
self.patchToApply["0.2.7"] = [("libspectre-0.2.7-20131003.diff", 1), ("libspectre-new-ghostscript.diff", 1)]
self.patchToApply["0.2.8"] = [("libspectre-0.2.7-20131003.diff", 1), ("libspectre-new-ghostscript.diff", 1)]
self.targetDigests['0.2.6'] = '819475c7e34a1e9bc2e876110fee530b42aecabd'
self.targetDigests['0.2.7'] = 'a7efd97b82b84ff1bb7a0d88c7e35ad10cc84ea8'
self.targetDigests["0.2.8"] = (['65256af389823bbc4ee4d25bfd1cc19023ffc29ae9f9677f2d200fa6e98bc7a8'], CraftHash.HashAlgorithm.SHA256)
self.description = "a wrapper library for libgs"
self.defaultTarget = '0.2.8'
def setDependencies(self):
self.runtimeDependencies["libs/ghostscript"] = None
self.runtimeDependencies["virtual/base"] = None
from Package.CMakePackageBase import *
if CraftCore.compiler.isWindows:
class Package(CMakePackageBase):
def __init__(self, **args):
CMakePackageBase.__init__(self)
else:
class Package(AutoToolsPackageBase):
def __init__(self, **args):
AutoToolsPackageBase.__init__(self)
self.subinfo.options.useShadowBuild = False
self.subinfo.options.configure.args = " --disable-static --enable-shared"
|
436838
|
import numpy as np
import unittest as ut
from qfast.pauli import get_norder_paulis
class TestGetNorderPaulis ( ut.TestCase ):
def in_array( self, needle, haystack ):
for elem in haystack:
if np.allclose( elem, needle ):
return True
return False
def test_get_norder_paulis_n1 ( self ):
num_qubits = -1
self.assertRaises( ValueError, get_norder_paulis, num_qubits )
def test_get_norder_paulis_0 ( self ):
num_qubits = 0
paulis = get_norder_paulis( num_qubits )
self.assertTrue( len( paulis ) == 4 ** num_qubits )
I = np.array( [[1, 0], [0, 1]], dtype = np.complex128 )
self.assertTrue( self.in_array( I, paulis ) )
def test_get_norder_paulis_1 ( self ):
num_qubits = 1
paulis = get_norder_paulis( num_qubits )
self.assertTrue( len( paulis ) == 4 ** num_qubits )
X = np.array( [[0, 1], [1, 0]], dtype = np.complex128 )
Y = np.array( [[0, -1j], [1j, 0]], dtype = np.complex128 )
Z = np.array( [[1, 0], [0, -1]], dtype = np.complex128 )
I = np.array( [[1, 0], [0, 1]], dtype = np.complex128 )
self.assertTrue( self.in_array( X, paulis ) )
self.assertTrue( self.in_array( Y, paulis ) )
self.assertTrue( self.in_array( Z, paulis ) )
self.assertTrue( self.in_array( I, paulis ) )
def test_get_norder_paulis_2 ( self ):
num_qubits = 2
paulis = get_norder_paulis( num_qubits )
self.assertTrue( len( paulis ) == 4 ** num_qubits )
X = np.array( [[0, 1], [1, 0]], dtype = np.complex128 )
Y = np.array( [[0, -1j], [1j, 0]], dtype = np.complex128 )
Z = np.array( [[1, 0], [0, -1]], dtype = np.complex128 )
I = np.array( [[1, 0], [0, 1]], dtype = np.complex128 )
self.assertTrue( self.in_array( np.kron( X, X ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, Y ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, Z ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, I ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, X ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, Y ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, Z ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, I ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, X ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, Y ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, Z ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, I ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, X ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, Y ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, Z ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, I ), paulis ) )
def test_get_norder_paulis_3 ( self ):
num_qubits = 3
paulis = get_norder_paulis( num_qubits )
self.assertTrue( len( paulis ) == 4 ** num_qubits )
X = np.array( [[0, 1], [1, 0]], dtype = np.complex128 )
Y = np.array( [[0, -1j], [1j, 0]], dtype = np.complex128 )
Z = np.array( [[1, 0], [0, -1]], dtype = np.complex128 )
I = np.array( [[1, 0], [0, 1]], dtype = np.complex128 )
self.assertTrue( self.in_array( np.kron( X, np.kron( X, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( X, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( X, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( X, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( Y, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( Y, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( Y, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( Y, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( Z, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( Z, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( Z, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( Z, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( I, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( I, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( I, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( X, np.kron( I, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( X, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( X, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( X, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( X, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( Y, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( Y, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( Y, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( Y, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( Z, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( Z, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( Z, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( Z, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( I, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( I, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( I, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Y, np.kron( I, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( X, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( X, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( X, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( X, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( Y, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( Y, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( Y, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( Y, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( Z, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( Z, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( Z, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( Z, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( I, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( I, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( I, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( Z, np.kron( I, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( X, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( X, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( X, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( X, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( Y, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( Y, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( Y, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( Y, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( Z, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( Z, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( Z, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( Z, I ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( I, X ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( I, Y ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( I, Z ) ), paulis ) )
self.assertTrue( self.in_array( np.kron( I, np.kron( I, I ) ), paulis ) )
if __name__ == '__main__':
ut.main()
|
436841
|
import argparse
import json
import os
import requests
from PIL import Image
from PIL.ImageDraw import ImageDraw
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Performs detection over input image given a trained detector.')
parser.add_argument('--input_image', type=str, default='IMSLP454435-PMLP738602-Il_tempio_d_amore_Sinfonia-0011.jpg',
help='Path to the input image.')
args = parser.parse_args()
input_image_path = args.input_image
basename, ext = os.path.splitext(input_image_path)
# Get bounding boxes for all measures
with open(input_image_path, 'rb') as image:
response = requests.post('http://localhost:8080/upload', files={'image': image})
measures = json.loads(response.content.decode('utf-8'))['measures']
print(measures)
# Draw boxes in copy of source image
image = Image.open(input_image_path).convert('RGBA') # type: Image.Image
overlay = Image.new('RGBA', image.size)
image_draw = ImageDraw(overlay)
for m in measures:
image_draw.rectangle([int(m['left']), int(m['top']), int(m['right']), int(m['bottom'])], fill='#00FFFF1B')
for m in measures:
image_draw.rectangle([int(m['left']), int(m['top']), int(m['right']), int(m['bottom'])], outline='#008888', width=2)
result_image = Image.alpha_composite(image, overlay).convert('RGB')
basename, ext = os.path.splitext(input_image_path)
result_path = basename + '_bboxes' + ext
result_image.save(result_path)
|
436844
|
from torch.optim import Adam
from torch import tensor, arange, stack
from torch.nn import Module, Linear
from torch.nn.functional import softmax, elu
from torch.distributions import Categorical
from algris import normalize
import visdom
class Agent(Module):
def __init__(self):
super(Agent, self).__init__()
self.a_space = arange(-1, 1.1, 0.2)
self.w_space = arange(-0.5, 0.6, 0.1)
self.s_head = Linear(4, 4*16)
self.a_head = Linear(4*16, len(self.a_space))
self.w_head = Linear(4*16, len(self.w_space))
self.optimizer = Adam(self.parameters(), lr=0.01)
self.records = [] # records of returns
self.viz = visdom.Visdom()
self.viz.close(win=None)
self.plot_v = self.viz.line(X=[0], Y=[0])
self.plot_a = self.viz.line(X=[0], Y=[0])
self.plot_w = self.viz.line(X=[0], Y=[0])
self.plot_r = self.viz.line(X=[0], Y=[0])
self.plot_l = self.viz.line(X=[0], Y=[0])
self.plot_value = self.viz.line(X=[0], Y=[0])
self.v_history = []
self.w_history = []
self.a_history = []
self.f_history = []
self.l_history = []
def forward(self, x):
x = elu(self.s_head(x))
a_scores = self.a_head(x)
w_scores = self.w_head(x)
return softmax(a_scores, dim=0), softmax(w_scores, dim=0)
def optimize(self, loss):
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
def decision(self, done, x, y, rz, v, feed, t): # return action
if len(self.records):
self.records[-1][0] = feed
if not done:
a_probs, w_probs = self(tensor([x, y, rz, v]))
a_dist = Categorical(a_probs)
w_dist = Categorical(w_probs)
a_index = a_dist.sample()
w_index = w_dist.sample()
self.records.append([
0,
a_dist.probs[a_index],
w_dist.probs[w_index],
a_dist.log_prob(a_index), # entropy, negtive
w_dist.log_prob(w_index)
]) # record of last episode
a = self.a_space[a_index].item()
w = self.w_space[w_index].item()
else:
a = w = 0
self.finish_episode()
if(done):
self.v_history = []
self.a_history = []
self.w_history = []
self.f_history = []
else:
self.v_history.append(v)
self.a_history.append(a)
self.w_history.append(w)
self.f_history.append(feed)
x_series = list(range(len(self.v_history)))
self.viz.line(X=x_series, Y=self.v_history,
win=self.plot_v, opts=dict(ylabel="velocity"))
self.viz.line(X=x_series, Y=self.a_history,
win=self.plot_a, opts=dict(ylabel="acceleration"))
self.viz.line(X=x_series, Y=self.w_history,
win=self.plot_w, opts=dict(ylabel="front wheel angle"))
self.viz.line(X=x_series, Y=self.f_history,
win=self.plot_r, opts=dict(ylabel="feed"))
return a, w
def finish_episode(self):
values = []
for feed, ap, wp, lap, lwp in self.records:
values.append(feed)
values = tensor(values)
values = normalize(values)
psloss = lsloss = prloss = lrloss = []
rloss = 0
for value, record in zip(values, self.records):
psloss.append(value*record[1]*record[2]) # value*p(a)*p(w)
# log(1/p(a,w))=-log(p(a)*p(w))=-log(p(a))-log(p(w))
lsloss.append(value*(-record[3]-record[4]))
prloss.append(record[0]*record[1]*record[2]) # feed*p(a)*p(w)
lrloss.append(record[0]*(-record[3]-record[4])) # feed*log(1/p(a,w))
rloss += record[0] # sum(feed0,feed1,...,feedt), no gradient
loss=stack(prloss).sum()
self.optimize(loss)
self.l_history.append(
[loss.item(), rloss])
self.viz.line(X=list(range(len(self.l_history))), Y=self.l_history,
win=self.plot_l, opts=dict(ylabel="loss", legend=["l", "r"]))
self.viz.line(X=list(range(len(self.records))), Y=tensor(self.records),
win=self.plot_value, opts=dict(ylabel="record", width=1000, height=400, legend=["feed", "ap", "wp", "lap", "lwp"]))
del self.records[:]
|
436857
|
import os
from django.conf import settings
from django.core.wsgi import get_wsgi_application
__author__ = "<NAME>"
__copyright__ = "Copyright 2019, Helium Edu"
__version__ = "1.4.38"
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "conf.settings")
application = get_wsgi_application()
# Only start the monitor if we're using a non-dev web server and not in production
if not settings.DEV_SERVER:
from conf import monitor
monitor.start()
|
436866
|
import six
from cqparts.params import Parameter, ParametricObject
# Types of things... not parts on their own, but utilised in many
from .solidtypes import fastener_heads
from .solidtypes import screw_drives
from .solidtypes import threads
# --------- Custom Parameter types ---------
class FastenerComponentParam(Parameter):
"""
Custom fastener component as a parameter.
(not to be confused with a *Part*)
"""
name = None
finder_callback = None
component_base = None
def type(self, value):
if isinstance(value, self.component_base):
# component's instance explicitly provided.
return value
elif isinstance(value, (tuple, list)):
# split value
if len(value) != 2:
raise ParameterError("given tuple must have 2 elements ({name}_type, dict(params)): {val!r}".format(
name=self.name, val=value
))
(component_type, params) = value
# Get component's class (or raise an exception trying)
component_class = None
if type(component_type) is type: # given value is a class
if issubclass(component_type, self.component_base):
# component class is explicitly defined
component_class = component_type
else:
raise ParameterError(
"given {name} type class {cls!r} does not inherit from {base!r}".format(
name=self.name, cls=type(component_type), base=self.component_base
)
)
elif isinstance(component_type, six.string_types):
# name of component type given, use callback to find it
try:
component_class = self.finder_callback(name=component_type)
except ValueError as e:
raise ParameterError(
("{name} type of '{type}' cannot be found. ".format(name=self.name, type=component_type)) +
"is it spelt correctly (case sensitive)?, has the library defining it been imported?"
)
else:
raise ParameterError(
"{name} type {val!r} must be a str, or a class inheriting from {base!r}".format(
name=self.name, val=component_type, base=self.component_base
)
)
# Verify parameters (very loosely)
if not isinstance(params, dict):
raise ParameterError("parameters must be a dict: {!r}".format(params))
# Create instance & return it
return component_class(**params)
# Serialize / Deserialize
@classmethod
def serialize(cls, value):
if value is None:
return value
return value.serialize() # divert to ParametricObject's serialize()
@classmethod
def deserialize(cls, value):
if value is None:
return value
return ParametricObject.deserialize(value)
class HeadType(FastenerComponentParam):
name = 'head'
finder_callback = staticmethod(fastener_heads.find)
component_base = fastener_heads.FastenerHead
_doc_type = "``value`` for :meth:`HeadType.type <cqparts_fasteners.params.HeadType.type>`"
def type(self, value):
"""
:param value: defined type of male fastener head
:type value: see below
``value`` can be any of:
- :class:`FastenerHead <cqparts.solidtypes.fastener_heads.FastenerHead>` instance
- :class:`tuple` of (``head type``, ``parameters``) where:
- ``head type`` is one of
- :class:`str` name of fastener head (registered with :meth:`register <cqparts.solidtypes.fastener_heads.register>`)
- :class:`FastenerHead <cqparts.solidtypes.fastener_heads.FastenerHead>` subclass
- ``parameters`` is a :class:`dict`
"""
return super(HeadType, self).type(value)
class DriveType(FastenerComponentParam):
name = 'drive'
finder_callback = staticmethod(screw_drives.find)
component_base = screw_drives.ScrewDrive
_doc_type = "``value`` for :meth:`DriveType.type <cqparts_fasteners.params.DriveType.type>`"
def type(self, value):
"""
:param value: defined type of screw-drive
:type value: see below
``value`` can be any of:
- :class:`ScrewDrive <cqparts.solidtypes.screw_drives.ScrewDrive>` instance
- :class:`tuple` of (``drive type``, ``parameters``) where
- ``drive type`` is one of
- ``str``: name of screw-drive (registered with :meth:`register <cqparts.solidtypes.screw_drives.register>`)
- :class:`ScrewDrive <cqparts.solidtypes.screw_drives.ScrewDrive>` subclass
- ``parameters`` is a :class:`dict`
"""
return super(DriveType, self).type(value)
class ThreadType(FastenerComponentParam):
name = 'thread'
finder_callback = staticmethod(threads.find)
component_base = threads.Thread
_doc_type = "``value`` for :meth:`ThreadType.type <cqparts_fasteners.params.ThreadType.type>`"
def type(self, value):
"""
:param value: defined type of thread
:type value: see below
``value`` can be any of:
- :class:`Thread <cqparts.solidtypes.threads.Thread>` instance
- :class:`tuple` of (``thread type``, ``parameters``) where:
- ``thread type`` is one of
- ``str``: name of thread type (registered with :meth:`register <cqparts.solidtypes.threads.register>`)
- :class:`Thread <cqparts.solidtypes.threads.Thread>` subclass
- ``parameters`` is a :class:`dict`
"""
return super(ThreadType, self).type(value)
|
436867
|
from ckstyle.cmdconsole.ConsoleClass import console
def doCombine(name, props):
pluginName = camelCase(name) + 'Combiner'
pluginClass = NullCombiner
try:
plugin = __import__('ckstyle.plugins.combiners.' + pluginName, fromlist = [pluginName])
if hasattr(plugin, pluginName):
pluginClass = getattr(plugin, pluginName)
else:
console.error('%s should exist in %s.py' % (pluginName, pluginName))
except ImportError as e:
pass
instance = pluginClass(name, props)
return instance.combine()
class NullCombiner():
def __init__(self, name, props):
pass
def combine(self):
return None, [], False
def camelCase(name):
splited = name.split('-')
collector = []
for x in splited:
collector.append(x.capitalize())
return ''.join(collector)
if __name__ == '__main__':
print(doCombine('margin', [
['margin', 'margin', '50px auto 0 auto']
]))
|
436870
|
from __future__ import unicode_literals
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
__version__ = "1.1.3"
__url__ = "https://github.com/hysds/hysds"
__description__ = "HySDS (Hybrid Cloud Science Data System)"
|
436872
|
import base64
from typing import List, Optional
from electrum_gui.common.basic.functional.require import require
from electrum_gui.common.basic.functional.text import force_text
from electrum_gui.common.basic.request.exceptions import RequestException, ResponseException
from electrum_gui.common.basic.request.restful import RestfulRequest
from electrum_gui.common.provider import exceptions
from electrum_gui.common.provider.chains.algo.sdk.constants import assettransfer_txn, payment_txn
from electrum_gui.common.provider.chains.algo.sdk.future.transaction import SuggestedParams
from electrum_gui.common.provider.data import (
Address,
BlockHeader,
ClientInfo,
EstimatedTimeOnPrice,
PricesPerUnit,
Transaction,
TransactionFee,
TransactionInput,
TransactionOutput,
TransactionStatus,
TxBroadcastReceipt,
TxBroadcastReceiptCode,
TxPaginate,
)
from electrum_gui.common.provider.exceptions import FailedToGetSuggestedParams, TransactionNotFound
from electrum_gui.common.provider.interfaces import ClientInterface, SearchTransactionMixin
def _parse_transactions(tx: dict) -> Transaction:
"""Parse transaction from raw rpc response
:param tx:
:return:
"""
block_header = BlockHeader(
block_hash=tx.get("blockHash", ""), # can't get
block_number=tx.get("confirmed-round", 0),
block_time=tx.get("round-time", 0),
)
status = TransactionStatus.CONFIRM_SUCCESS
fee = TransactionFee(
limit=tx.get("fee"),
used=tx.get("fee"),
price_per_unit=1, # maintain internal consistency
)
tx_type = tx["tx-type"]
sender = tx.get("sender", "")
receiver = ""
value = 0
token_address = None
if tx_type == payment_txn:
receiver = tx["payment-transaction"].get("receiver", "")
value = tx["payment-transaction"].get("amount", 0)
elif tx_type == assettransfer_txn:
token_address = str(tx["asset-transfer-transaction"]["asset-id"])
receiver = tx["asset-transfer-transaction"].get("receiver", "")
value = tx["asset-transfer-transaction"].get("amount", 0)
return Transaction(
txid=tx.get("id"),
inputs=[TransactionInput(address=sender, token_address=token_address, value=value)],
outputs=[TransactionOutput(address=receiver, token_address=token_address, value=value)],
status=status,
block_header=block_header,
fee=fee,
nonce=0,
)
class ALGORestful(ClientInterface, SearchTransactionMixin):
def __init__(self, algod_url: str, indexer_url: str, api_keys: List[str] = None):
self.algod_restful = RestfulRequest(
algod_url,
timeout=10,
session_initializer=lambda s: s.headers.update({"x-api-key": api_keys[0]}) if api_keys else None,
)
self.indexer_restful = RestfulRequest(
indexer_url,
timeout=10,
session_initializer=lambda s: s.headers.update({"x-api-key": api_keys[0]}) if api_keys else None,
)
def get_info(self) -> ClientInfo:
resp = self.algod_restful.get("/v2/status")
is_ready = resp.get("catchup-time", 1) == 0
if is_ready:
time_since_last_round = resp.get("time-since-last-round")
is_ready = time_since_last_round < 1e9 * 60 # 1 min
return ClientInfo(
name="algod",
best_block_number=resp.get("last-round", 0),
is_ready=is_ready,
desc="",
)
def get_address(self, address: str) -> Address:
resp = self._get_raw_address_info(address)
return Address(
address=address,
balance=resp["amount"],
existing=bool(resp["amount"]) or bool(resp["assets"]),
)
def _get_raw_address_info(self, address: str) -> dict:
resp = self.algod_restful.get(f"/v2/accounts/{address}")
require(resp["address"] == address)
return resp
def get_balance(self, address: str, token_address: Optional[str] = None) -> int:
if token_address is None:
return super(ALGORestful, self).get_balance(address)
else:
resp = self._get_raw_address_info(address)
for token_dict in resp.get("assets") or ():
if token_dict.get("asset-id") == int(token_address):
return token_dict.get("amount", 0)
return 0
def get_transaction_by_txid(self, txid: str) -> Transaction:
try:
# todo handle pending tx
# pending = self.restful.get(f"/ps2/v2/transactions/pending/{txid}")
resp = self.indexer_restful.get(f"/v2/transactions/{txid}")
except ResponseException as e:
if e.response is not None and "no transaction found" in force_text(e.response.text):
raise TransactionNotFound(txid)
else:
raise e
return _parse_transactions(resp.get("transaction"))
def search_txs_by_address(self, address: str, paginate: Optional[TxPaginate] = None) -> List[Transaction]:
"""Retrieve the latest 50 transactions."""
if paginate:
# TODO: paginate
pass
resp = self.indexer_restful.get(f"/v2/accounts/{address}/transactions", params={"limit": 50})
return [_parse_transactions(tx) for tx in resp.get("transactions", [])]
def broadcast_transaction(self, raw_tx: str) -> TxBroadcastReceipt:
try:
resp = self.algod_restful.post(
"/v2/transactions", data=base64.b64decode(raw_tx), headers={'Content-Type': 'application/x-binary'}
)
except ResponseException as e:
try:
resp = e.response.json()
except ValueError:
resp = dict()
txid = resp.get("txId")
if txid:
return TxBroadcastReceipt(is_success=True, receipt_code=TxBroadcastReceiptCode.SUCCESS, txid=txid)
else:
raise exceptions.UnknownBroadcastError("malformed algorand transaction" if resp.status_code == 400 else "")
def get_prices_per_unit_of_fee(self) -> PricesPerUnit:
normal = EstimatedTimeOnPrice(price=1, time=15) # maintain internal consistency
return PricesPerUnit(normal=normal)
def get_suggested_params(self) -> SuggestedParams:
try:
resp = self.algod_restful.get("/v2/transactions/params")
except RequestException:
raise FailedToGetSuggestedParams()
return SuggestedParams(
resp["fee"],
resp["last-round"],
resp["last-round"] + 1000,
resp["genesis-hash"],
resp["genesis-id"],
False,
resp["consensus-version"],
resp["min-fee"],
)
|
436915
|
import contextlib
import os
import sys
from pathlib import Path
@contextlib.contextmanager
def working_directory(path: Path):
"""Change working directory and returns to previous on exit."""
prev_cwd = Path.cwd()
os.chdir(str(path))
sys.path.insert(0, str(path))
try:
yield
finally:
os.chdir(prev_cwd)
sys.path.remove(str(path))
def get_project_dir() -> Path:
"""
Sample project directory
:return str: sample project directory
"""
return Path(__file__).parent / "sample"
def unload_django():
"""Tear down django initialization by unloding modules and resetting apps state."""
project_modules = [
module_name
for module_name in sys.modules.keys()
if module_name.startswith("django") or module_name.startswith("test_project")
]
for module in project_modules:
if module in sys.modules:
del sys.modules[module]
from django.apps import apps
apps.clear_cache()
apps.ready = False
apps.models_ready = False
apps.apps_ready = False
apps.loading = False
apps.app_configs = {}
|
436923
|
import re
from ..identifier import Identifier
ISSN_RE = re.compile('issn\s?=?\s?([0-9]{4}\-[0-9]{3}([0-9]|X))', re.I)
def extract(text):
for match in ISSN_RE.finditer(text):
yield Identifier(
'issn',
match.group(1).replace('-', '').replace(' ', '').strip()
)
|
436945
|
import sqlite3
import json
import os
import uuid
def get_random_db_path():
return f"/tmp/.{uuid.uuid4()}.db"
def dict_factory(cursor, row):
d = {}
for idx, col in enumerate(cursor.description):
d[col[0]] = row[idx]
return d
class SQLHandler(object):
def __init__(self, hide_attributes=True, db_path=None, in_memory=False, tfstate_file=None):
self.hide_attributes = hide_attributes
self.db_path = db_path
self.tfstate_file = tfstate_file
if self.db_path is None:
self.db_path = get_random_db_path()
if in_memory:
self.db_path = "file::memory:"
self.conn = self.get_new_db()
self.conn.row_factory = dict_factory
self.cursor = self.conn.cursor()
def create_table(self, resources):
if self.hide_attributes:
resources = self.__hide_attributes(resources)
if len(resources) == 0:
k = ['mode', 'type', 'name', 'provider', 'module', 'attributes', 'dependencies']
else:
k = list(resources[0].keys())
k.append("tfstate_file")
sql = "CREATE TABLE IF NOT EXISTS resources(\n"
for i in enumerate(k):
if i[1] in ("attributes", "dependencies"):
sql += f"`{i[1]}` json default null"
else:
sql += f"`{i[1]}` text default null"
if i[0] != len(k) - 1:
sql += ",\n"
sql += '\n)'
self.cursor.execute(sql)
def get_new_db(self):
self.conn = sqlite3.connect(self.db_path)
return self.conn
def remove_db(self):
if self.db_path:
if os.path.exists(self.db_path):
os.remove(self.db_path)
def return_db(self):
return self.conn
def query(self, sql, parse_attributes=True):
self.cursor.execute(sql)
res = self.cursor.fetchall()
if parse_attributes is False:
return res
output = []
for i in res:
if "attributes" in i:
i["attributes"] = json.loads(i["attributes"])
if "dependencies" in i:
i["dependencies"] = json.loads(i["dependencies"])
output.append(i)
return output
def insert_resources(self, resources):
if self.hide_attributes:
resources = self.__hide_attributes(resources)
for resource in resources:
self.insert_resource(resource)
def __hide_attributes(self, resources):
output = []
for resource in resources:
new_resource = {}
for j in resource.keys():
if j.startswith("__"):
continue
new_resource[j] = resource[j]
output.append(new_resource)
return output
def insert_resource(self, resource):
resource["tfstate_file"] = os.path.basename(self.tfstate_file)
sql = "INSERT INTO resources("
for i in enumerate(resource):
sql += f"`{i[1]}`"
sql += ", "
sql = sql[0:-2]
sql += ") VALUES ("
for i in enumerate(resource):
sql += f":{i[1]}"
sql += ", "
sql = sql[0:-2]
sql += ");"
for k in resource.keys():
if type(resource[k]) not in [str, type(None)]:
resource[k] = json.dumps(resource[k])
try:
self.cursor.execute(sql, resource)
self.conn.commit()
except Exception as e:
print(e)
|
437013
|
import json
import re
import os
import math
from samflow.command import ShellCommand, PythonCommand
from samflow.workflow import attach_back
from pkg_resources import resource_filename
from chilin2.modules.config.helpers import JinjaTemplateCommand, template_dump, json_load, json_dump
def tex_motif(workflow, conf):
tex = attach_back(workflow,
PythonCommand(
latex_seqpos,
input={"template": resource_filename("chilin2.modules", "mdseqpos/motif.tex"),"json":conf.json_prefix + "_seqpos.json"},
output={"tex": conf.latex_prefix + "_motif.tex"},
param={"id": conf.id},
name = "generating latex of motif info"))
tex.allow_fail = True
tex.allow_dangling = True
def latex_seqpos(input, output, param):
json_dict = json_load(input["json"])
latex = JinjaTemplateCommand(
name = "motif finding",
template = input["template"],
param = {"motif_table": json_dict["stat"]["satisfied_motifs"][:5], ## use top 5 motif
"render_dump": output["tex"]})
template_dump(latex)
|
437014
|
from mle_monitor import MLEProtocol, MLEResource, MLEDashboard
def test_dashboard():
# Test data collection and layout generation
resource = MLEResource(resource_name="local")
protocol = MLEProtocol(protocol_fname="mle_protocol.db")
dashboard = MLEDashboard(protocol, resource)
dashboard.snapshot()
|
437045
|
from __future__ import absolute_import
from __future__ import print_function
import socket
import getpass
import sys
from cProfile import Profile
from pstats import Stats
from tempfile import NamedTemporaryFile
from functools import wraps
from datetime import datetime
def profile(hostname=None, to_stdout=False):
def print_stats(stats):
stats.strip_dirs()
stats.sort_stats('time', 'calls')
stats.print_stats(20)
stats.sort_stats('cumulative')
stats.print_stats(20)
def decorator(f):
@wraps(f)
def _(*args, **kwargs):
prof = Profile()
try:
return prof.runcall(f, *args, **kwargs)
finally:
if to_stdout:
stats = Stats(prof)
print_stats(stats)
else:
with NamedTemporaryFile(prefix='dpark_profile_', delete=False) as fd:
print('===\n', datetime.today(), getpass.getuser(), sys.argv[0], file=fd)
stats = Stats(prof, stream=fd)
print_stats(stats)
return _
if hostname is None or socket.gethostname() == hostname:
return decorator
else:
return lambda f: f
|
437067
|
from django.db import models
from django.utils.text import slugify
from accounts.models import ServiceProvider
from library.models import BaseModel
from django.utils.translation import ugettext_lazy as _
from address.models import ServiceAddress, Area
import uuid
class Service(BaseModel):
RESTAURANT = 0
CAFE = 1
CONFECTIONERY = 2
SUPERMARKET = 3
SERVICE_TYPES = (
(RESTAURANT, _('restaurant')),
(CAFE, _('cafe')),
(CONFECTIONERY, _('confectionery')),
(SUPERMARKET, _('supermarket')),
)
uuid = models.UUIDField(default=uuid.uuid4, verbose_name=_('uuid'), unique=True, db_index=True)
service_provider = models.ForeignKey(
ServiceProvider,
verbose_name=_('service provider'),
related_name='services',
on_delete=models.CASCADE
)
name = models.CharField(max_length=40, verbose_name=_('name'))
service_type = models.PositiveSmallIntegerField(verbose_name=_('service type'), choices=SERVICE_TYPES)
minimum_purchase = models.DecimalField(max_digits=9, decimal_places=0, verbose_name=_('minimum purchase'))
available = models.BooleanField(default=False, verbose_name=_('available'))
logo = models.ImageField(verbose_name=_('logo'), upload_to='service/logos/', null=True, blank=True)
banner = models.ImageField(verbose_name=_('banner'), upload_to='service/banners/', null=True, blank=True)
address = models.OneToOneField(
ServiceAddress,
verbose_name=_('address'),
related_name='services',
on_delete=models.SET_NULL,
null=True,
blank=True
)
def __str__(self):
return f'{self.name} - {self.get_service_type_display()}'
class Meta:
verbose_name = _('Service')
verbose_name_plural = _('Services')
db_table = 'service'
ordering = ('created_time',)
class ServiceCategory(BaseModel):
name = models.CharField(max_length=30, verbose_name=_('name'))
slug = models.SlugField(max_length=35, verbose_name=_('slug'), allow_unicode=True)
service = models.ForeignKey(Service, verbose_name=_('service'), related_name='categories', on_delete=models.CASCADE)
def __str__(self):
return f'{self.name} - {self.service.name}'
def save(self, *args, **kwargs):
self.slug = slugify(self.name, allow_unicode=True)
super().save(*args, **kwargs)
class Meta:
verbose_name = _('ServiceCategory')
verbose_name_plural = _('ServiceCategories')
db_table = 'service_category'
class DeliveryArea(BaseModel):
service = models.ForeignKey(
Service, verbose_name=_('service'), related_name='delivery_areas', on_delete=models.CASCADE
)
area = models.ForeignKey(Area, verbose_name=_('area'), related_name='delivery_areas', on_delete=models.CASCADE)
def __str__(self):
return f'{self.service.name} - {self.area}'
class Meta:
verbose_name = _('DeliveryArea')
verbose_name_plural = _('DeliveryAreas')
db_table = 'delivery_area'
class ServiceAvailableTime(BaseModel):
SAT_DAY = 0
SUN_DAY = 1
MON_DAY = 2
TUE_DAY = 3
WED_DAY = 4
THU_DAY = 5
FRI_DAY = 6
DAYS = (
(SAT_DAY, _('saturday')),
(SUN_DAY, _('sunday')),
(MON_DAY, _('monday')),
(TUE_DAY, _('tuesday')),
(WED_DAY, _('wednesday')),
(THU_DAY, _('thursday')),
(FRI_DAY, _('friday'))
)
service = models.ForeignKey(
Service, verbose_name=_('service'), related_name='available_times', on_delete=models.CASCADE
)
day = models.PositiveSmallIntegerField(verbose_name=_('day'), choices=DAYS, null=True)
open_time = models.TimeField(verbose_name=_('open time'), null=True)
close_time = models.TimeField(verbose_name=_('close time'), null=True)
is_close = models.BooleanField(verbose_name=_('close day'), blank=True, null=True)
def __str__(self):
return f'{self.service.name} - {self.get_day_display()} - ' \
f'{self.is_close if self.close_time else self.open_time and "-" and self.close_time}'
class Meta:
verbose_name = _('ServiceAvailableTime')
verbose_name_plural = _('ServiceAvailableTimes')
db_table = 'service_available_time'
ordering = ('day',)
|
437097
|
from collections import defaultdict
from boto.mturk.connection import MTurkConnection
from boto.mturk.price import Price
from boto.mturk.connection import MTurkRequestError
__author__ = 'anushabala'
from argparse import ArgumentParser
import csv
from datetime import datetime
import numpy as np
import matplotlib.pyplot as plt
import sqlite3
import json
DATE_FMT = "%a %b %d %H:%M:%S %Z %Y"
def assign_bonus(duration):
if 7 < duration <= 10:
return 0.25
elif 10 < duration <= 13:
return 0.5
elif 13 < duration <= 25:
return 0.75
elif duration > 25:
print "t>25"
return 2
else:
return 0.
def grant_bonuses():
reader = csv.reader(results_file)
header = reader.next()
response_col = header.index('Answer.surveycode')
feedback_col = header.index('Answer.feedback')
hit_col = header.index('AssignmentId')
worker_col = header.index('WorkerId')
total_bonus = 0.
for row in reader:
response = row[response_col]
hit_id = row[hit_col]
worker_id = row[worker_col]
feedback = row[feedback_col]
if response.startswith("I") or response.startswith("C"):
response = "MTURK_TASK_" + response
if response == "{}":
print "Empty response; feedback: {:s}".format(feedback)
if feedback != "{}" and "MTURK_TASK_" not in feedback:
total_bonus += 0.25
print "Based on feedback: Granting bonus 0.25 to worker {:s}".format(worker_id)
if not debug:
mturk_connection.grant_bonus(worker_id, hit_id, Price(amount=0.25),
reason='For the trouble you experienced with our negotiation platform')
elif "MTURK_TASK_" in feedback:
print "Survey code was entered in feedback? {:s} Trying..".format(feedback)
response = feedback
if response not in mturk_codes.keys():
print "No userid associated with code {:s}".format(response)
continue
uid = mturk_codes[response]
if uid not in bonuses.keys():
print "No chats for user {:s} with code {:s}".format(uid, response)
continue
bonus = bonuses[uid]
if bonus > 0.:
total_bonus += bonus
print "Granting bonus {:.2f} to worker {:s}".format(bonus, worker_id)
if not debug:
mturk_connection.grant_bonus(worker_id, hit_id, Price(amount=bonus),
reason='For having to spend extra time on our negotiation platform')
print "Total bonus awarded: {:.2f}".format(total_bonus)
def get_last_event(cid):
cursor.execute('''SELECT time FROM event WHERE chat_id=?''', (cid,))
times = cursor.fetchall()
if times is None:
return None
max_time = -1
for event_time in times:
event_time = float(event_time[0])
max_time = event_time if event_time > max_time else max_time
return max_time
def get_user_chats():
user_chats = defaultdict(list)
chat_times = defaultdict(float)
cursor.execute('''SELECT chat_id, agent_ids, start_time FROM chat''')
for (cid, agent_ids, start_time) in cursor.fetchall():
agent_ids = json.loads(agent_ids)
start_time = float(start_time)
user_chats[agent_ids["0"]].append(cid)
user_chats[agent_ids["1"]].append(cid)
end_time = get_last_event(cid)
chat_times[cid] = (end_time - start_time)
return user_chats, chat_times
def get_mturk_codes():
codes = {}
cursor.execute('''SELECT * FROM mturk_task WHERE mturk_code IS NOT NULL''')
for (uid, c, _) in cursor.fetchall():
codes[c] = uid
return codes
def get_bonuses():
times = []
num_chats = []
bonuses = {}
for uid in user_chats.keys():
t = sum([chat_times[cid] for cid in user_chats[uid]]) / 60.
if t < 1:
continue
num_chats.append(len(user_chats[uid]))
times.append(t)
bonuses[uid] = assign_bonus(t)
print "Avg time taken: {:.2f}".format(np.mean(times))
print "Std: {:.2f}".format(np.std(times))
print "Average number of chats: {:.2f}".format(np.mean(num_chats))
print "Std: {:.2f}".format(np.std(num_chats))
print "Total bonus: ${:.2f}".format(np.sum(bonuses.values()))
hist, bins = np.histogram(times)
print bins
# width = np.diff(bins)
# center = (bins[:-1] + bins[1:]) / 2
#
# fig, ax = plt.subplots(figsize=(8,3))
# ax.bar(center, hist, align='center', width=width)
# ax.set_xticks(bins)
# plt.show()
return bonuses
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument('--config', type=str, default='data/aws_config.json',
help='Config file containing AWS access key and secret access key. '
'See data/sample_aws_config.json for an example.')
parser.add_argument('--debug', action='store_true', help="If provided, runs script in debug mode")
parser.add_argument('--results', type=str, required=True, help='Path to results CSV file from Mechanical Turk')
parser.add_argument('--db', type=str, required=True, help='Path to website database file')
parser.add_argument('--min-time', type=float, default=10.0, help='Minimum time to award bonus for')
args = parser.parse_args()
config = json.load(open(args.config, 'r'))
debug = args.debug
results_file = open(args.results, 'r')
conn = sqlite3.connect(args.db)
cursor = conn.cursor()
user_chats, chat_times = get_user_chats()
mturk_codes = get_mturk_codes()
bonuses = get_bonuses()
if debug:
print "Running script in debug mode."
host = 'mechanicalturk.sandbox.amazonaws.com'
else:
host = 'mechanicalturk.amazonaws.com'
mturk_connection = MTurkConnection(aws_access_key_id=config["access_key"],
aws_secret_access_key=config["secret_key"],
host=host)
grant_bonuses()
|
437105
|
import os
import tensorflow as tf
import logging
logger = logging.getLogger('hyper_fcn')
class TuneReporter(tf.keras.callbacks.Callback):
"""Tune Callback for Keras."""
def __init__(self, reporter=None, freq="epoch", logs=None):
"""Initializer.
Args:
freq (str): Sets the frequency of reporting intermediate results.
One of ["batch", "epoch"].
"""
self.iteration = 0
logs = logs or {}
if freq not in ["batch", "epoch"]:
raise ValueError("{} not supported as a frequency.".format(freq))
self.freq = freq
super(TuneReporter, self).__init__()
def on_batch_end(self, batch, logs=None):
from ray import tune
logs = logs or {}
if not self.freq == "batch":
return
self.iteration += 1
for metric in list(logs):
if "loss" in metric and "neg_" not in metric:
logs["neg_" + metric] = -logs[metric]
if "acc" in logs:
tune.report(keras_info=logs, mean_accuracy=logs["acc"])
else:
tune.report(keras_info=logs, mean_accuracy=logs.get("accuracy"))
def on_epoch_end(self, batch, logs=None):
from ray import tune
logs = logs or {}
if not self.freq == "epoch":
return
self.iteration += 1
for metric in list(logs):
if "loss" in metric and "neg_" not in metric:
logs["neg_" + metric] = -logs[metric]
if "acc" in logs:
tune.report(keras_info=logs, val_loss=logs['val_loss'], mean_accuracy=logs["acc"])
else:
tune.report(keras_info=logs, val_loss=logs['val_loss'], mean_accuracy=logs.get("accuracy"))
def create_callbacks(final_run, model_path):
callbacks = []
# Creating early stopping callback
earlystopping = tf.keras.callbacks.EarlyStopping(monitor="val_loss",
patience=10,
min_delta=1e-4,
mode='min',
restore_best_weights=True,
verbose=1)
callbacks.append(earlystopping)
if final_run:
logger.info("Creating model checkpoint callback")
# Make sure the 'snapshots' directory exists
os.makedirs(model_path, exist_ok=True)
# Creating model checkpoint callback
checkpoint_path = model_path
checkpoint_path = os.path.join(checkpoint_path, 'train_model.h5')
checkpoint = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,
monitor='val_loss',
save_best_only=True,
verbose=1)
callbacks.append(checkpoint)
else:
logger.info("Creating tune reporter callback")
# Creating ray callback which reports metrics of the ongoing run
# We choose to report metrics after epoch end using freq="epoch"
# because val_loss is calculated just before the end of epoch
tune_reporter = TuneReporter(freq="epoch")
callbacks.append(tune_reporter)
return callbacks
|
437136
|
from datetime import date as dt
import pandas as pd
import requests
import bandl.common
#default periods
DEFAULT_DAYS = 250
def is_ind_index(symbol):
is_it = symbol in bandl.common.IND_INDICES
return is_it
def get_formated_date(date=None,format=None,dayfirst=False):
"""string date to format date
"""
try:
if not date:
date = dt.today()
date_time = pd.to_datetime(date,dayfirst=dayfirst)
if not format:
format='%m/%d/%Y'
format += ' %H:%M:%S'
return date_time.strftime(format)
except Exception as err:
raise Exception("Error occurred while formatting date, Error: ",str(err))
def get_formated_dateframe(date=None,format=None,dayfirst=False):
return pd.to_datetime(get_formated_date(date,format,dayfirst),format=format)
def get_date_offset(periods=None,start=None,end=None,freq="B"):
#use to get start date and end date
if start:
if not periods:
return get_formated_date()
else:
return pd.date_range(start=start,end=end,periods=periods,freq=freq)[-1]
elif end:
return pd.date_range(start=start,end=end,periods=periods,freq=freq)[0]
else:
raise ValueError("start/end , one should be None")
def get_date_range(start=None,end=None,periods=None,format=None,dayfirst=False,freq="B"):
#Step 1: format date
if start:
start = get_formated_dateframe(start,dayfirst=dayfirst)
if end:
end = get_formated_dateframe(end,dayfirst=dayfirst)
#Step 2: date range with periods
if (not periods) and (not start):
periods = DEFAULT_DAYS
#if only start, find till today
if start and (not end):
s_from = start
e_till = get_date_offset(start=start,periods=periods)#s_from + pd.offsets.BDay(periods)
#if not start, go to past
elif(end and (not start)):
s_from = get_date_offset(end=end,periods=periods)#e_till - pd.offsets.BDay(periods)
e_till = end
#if start and end, no need to change
elif(start and end):
s_from = start
e_till = end
# if no stat/end and periods given, we get last 1 years of data
else:
e_till = get_formated_dateframe()
s_from = get_date_offset(end=e_till,periods=periods,freq=freq)
#Step 3: Format to input date format
s_from = get_formated_dateframe(date=s_from,format=format)
e_till = get_formated_dateframe(date=e_till,format=format)
return s_from,e_till
def get_data_resample(dfs,time):
dfs.columns = dfs.columns.str.title()
ohlc_dict = {'Open':'first', 'High':'max', 'Low':'min', 'Close': 'last','Volume':'sum'}
return dfs.resample(time,convention="end").agg(ohlc_dict).dropna()
|
437144
|
from .stop_words import STOP_WORDS
from ...language import Language, BaseDefaults
class SlovenianDefaults(BaseDefaults):
stop_words = STOP_WORDS
class Slovenian(Language):
lang = "sl"
Defaults = SlovenianDefaults
__all__ = ["Slovenian"]
|
437156
|
import time
from time import sleep
import client
from logic import epoch_logic, validator_logic, shard_logic
import config
VALIDATOR_LENGTHS = []
MAX_VALIDATOR_LENGTHS = 20
def get_validators_and_bid_if_necessary(bidding_enabled=False):
debug_json = {}
my_validator = validator_logic.get_my_validator()
if bidding_enabled:
# Remove existing keys from the validator not found in the config.
removed_keys = validator_logic.remove_keys_not_in_config(my_validator)
if removed_keys:
# Refresh my_validator
my_validator = validator_logic.get_my_validator()
debug_json['keys_not_in_config_removed'] = removed_keys
validators = validator_logic.get_all_validators()
VALIDATOR_LENGTHS.append(len(validators))
if len(VALIDATOR_LENGTHS) > MAX_VALIDATOR_LENGTHS:
VALIDATOR_LENGTHS.pop(0)
avg_validators_length = sum(VALIDATOR_LENGTHS) / (1.0 * len(VALIDATOR_LENGTHS))
bidding_enabled = len(validators) >= (avg_validators_length - 3) and bidding_enabled
target_slot = config.TARGET_SLOT
my_slot_range = validator_logic.get_my_slot_range_for_validators(validators, my_validator)
num_blocks_left = epoch_logic.get_remaining_blocks_for_current_epoch()
response_json = dict(
action=None,
slots=str(my_slot_range),
validator=my_validator.to_dict(),
validators=[v.to_dict() for v in validators],
num_blocks_left=num_blocks_left,
num_seconds_left=epoch_logic.get_remaining_seconds_for_current_epoch(),
interval_seconds=epoch_logic.get_interval_seconds(),
debug=debug_json
)
min_efficient_bid, max_efficient_bid = validator_logic.get_min_max_efficient_bid(validators)
shard_staking_amounts = shard_logic.get_shard_staking_amounts(validators, min_efficient_bid, max_efficient_bid)
debug_json['avg_num_validators'] = avg_validators_length
debug_json['max_efficient_bid'] = max_efficient_bid
debug_json['min_efficient_bid'] = min_efficient_bid
debug_json['shard_staking_amounts'] = shard_staking_amounts
if bidding_enabled and num_blocks_left <= config.BOTTOM_FEED_ENABLED_BLOCKS_LEFT:
target_slot = config.NUM_SLOTS - config.BOTTOM_FEED_SLOT_DISTANCE
if not bidding_enabled:
response_json['interval_seconds'] = 0.5
changed_keys = False
validator_lower_bid, key_to_add = validator_logic.get_validator_add_key(my_validator)
if validator_lower_bid:
validators_lowering_bid = [validator_lower_bid if v.address == config.VALIDATOR_ADDR else v for v in validators]
next_slot_range = validator_logic.get_my_slot_range_for_validators(validators_lowering_bid, my_validator)
response_json["slots_after_lowering_bid"] = str(next_slot_range)
force_remove_due_to_inefficient = False
if (
my_validator.bid > max_efficient_bid
and next_slot_range.end <= config.NUM_SLOTS
and config.PREVENT_INEFFICIENT_BID
):
debug_json['force_remove_due_to_inefficient'] = force_remove_due_to_inefficient = True
if (
((my_slot_range.end <= target_slot and next_slot_range.end < target_slot)
or force_remove_due_to_inefficient)
and bidding_enabled
):
response_json["action"] = u"Lowering the bid by adding key {}".format(key_to_add)
response = client.add_bls_key(key_to_add)
if response is not None:
changed_keys = True
response_json["added_bls_key"] = key_to_add
else:
response_json['interval_seconds'] = 1
validators = validator_logic.get_all_validators()
my_slot_range = validator_logic.get_my_slot_range_for_validators(validators, my_validator)
response_json["new_slots"] = str(my_slot_range)
validator_increase_bid, key_to_remove = validator_logic.get_validator_remove_key(my_validator)
if validator_increase_bid:
validators_increasing_bid = [validator_increase_bid if v.address == config.VALIDATOR_ADDR else v
for v in validators]
next_slot_range = validator_logic.get_my_slot_range_for_validators(validators_increasing_bid,
my_validator)
response_json["slots_after_increasing_bid"] = str(next_slot_range)
if (
my_slot_range.end >= target_slot and bidding_enabled and not response_json.get("action")
):
# Max efficient bid calculation must be re-done with a scenario where we remove a key
_, max_efficient_bid_after_increase = validator_logic.get_min_max_efficient_bid(validators_increasing_bid)
prevent_bid_due_to_inefficient = False
if (
validator_increase_bid.bid > max_efficient_bid_after_increase
and config.PREVENT_INEFFICIENT_BID
and my_slot_range.end <= config.NUM_SLOTS
):
prevent_bid_due_to_inefficient = True
debug_json['prevent_bid_due_to_inefficient'] = prevent_bid_due_to_inefficient
if not prevent_bid_due_to_inefficient:
response_json["action"] = u"Increasing the bid by removing key {}".format(key_to_remove)
response = client.remove_bls_key(key_to_remove)
if response is not None:
response_json["removed_bls_key"] = key_to_remove
changed_keys = True
else:
response_json['interval_seconds'] = 1
validators = validator_logic.get_all_validators()
my_slot_range = validator_logic.get_my_slot_range_for_validators(validators, my_validator)
response_json["new_slots"] = str(my_slot_range)
if changed_keys:
response_json['interval_seconds'] = 1
return response_json
def should_show_response_json(prev_response_json, response_json):
if not response_json:
raise RuntimeError("response_json should be populated: {}".format(response_json))
return (not prev_response_json or prev_response_json["slots"] != response_json["slots"]
or response_json.get("action") or response_json.get("new_slots")
or prev_response_json["interval_seconds"] != response_json["interval_seconds"])
|
437190
|
from panda3d.core import PNMImage, Filename, TextNode
from direct.gui.DirectGui import DirectFrame, DGG, DirectButton, DirectLabel, DirectSlider, DirectEntry, DirectScrolledFrame
from direct.showbase.ShowBase import ShowBase
from direct.showbase.DirectObject import DirectObject
from typing import Tuple, Union, Callable, List
import os
from structures import Colour, WHITE, BLACK, TRANSPARENT
from utility.constants import GUI_DATA_PATH
from simulator.services.services import Services
from simulator.services.persistent_state.persistent_state_views import PersistentStateViews
from simulator.services.event_manager.events.event import Event
from simulator.services.event_manager.events.new_colour_event import NewColourEvent
from simulator.services.event_manager.events.toggle_view_event import ToggleViewEvent
from simulator.views.gui.common import WINDOW_BG_COLOUR, WIDGET_BG_COLOUR
from simulator.views.gui.window import Window
class ColourPicker:
pick_colour_callback: Callable[[Tuple[float, float, float, float]], None]
__base: ShowBase
__palette_img: PNMImage
__palette_size: Tuple[int, int]
__palette_frame: DirectFrame
__marker: DirectFrame
__marker_center: DirectFrame
enabled: bool
def __init__(self, base: ShowBase, pick_colour_callback: Callable[[Tuple[float, float, float, float]], None],
**kwargs) -> None:
self.__base = base
self.pick_colour_callback = pick_colour_callback
self.enabled = True
# PALETTE #
palette_filename = os.path.join(GUI_DATA_PATH, "colour_palette.png")
self.__palette_img = PNMImage(Filename.fromOsSpecific(palette_filename))
self.__palette_size = (self.__palette_img.getReadXSize(), self.__palette_img.getReadYSize())
self.__palette_frame = DirectFrame(image=palette_filename, **kwargs)
self.__palette_frame['state'] = DGG.NORMAL
self.__palette_frame.bind(DGG.B1PRESS, command=self.__pick)
# MARKER #
self.__marker = DirectFrame(parent=self.__palette_frame,
frameColor=(0.0, 0.0, 0.0, 1.0),
frameSize=(-0.08, .08, -.08, .08),
pos=(0.0, 0.0, 0.0))
self.__marker_center = DirectFrame(parent=self.__marker,
frameSize=(-0.03, 0.03, -0.03, 0.03))
self.__marker.hide()
def __colour_at(self, x: float, y: float) -> Union[Tuple[float, float, float, float], None]:
w, h = self.__palette_size
screen = self.__base.pixel2d
img_scale = self.__palette_frame['image_scale']
sx = self.__palette_frame.getSx(screen) * img_scale[0]
sy = self.__palette_frame.getSz(screen) * img_scale[2]
x -= self.__palette_frame.getX(screen)
y -= self.__palette_frame.getZ(screen)
x = (0.5 + x / (2.0 * sx)) * w
y = (0.5 - y / (2.0 * sy)) * h
if 0 <= x < w and 0 <= y < h:
return (*self.__palette_img.getXel(int(x), int(y)), 1.0)
else:
return None
def __update_marker_colour(self) -> Tuple[float, float, float, float]:
c = self.colour_under_marker()
if c is None:
c = self.__marker_center['frameColor']
else:
self.__marker_center['frameColor'] = c
return c
def __update_marker_pos(self) -> None:
if not self.__base.mouseWatcherNode.hasMouse():
return None
pointer = self.__base.win.get_pointer(0)
x, y = pointer.getX(), -pointer.getY()
w, h = self.__palette_size
screen = self.__base.pixel2d
img_scale = self.__palette_frame['image_scale']
sx = self.__palette_frame.getSx(screen) * img_scale[0]
sy = self.__palette_frame.getSz(screen) * img_scale[2]
x -= self.__palette_frame.getX(screen)
y -= self.__palette_frame.getZ(screen)
x /= sx
y /= sy
x = max(-0.92, min(0.92, x))
y = max(-0.92, min(0.92, y))
self.__marker.set_pos(x, 0.0, y)
self.__marker.show()
def colour_under_marker(self) -> Union[Tuple[float, float, float, float], None]:
x, _, y = self.__marker.get_pos()
w, h = self.__palette_size
screen = self.__base.pixel2d
img_scale = self.__palette_frame['image_scale']
sx = self.__palette_frame.getSx(screen) * img_scale[0]
sy = self.__palette_frame.getSz(screen) * img_scale[2]
x *= sx
y *= sy
x += self.__palette_frame.getX(screen)
y += self.__palette_frame.getZ(screen)
return self.__colour_at(x, y)
def colour_under_mouse(self) -> Union[Tuple[float, float, float, float], None]:
if not self.__base.mouseWatcherNode.hasMouse():
return None
pointer = self.__base.win.get_pointer(0)
return self.__colour_at(pointer.getX(), -pointer.getY())
def __pick(self, *args):
if self.enabled:
self.__update_marker_pos()
self.pick_colour_callback(self.__update_marker_colour())
@property
def frame(self) -> DirectFrame:
return self.__palette_frame
@property
def marker(self) -> DirectFrame:
return self.__marker
class ColourView():
__frame: DirectFrame
__view: DirectFrame
__colour: Union[Colour, None]
def __init__(self, parent: DirectFrame, colour: Union[Colour, None] = None):
bg_filename = os.path.join(GUI_DATA_PATH, "colour_bg.png")
self.__frame = DirectFrame(parent=parent,
relief=DGG.SUNKEN,
image=bg_filename,
image_scale=(0.465, 1.0, 0.39),
borderWidth=(0.05, 0.05),
frameSize=(-0.52, 0.52, -0.44, 0.44),
scale=(0.5, 1.0, 0.5))
self.__view = DirectFrame(parent=self.__frame,
frameColor=colour if colour != None else TRANSPARENT,
frameSize=(-0.47, 0.47, -0.39, 0.39))
self.__colour = colour
@property
def colour(self) -> str:
return 'colour'
@colour.getter
def colour(self) -> Union[Colour, None]:
return self.__colour
@colour.setter
def colour(self, value) -> None:
self.__colour = value
self.__view['frameColor'] = value if value != None else WINDOW_BG_COLOUR
@property
def frame(self) -> DirectFrame:
return self.__frame
@property
def view(self) -> DirectFrame:
return self.__view
def destroy(self) -> None:
self.__view.destroy()
self.__frame.destroy()
class ColourChannel(DirectObject):
__slider_edit_callback: Callable[['ColourChannel', float], None]
__entry_edit_callback: Callable[['ColourChannel', float], None]
__frame: DirectFrame
__label: DirectLabel
__slider: DirectSlider
__entry: DirectEntry
__disable_frame_overlay: DirectButton
__enabled: bool
def __init__(self, parent: DirectFrame, text: str, value: float,
slider_edit_callback: Callable[['ColourChannel', float], None],
entry_edit_callback: Callable[['ColourChannel', float], None],
mouse1_press_callbacks: List[Callable[[], None]]):
self.__frame = DirectFrame(parent=parent)
self.__slider_edit_callback = slider_edit_callback
self.__entry_edit_callback = entry_edit_callback
self.__label = DirectLabel(parent=self.__frame,
text=text,
text_fg=WHITE,
text_bg=WINDOW_BG_COLOUR,
pos=(-0.5, 0.0, 0.0),
scale=(0.1, 1.0, 0.1))
self.__slider = DirectSlider(parent=self.__frame,
orientation=DGG.HORIZONTAL,
borderWidth=(0.0, 0.0),
frameColor=WIDGET_BG_COLOUR,
frameSize=(-1.0, 1.0, -0.4, 0.4),
thumb_frameSize=(-0.075, 0.075, -0.2, 0.2),
value=value,
pos=(0.05, 0.0, 0.0255),
scale=(0.45, 1.0, 0.5))
self.__entry_hovered = False
mouse1_press_callbacks.append(self.__entry_mouse_click_callback)
self.__entry = DirectEntry(parent=self.__frame,
frameColor=WIDGET_BG_COLOUR,
text_fg=WHITE,
initialText=str(value),
scale=0.1,
width=3,
suppressKeys=True,
pos=(0.55, 0.0, -0.01105))
self.__entry.bind(DGG.EXIT, self.__entry_exit_callback)
self.__entry.bind(DGG.ENTER, self.__entry_enter_callback)
self.__entry.bind(DGG.B1PRESS, self.__entry_mouse_click_callback)
self.accept("mouse1", self.__entry_mouse_click_callback)
self.__disable_frame_overlay = DirectButton(parent=self.__frame,
frameColor=TRANSPARENT,
borderWidth=(0.0, 0.0),
frameSize=(-0.6, 0.9, -0.2, 0.2),
suppressMouse=True)
self.__disable_frame_overlay.hide()
self.__enabled = True
self.__set_callbacks()
def __entry_exit_callback(self, *discard) -> None:
self.__entry_hovered = False
def __entry_enter_callback(self, *discard) -> None:
self.__entry_hovered = True
def __entry_mouse_click_callback(self, *discard) -> None:
if self.__entry_hovered:
s = self.__entry.get()
try:
f = float(s)
except:
return
self.__entry_edit_callback(self, f)
else:
self.__entry['focus'] = False
def __unset_callbacks(self):
self.__slider['command'] = None
self.__entry['command'] = None
def __set_callbacks(self):
def slider_callback() -> None:
self.__slider_edit_callback(self, self.__slider['value'])
def entry_callback(s) -> None:
try:
f = float(s)
except:
return
self.__entry_edit_callback(self, f)
self.__slider['command'] = slider_callback
self.__entry['command'] = entry_callback
@property
def frame(self) -> DirectFrame:
return self.__frame
def update_slider(self, value: float):
if not self.__enabled:
return
self.__unset_callbacks()
self.__slider['value'] = value
self.__set_callbacks()
def update_entry(self, value: float):
if not self.__enabled:
return
self.__unset_callbacks()
self.__entry.enterText(f'{value:.3f}')
self.__set_callbacks()
def update(self, value: float):
self.update_slider(value)
self.update_entry(value)
@property
def value(self) -> float:
return self.__slider['value']
@property
def enabled(self) -> str:
return 'enabled'
@enabled.setter
def enabled(self, enabled: bool) -> None:
if self.__enabled == enabled:
return
self.__enabled = enabled
if enabled:
self.__disable_frame_overlay.hide()
else:
self.__disable_frame_overlay.show()
@enabled.getter
def enabled(self) -> bool:
return self.__enabled
class AdvancedColourPicker():
__base: ShowBase
__colour: Colour
__callback: Callable[[Colour], None]
__frame: DirectFrame
__colour_picker: ColourPicker
__cv_picked: ColourView
__cv_hovered: ColourView
__r: ColourChannel
__g: ColourChannel
__b: ColourChannel
__a: ColourChannel
__dirty_rem_no_hide: int
__enabled: bool
def __init__(self, base: ShowBase, parent: DirectFrame, callback: Callable[[Colour], None],
mouse1_press_callbacks: List[Callable[[], None]],
colour: Colour = Colour(0.25, 0.5, 0.75, 1.0)):
self.__base = base
self.__colour = colour
self.__callback = callback
self.__enabled = True
self.__frame = DirectFrame(parent=parent)
self.__colour_picker = ColourPicker(self.__base,
self.__colour_picked_callback,
parent=self.__frame,
relief=DGG.SUNKEN,
borderWidth=(.0, .0),
image_scale=(1., 1., 1.),
frameColor=WIDGET_BG_COLOUR,
frameSize=(-1., 1., -1., 1.),
scale=(1.0, 1.0, 0.75),
pos=(0.0, 0.0, 0.15))
self.__cv_picked = ColourView(self.__frame, self.__colour)
self.__cv_picked.frame.set_pos(-0.74, 0.0, -1.41)
self.__cv_hovered = ColourView(self.__frame)
self.__cv_hovered.frame.set_pos(-0.74, 0.0, -0.89)
def update_cv_hovered(task):
c = self.__colour_picker.colour_under_mouse()
self.__cv_hovered.colour = c
return task.cont
self.__base.taskMgr.add(update_cv_hovered, 'update_cv_hovered')
c = self.__colour
f = self.__frame
sc = self.__colour_channel_slider_edit_callback
ec = self.__colour_channel_entry_edit_callback
self.__r = ColourChannel(f, "R", c[0], sc, ec, mouse1_press_callbacks)
self.__g = ColourChannel(f, "G", c[1], sc, ec, mouse1_press_callbacks)
self.__b = ColourChannel(f, "B", c[2], sc, ec, mouse1_press_callbacks)
self.__a = ColourChannel(f, "A", c[3], sc, ec, mouse1_press_callbacks)
x = 0.14
y_base = -0.8
y_inc = -0.25
self.__r.frame.set_pos((x, 0.0, y_base))
self.__g.frame.set_pos((x, 0.0, y_base + y_inc))
self.__b.frame.set_pos((x, 0.0, y_base + y_inc * 2))
self.__a.frame.set_pos((x, 0.0, y_base + y_inc * 3))
self.__dirty_rem_no_hide = 0
def __colour_picked_callback(self, colour: Colour):
n = 3
r, g, b, _ = colour
self.__r.update(r)
self.__g.update(g)
self.__b.update(b)
self.__cv_picked.colour = Colour(r, g, b, self.__cv_picked.colour.a)
self.__dirty_rem_no_hide = 3 # something fishy is going on
self.__callback(self.__cv_picked.colour)
def __colour_channel_slider_edit_callback(self, chn: ColourChannel, value: float):
if chn != self.__a:
if self.__dirty_rem_no_hide:
self.__dirty_rem_no_hide -= 1
else:
self.__colour_picker.marker.hide()
chn.update_entry(value)
self.__cv_picked.colour = Colour(self.__r.value, self.__g.value, self.__b.value, self.__a.value)
self.__callback(self.__cv_picked.colour)
def __colour_channel_entry_edit_callback(self, chn: ColourChannel, value: float):
if chn != self.__a:
if self.__dirty_rem_no_hide:
self.__dirty_rem_no_hide -= 1
else:
self.__colour_picker.marker.hide()
chn.update_slider(value)
self.__cv_picked.colour = Colour(self.__r.value, self.__g.value, self.__b.value, self.__a.value)
self.__callback(self.__cv_picked.colour)
@property
def frame(self) -> DirectFrame:
return self.__frame
@property
def colour(self) -> str:
return 'colour'
@colour.getter
def colour(self) -> Colour:
return self.self.__cv_picked.colour
@colour.setter
def colour(self, value: Colour) -> None:
self.__colour_picker.marker.hide()
self.__cv_picked.colour = value
r, g, b, a = value
self.__r.update(r)
self.__g.update(g)
self.__b.update(b)
self.__a.update(a)
@property
def enabled(self) -> str:
return 'enabled'
@enabled.setter
def enabled(self, enabled: bool) -> None:
if self.__enabled == enabled:
return
self.__enabled = enabled
if not enabled:
self.colour = WINDOW_BG_COLOUR
self.__colour_picker.enabled = enabled
self.__r.enabled = enabled
self.__g.enabled = enabled
self.__b.enabled = enabled
self.__a.enabled = enabled
@enabled.getter
def enabled(self) -> bool:
return self.__enabled
class ViewElement():
__name: str
__visibility_callback: Callable[[str, bool], None]
__colour_callback: Callable[[str, Colour], None]
__cv_clicked_callback: Callable[['ViewElement'], None]
__visible: bool
__frame: DirectFrame
__label: DirectLabel
__cv: ColourView
__cv_btn: DirectButton
__visibility_btn: DirectButton
__visibility_bar: DirectFrame
def __init__(self, name: str, visibility_callback: Callable[[str, bool], None],
colour_callback: Callable[[str, Colour], None], cv_clicked_callback: Callable[['ViewElement'], None],
parent: DirectFrame, visible: bool = True, colour: Colour = Colour(0.2, 0.3, 0.4, 0.5),
mouse1_press_callbacks: List[Callable[[], None]] = []):
self.__name = name
self.__visible = visible
self.__visibility_callback = None
self.__colour_callback = None
self.__cv_clicked_callback = None
self.__frame = DirectFrame(parent=parent, frameColor=WINDOW_BG_COLOUR)
self.__cv = ColourView(self.__frame, colour)
self.__cv.frame.set_scale((0.15, 1.0, 0.15))
self.__cv.frame.set_pos((-0.65, 1.0, 0.0))
self.__cv_btn = DirectButton(parent=self.__cv.frame,
frameColor=TRANSPARENT,
borderWidth=(0, 0),
frameSize=self.__cv.view["frameSize"],
scale=self.__cv.view["scale"],
pos=self.__cv.view["pos"],
command=self.__cv_clicked)
self.__label = DirectLabel(parent=self.__frame,
text=self.__name,
text_fg=WHITE,
text_bg=WINDOW_BG_COLOUR,
frameColor=WINDOW_BG_COLOUR,
text_align=TextNode.ALeft,
borderWidth=(.0, .0),
pos=(-0.3, 0.0, -0.03),
scale=(0.1, 1.0, 0.1))
visibility_filename = os.path.join(GUI_DATA_PATH, "visible.png")
self.__visibility_btn = DirectButton(parent=self.__frame,
image=visibility_filename,
frameColor=TRANSPARENT,
pos=(-0.92, 0.0, 0.0),
scale=(0.09, 1.0, 0.06),
command=self.__toggle_visible)
self.__visibility_bar = DirectFrame(parent=self.__frame,
borderWidth=(.0, .0),
frameColor=WINDOW_BG_COLOUR,
frameSize=(-0.1, 0.1, -0.01, 0.01),
pos=(-0.92, 0.0, 0.0),
hpr=(40, 0, 40))
self.visible = self.__visible # trigger UI update
self.__visibility_callback = visibility_callback
self.__colour_callback = colour_callback
self.__cv_clicked_callback = cv_clicked_callback
def __toggle_visible(self):
self.visible = not self.visible
def __cv_clicked(self):
if self.__cv_clicked_callback:
self.__cv_clicked_callback(self)
@property
def name(self) -> str:
return self.__name
@property
def frame(self) -> DirectFrame:
return self.__frame
@property
def colour_view(self) -> ColourView:
return self.__cv
@property
def colour(self) -> str:
return 'colour'
@colour.getter
def colour(self) -> Colour:
return self.__cv.colour
@colour.setter
def colour(self, value: Colour) -> None:
self.__cv.colour = value
if self.__colour_callback:
self.__colour_callback(self.name, value)
@property
def visible(self) -> str:
return 'visible'
@visible.getter
def visible(self) -> bool:
return self.__visible
@visible.setter
def visible(self, value: bool) -> None:
self.__visible = value
if self.__visibility_callback:
self.__visibility_callback(self.name, value)
if self.__visible:
self.__visibility_bar.hide()
else:
self.__visibility_bar.show()
def destroy(self) -> None:
self.__visibility_bar.destroy()
self.__visibility_btn.destroy()
self.__cv_btn.destroy()
self.__cv.destroy()
self.__label.destroy()
self.__frame.destroy()
class ViewEditor():
__services: Services
__base: ShowBase
__window: Window
__colour_picker: AdvancedColourPicker
__elems: List[ViewElement]
def __init__(self, services: Services, mouse1_press_callbacks: List[Callable[[], None]]):
self.__services = services
self.__services.ev_manager.register_listener(self)
self.__base = self.__services.graphics.window
self.__window = Window(self.__base, "view_editor", mouse1_press_callbacks,
borderWidth=(0.0, 0.0),
frameColor=WINDOW_BG_COLOUR,
pos=(1.1, 0.5, 0.5),
frameSize=(-1.1, 1.1, -5.79, 1.56)
)
self.__colour_picker = AdvancedColourPicker(self.__base, self.__window.frame, self.__colour_picker_callback, mouse1_press_callbacks)
# spacers
DirectFrame(parent=self.__window.frame,
borderWidth=(.0, .0),
frameColor=WIDGET_BG_COLOUR,
frameSize=(-1., 1., -0.01, 0.01),
pos=(0.0, 0.0, -1.75))
DirectFrame(parent=self.__window.frame,
borderWidth=(.0, .0),
frameColor=WIDGET_BG_COLOUR,
frameSize=(-1., 1., -0.01, 0.01),
pos=(0.0, 0.0, 1.1))
DirectFrame(parent=self.__window.frame,
borderWidth=(.0, .0),
frameColor=WIDGET_BG_COLOUR,
frameSize=(-1., 1., -0.01, 0.01),
pos=(0.0, 0.0, -4.1))
# ViewElements listing
self.__elems_frame = DirectScrolledFrame(parent=self.__window.frame,
frameColor=WINDOW_BG_COLOUR,
frameSize=(-1, 1, -1.125, 1.1),
pos=(0, 0, -2.9),
autoHideScrollBars=True)
# selected colour view frame
self.__selected_cv_outline = DirectFrame(parent=self.__elems_frame.getCanvas(),
relief=DGG.SUNKEN,
frameColor=WHITE,
borderWidth=(0.15, 0.15),
frameSize=(-0.62, 0.62, -0.54, 0.54),
scale=(0.18, 1.0, 0.18))
# selected view frame
self.__selected_view_outline = DirectFrame(parent=self.__window.frame,
relief=DGG.SUNKEN,
frameColor=WHITE,
borderWidth=(0.15, 0.15),
frameSize=(-0.62, 0.62, -0.54, 0.54),
scale=(0.3, 2.0, 0.35))
self.heading = DirectLabel(parent=self.__window.frame,
text="View Editor",
text_fg=WHITE,
text_bg=WINDOW_BG_COLOUR,
frameColor=WINDOW_BG_COLOUR,
borderWidth=(.0, .0),
pos=(-0.42, 0.0, 1.27),
scale=(0.2, 3, 0.2))
self.__save_outline = DirectFrame(parent=self.__window.frame,
frameColor=WHITE,
pos=(-0.57, 0, -5.45),
borderWidth=(0.25, 0.15),
frameSize=(-0.62, 0.62, -0.54, 0.54),
scale=(0.50, 2.1, 0.25))
self.__restore_outline = DirectFrame(parent=self.__window.frame,
frameColor=WHITE,
pos=(0.50, 0, -5.45),
borderWidth=(0.25, 0.15),
frameSize=(-0.62, 0.62, -0.54, 0.54),
scale=(0.65, 2.1, 0.25))
# save and restore
self.btn_s = DirectButton(
text="Save",
text_fg=(0.3, 0.3, 0.3, 1.0),
pressEffect=1,
command=self.__save,
pos=(-0.575, 0, -5.5),
parent=self.__window.frame,
scale=(0.20, 2.1, 0.15),
frameColor=TRANSPARENT)
self.btn_r = DirectButton(
text="Restore",
text_fg=(0.3, 0.3, 0.3, 1.0),
pressEffect=1,
command=self.__reset,
pos=(0.50, 0, -5.5),
parent=self.__window.frame,
scale=(0.20, 2.1, 0.15),
frameColor=TRANSPARENT)
# zoom window in / out
self.btn_zoom_out = DirectButton(
text="-",
text_fg=WHITE,
pressEffect=1,
command=self.__window.zoom_out,
pos=(0.5, 0., 1.25),
parent=self.__window.frame,
scale=(0.38, 4.25, 0.45),
frameColor=TRANSPARENT)
self.btn_zoom_in = DirectButton(
text="+",
text_fg=WHITE,
pressEffect=1,
command=self.__window.zoom_in,
pos=(0.71, 0., 1.28),
parent=self.__window.frame,
scale=(0.35, 4.19, 0.38),
frameColor=TRANSPARENT)
# Quit button
self.btn = DirectButton(text='x',
text_fg=WHITE,
command=self.__window.toggle_visible,
pos=(0.91, 0.4, 1.3),
parent=self.__window.frame,
scale=(0.3, 2.9, 0.2),
pressEffect=1,
frameColor=TRANSPARENT)
# Creating view selectors
self.__view_selectors = []
for i in range(0, PersistentStateViews.MAX_VIEWS):
num = os.path.join(GUI_DATA_PATH, str(i + 1) + ".png")
self.__view_selectors.append(DirectButton(image=num,
pos=(-0.7 + (i % 3) * 0.7, 0.4, -4.4 - 0.5 * (i // 3)),
parent=self.__window.frame,
scale=0.16,
frameColor=TRANSPARENT,
command=lambda v: setattr(self, "view_idx", v),
extraArgs=[i]))
self.__elems = []
self.__reset()
def __reset(self) -> None:
self.__services.state.views.restore_effective_view()
ps_colours = self.__services.state.views.effective_view.colours
for e in self.__elems:
e.destroy()
self.__elems.clear()
for name, dc in ps_colours.items():
self.__elems.append(ViewElement(name, self.__update_visibility, self.__update_colour, self.__select_cv,
self.__elems_frame.getCanvas(), dc.visible, dc.colour))
for i in range(len(self.__elems)):
self.__elems[i].frame.set_pos((0.15, 0.0, -0.2 * i))
self.__elems_frame["canvasSize"] = (-0.95, 0.95, -0.2 * len(self.__elems) + 0.1, 0.1)
self.__cur_view_idx = self.view_idx
self.__selected_view_outline.set_pos((-0.7 + (self.view_idx % 3) * 0.7, 0.4, -4.4 - 0.5 * (self.view_idx // 3)))
self.__select_cv(self.__elems[0] if self.__elems else None)
def __save(self) -> None:
self.__services.state.views.apply_effective_view()
def __update_visibility(self, name: str, visible: bool) -> None:
self.__services.state.views.effective_view.colours[name].visible = visible
def __update_colour(self, name: str, colour: Colour) -> None:
self.__services.state.views.effective_view.colours[name].colour = colour
def __colour_picker_callback(self, colour: Colour) -> None:
self.__window.focus()
if self.__selected_cv_elem is not None:
self.__selected_cv_elem.colour = colour # calls self.__update_colour()
def __select_cv(self, e: ViewElement):
self.__window.focus()
self.__selected_cv_elem = e
if e is None:
self.__selected_cv_outline.hide()
self.__colour_picker.enabled = False
else:
self.__colour_picker.enabled = True
self.__selected_cv_outline.show()
self.__selected_cv_outline.set_pos((-0.495, 1.0, -0.2 * self.__elems.index(e)))
self.__colour_picker.colour = e.colour
def notify(self, event: Event) -> None:
if isinstance(event, NewColourEvent) or self.__services.state.views.view_idx != self.__cur_view_idx:
self.__reset()
elif isinstance(event, ToggleViewEvent):
self.__window.toggle_visible()
@property
def view_idx(self) -> str:
return 'view_idx'
@view_idx.setter
def view_idx(self, idx: int) -> None:
self.__services.state.views.view_idx = idx
self.__reset()
@view_idx.getter
def view_idx(self) -> int:
return self.__services.state.views.view_idx
|
437250
|
import torch
import utils
####-----------------------------####
####----model evaluation----####
####-----------------------------####
def validate(model, dataset, batch_size=32, test_size=1024, verbose=True, allowed_classes=None,
with_exemplars=False, task=None):
'''Evaluate precision (= accuracy or proportion correct) of a classifier ([model]) on [dataset].
[allowed_classes] None or <list> containing all "active classes" between which should be chosen
(these "active classes" are assumed to be contiguous)'''
# Set model to eval()-mode
mode = model.training
model.eval()
# Loop over batches in [dataset]
data_loader = utils.get_data_loader(dataset, batch_size, cuda=model._is_on_cuda())
total_tested = total_correct = 0
for data, labels in data_loader:
# -break on [test_size] (if "None", full dataset is used)
if test_size:
if total_tested >= test_size:
break
# -evaluate model (if requested, only on [allowed_classes])
data, labels = data.to(model._device()), labels.to(model._device())
# labels = labels - allowed_classes[0] if (allowed_classes is not None) else labels
with torch.no_grad():
if with_exemplars:
predicted = model.classify_with_exemplars(data, allowed_classes=allowed_classes)
# - in case of Domain-IL scenario, collapse all corresponding domains into same class
if max(predicted).item() >= model.classes:
predicted = predicted % model.classes
else:
scores = model(data) if (allowed_classes is None) else model(data)[:, allowed_classes]
_, predicted = torch.max(scores, 1)
# -update statistics
total_correct += (predicted == labels).sum().item()
total_tested += len(data)
precision = total_correct / total_tested
# Set model back to its initial mode, print result on screen (if requested) and return it
model.train(mode=mode)
if verbose:
print('=> precision: {:.3f}'.format(precision))
return precision
def validate5(model, dataset, batch_size=32, test_size=1024, verbose=True, allowed_classes=None,
with_exemplars=False, task=None):
'''Evaluate precision (= accuracy or proportion correct) of a classifier ([model]) on [dataset].
[allowed_classes] None or <list> containing all "active classes" between which should be chosen
(these "active classes" are assumed to be contiguous)'''
# Set model to eval()-mode
mode = model.training
model.eval()
# Loop over batches in [dataset]
data_loader = utils.get_data_loader(dataset, batch_size, cuda=model._is_on_cuda())
total_tested = total_correct = 0
for data, labels in data_loader:
# -break on [test_size] (if "None", full dataset is used)
if test_size:
if total_tested >= test_size:
break
# -evaluate model (if requested, only on [allowed_classes])
data, labels = data.to(model._device()), labels.to(model._device())
# labels = labels - allowed_classes[0] if (allowed_classes is not None) else labels
with torch.no_grad():
if with_exemplars:
predicted = model.classify_with_exemplars(data, allowed_classes=allowed_classes)
# - in case of Domain-IL scenario, collapse all corresponding domains into same class
if max(predicted).item() >= model.classes:
predicted = predicted % model.classes
else:
scores = model(data) if (allowed_classes is None) else model(data)[:, allowed_classes]
_, predicted = scores.topk(1, -1)
# -update statistics
for i in range(5):
total_correct += (predicted[:, i] == labels).sum().item()
total_tested += len(data)
precision = total_correct / total_tested
# Set model back to its initial mode, print result on screen (if requested) and return it
model.train(mode=mode)
if verbose:
print('=> precision: {:.3f}'.format(precision))
return precision
def initiate_precision_dict(n_tasks):
'''Initiate <dict> with all precision-measures to keep track of.'''
precision = {}
precision["all_tasks"] = [[] for _ in range(n_tasks)]
precision["average"] = []
precision["x_iteration"] = []
precision["x_task"] = []
return precision
def precision(model, datasets, current_task, iteration, classes_per_task=None,
precision_dict=None, test_size=None, verbose=False, summary_graph=True,
with_exemplars=False):
'''Evaluate precision of a classifier (=[model]) on all tasks so far (= up to [current_task]) using [datasets].
[precision_dict] None or <dict> of all measures to keep track of, to which results will be appended to
[classes_per_task] <int> number of active classes er task'''
# Evaluate accuracy of model predictions for all tasks so far (reporting "0" for future tasks)
n_tasks = len(datasets)
precs = []
for i in range(n_tasks):
if i + 1 <= current_task:
allowed_classes = None
precs.append(validate(model, datasets[i], test_size=test_size, verbose=verbose,
allowed_classes=allowed_classes, with_exemplars=with_exemplars,
task=i + 1))
else:
precs.append(0)
average_precs = sum([precs[task_id] for task_id in range(current_task)]) / current_task
# Print results on screen
if verbose:
print(' => ave precision: {:.3f}'.format(average_precs))
names = ['task {}'.format(i + 1) for i in range(n_tasks)]
# Append results to [progress]-dictionary and return
if precision_dict is not None:
for task_id, _ in enumerate(names):
precision_dict["all_tasks"][task_id].append(precs[task_id])
precision_dict["average"].append(average_precs)
precision_dict["x_iteration"].append(iteration)
precision_dict["x_task"].append(current_task)
return precision_dict
|
437256
|
from Properties import VaporPressure, Props
from units import conv_unit
from utils import f2str
from PySide2 import QtCore, QtWidgets, QtGui
from compounds import FluidState
def tablewidget_vap_liq_reports(
pliq: Props,
pvap: Props,
pvp: VaporPressure,
state: FluidState = FluidState.Unknown,
isMixture: bool = False,
**units
):
"""
Generates a table-formatted calculations report.
Parameters
----------
pliq : Props
liquid properties to be reported
pvap : Props
vapor properties to be reported
pvp : VaporPressure
vapor pressure(s) to be reported
state : FluidState, enum
State of the fluid
isMixture : bool
True value if system is a mixture
units : kwarg
units in which the results will be reported
Returns
-------
labels : list of str
formatted properties labels
liq_values : list of str
formatted liquid properties
vap_values : list of str
formatted vapor properties
"""
labels = []
liq_values = []
vap_values = []
has_ig = True if pliq.IGProps != 0 else False
# defines delta string for state properties
delta_char = "delta"
# units
Tu = units["T"] if "T" in units else "K"
Vu = units["V"] if "V" in units else "m3/mol"
Pu = units["P"] if "P" in units else "Pa"
rhou = units["rho"] if "rho" in units else "kg/m3"
ene_per_molu = units["energy_per_mol"] if "energy_per_mol" in units else "J/mol"
ene_per_mol_tempu = (
units["energy_per_mol_temp"] if "energy_per_mol_temp" in units else "J/molK"
)
# Z, V and density
Zl = f2str(pliq.Z, 6, lt=1e-1)
Zv = f2str(pvap.Z, 6, lt=1e-1)
labels.append("Z")
liq_values.append(Zl)
vap_values.append(Zv)
Vs = "V [{0}]".format(Vu)
Vl = f2str(conv_unit(pliq.V, "m3/mol", Vu), 6, lt=1e-2, gt=1e4)
Vv = f2str(conv_unit(pvap.V, "m3/mol", Vu), 6, lt=1e-2, gt=1e4)
labels.append(Vs)
liq_values.append(Vl)
vap_values.append(Vv)
if pliq.rho and pvap.rho:
rhos = "Density [{0}]".format(rhou)
rhol = f2str(conv_unit(pliq.rho, "kg/m3", rhou), 6, lt=1e-2, gt=1e4)
rhov = f2str(conv_unit(pvap.rho, "kg/m3", rhou), 6, lt=1e-2, gt=1e4)
labels.append(rhos)
liq_values.append(rhol)
vap_values.append(rhov)
# Vapor pressure
if state not in (FluidState.Gas, FluidState.Supercritical):
if pvp.EOS:
Pvpeoss = "Vap. P (EOS) [{0}]".format(Pu)
Pvpeosl = f2str(conv_unit(pvp.EOS, "Pa", Pu), 6, lt=1e-2, gt=1e4)
labels.append(Pvpeoss)
liq_values.append(Pvpeosl)
vap_values.append(Pvpeosl)
if pvp.AW:
PvpAWs = "Vap. P (Ambrose-Walton) [{0}]".format(Pu)
PvpAWl = f2str(conv_unit(pvp.AW, "Pa", Pu), 6, lt=1e-2, gt=1e4)
labels.append(PvpAWs)
liq_values.append(PvpAWl)
vap_values.append(PvpAWl)
PvpLKs = "Vap. P (Lee-Kesler) [{0}]".format(Pu)
PvpLKl = f2str(conv_unit(pvp.LK, "Pa", Pu), 6, lt=1e-2, gt=1e4)
labels.append(PvpLKs)
liq_values.append(PvpLKl)
vap_values.append(PvpLKl)
#
if pvp.Antoine:
PvpAntoines = "Vap. P (Antoine) [{0}]".format(Pu)
PvpAntoinel = f2str(conv_unit(pvp.Antoine, "Pa", Pu), 6, lt=1e-2, gt=1e4)
labels.append(PvpAntoines)
liq_values.append(PvpAntoinel)
vap_values.append(PvpAntoinel)
# real properties (if any)
if has_ig:
# real properties
dHs = delta_char + "H [{0}]".format(ene_per_molu)
dHliq = f2str(
conv_unit(pliq.Props.H, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
dHvap = f2str(
conv_unit(pvap.Props.H, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
labels.append(dHs)
liq_values.append(dHliq)
vap_values.append(dHvap)
dSs = delta_char + "S [{0}]".format(ene_per_mol_tempu)
dSliq = f2str(
conv_unit(pliq.Props.S, "J/molK", ene_per_mol_tempu), 6, lt=1e-2, gt=1e4
)
dSvap = f2str(
conv_unit(pvap.Props.S, "J/molK", ene_per_mol_tempu), 6, lt=1e-2, gt=1e4
)
labels.append(dSs)
liq_values.append(dSliq)
vap_values.append(dSvap)
dGs = delta_char + "G [{0}]".format(ene_per_molu)
dGliq = f2str(
conv_unit(pliq.Props.G, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
dGvap = f2str(
conv_unit(pvap.Props.G, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
labels.append(dGs)
liq_values.append(dGliq)
vap_values.append(dGvap)
dUs = delta_char + "U [{0}]".format(ene_per_molu)
dUliq = f2str(
conv_unit(pliq.Props.U, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
dUvap = f2str(
conv_unit(pvap.Props.U, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
labels.append(dUs)
liq_values.append(dUliq)
vap_values.append(dUvap)
dAs = delta_char + "A [{0}]".format(ene_per_molu)
dAliq = f2str(
conv_unit(pliq.Props.A, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
dAvap = f2str(
conv_unit(pvap.Props.A, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
labels.append(dAs)
liq_values.append(dAliq)
vap_values.append(dAvap)
# fugacity
fs = "Fugacity [{0}]".format(Pu)
fliq = f2str(conv_unit(pliq.Fugacity, "Pa", Pu), 8, lt=1e-2, gt=1e4)
fvap = f2str(conv_unit(pvap.Fugacity, "Pa", Pu), 8, lt=1e-2, gt=1e4)
labels.append(fs)
liq_values.append(fliq)
vap_values.append(fvap)
# Ideal properties
# Cp
Cps = "Cp [{0}]".format(ene_per_mol_tempu)
Cpl = f2str(
conv_unit(pliq.IGProps.Cp, "J/molK", ene_per_mol_tempu), 6, lt=1e-2, gt=1e4
)
labels.append(Cps)
liq_values.append(Cpl)
vap_values.append(Cpl)
dHIGs = delta_char + "IG H [{0}]".format(ene_per_molu)
dHIG = f2str(
conv_unit(pliq.IGProps.H, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
labels.append(dHIGs)
liq_values.append(dHIG)
vap_values.append(dHIG)
dSIGs = delta_char + "IG S [{0}]".format(ene_per_mol_tempu)
dSIG = f2str(
conv_unit(pliq.IGProps.S, "J/molK", ene_per_mol_tempu), 6, lt=1e-2, gt=1e4
)
labels.append(dSIGs)
liq_values.append(dSIG)
vap_values.append(dSIG)
dGIGs = delta_char + "IG G [{0}]".format(ene_per_molu)
dGIG = f2str(
conv_unit(pliq.IGProps.G, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
labels.append(dGIGs)
liq_values.append(dGIG)
vap_values.append(dGIG)
dUIGs = delta_char + "IG U [{0}]".format(ene_per_molu)
dUIG = f2str(
conv_unit(pliq.IGProps.U, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
labels.append(dUIGs)
liq_values.append(dUIG)
vap_values.append(dUIG)
dAIGs = delta_char + "IG A [{0}]".format(ene_per_molu)
dAIG = f2str(
conv_unit(pliq.IGProps.A, "J/mol", ene_per_molu), 6, lt=1e-2, gt=1e4
)
labels.append(dAIGs)
liq_values.append(dAIG)
vap_values.append(dAIG)
else:
fs = "Fugacity [{0}]".format(Pu)
fliq = f2str(conv_unit(pliq.Fugacity, "Pa", Pu), 8, lt=1e-2, gt=1e4)
fvap = f2str(conv_unit(pvap.Fugacity, "Pa", Pu), 8, lt=1e-2, gt=1e4)
labels.append(fs)
liq_values.append(fliq)
vap_values.append(fvap)
# log += "Compound have no ideal properties (maybe it doesn't have ideal Cp parameters)\n"
return labels, liq_values, vap_values
|
437282
|
import tensorflow as tf
import math
class EmbeddingLayer(tf.keras.layers.Layer):
def __init__(self, vocab_size, embedding_size, initializer=None, stddev=0.01, mean=0.0):
super(EmbeddingLayer, self).__init__()
self.vocab_size = vocab_size
self.embedding_size = embedding_size
self.stddev = stddev
self.mean = mean
self.initializer = initializer
if self.initializer is None:
self.initializer = tf.random_normal_initializer(mean=self.mean,
stddev=self.stddev)
def build(self, input_shape):
with tf.name_scope("embedding_weights"):
self.embedding_weights = self.add_weight(
"weights",
shape=[self.vocab_size, self.embedding_size],
dtype="float32",
initializer=self.initializer
)
super(EmbeddingLayer, self).build(input_shape)
def call(self, inputs, mode="embedding", scale=False):
if mode == "embedding":
return self.embedding(inputs, scale=scale)
elif mode == "projection":
return self.projection(inputs)
else:
raise ValueError("mode {} is not valid.".format(mode))
def embedding(self, inputs, scale=False):
with tf.name_scope("embedding"):
# Create binary mask of size [batch_size, length]
mask = tf.cast(tf.not_equal(inputs, 0), tf.float32)
inputs = tf.cast(inputs, tf.int32)
embeddings = tf.nn.embedding_lookup(self.embedding_weights, inputs)
embeddings *= tf.expand_dims(mask, -1)
# Scale embedding by the sqrt of the hidden size
if scale:
embeddings *= self.embedding_size ** 0.5
return embeddings
def projection(self, inputs):
with tf.name_scope("output_layer"):
batch_size = tf.shape(inputs)[0]
seq_len = tf.shape(inputs)[1]
h_flat = tf.reshape(inputs, [-1, self.embedding_size])
logits = tf.matmul(h_flat, self.embedding_weights, transpose_b=True)
return tf.reshape(logits, [batch_size, seq_len, self.vocab_size])
class PositionEmbeddingLayer(tf.keras.layers.Layer):
def __init__(self, position_seq, pos_embedding_size, trainable=True, stddev=0.02, mean=0.0):
super(PositionEmbeddingLayer, self).__init__()
self.position_seq = position_seq
self.hidden_size = pos_embedding_size
self.trainable = trainable
self.stddev = stddev
self.mean = mean
if trainable:
self.position_embedding = EmbeddingLayer(self.position_seq, self.hidden_size,
stddev=self.stddev, mean=self.mean)
def call(self, inputs, start=1):
with tf.name_scope("pos_embedding"):
if self.trainable:
batch_size = tf.shape(inputs)[0]
batch_seq = tf.shape(inputs)[1]
positions = tf.reshape(tf.tile(tf.range(start, batch_seq + start), [batch_size]),
[batch_size, batch_seq])
positions = tf.cast(positions, tf.int32)
position_mask = tf.cast(tf.not_equal(inputs, 0), tf.int32)
positions *= position_mask
return self.position_embedding(positions)
else:
return self.get_position_sinusoid(self.position_seq)
@staticmethod
def get_position_sinusoid(seq_len, hidden_size, min_timescale=1.0, max_timescale=1.0e4):
position = tf.cast(tf.range(seq_len), tf.float32)
num_timescales = hidden_size // 2
log_timescale_increment = (
math.log(float(max_timescale) / float(min_timescale)) /
(tf.cast(num_timescales, tf.float32) - 1))
inv_timescales = min_timescale * tf.exp(
tf.cast(tf.range(num_timescales), tf.float32) * -log_timescale_increment)
scaled_time = tf.expand_dims(position, 1) * tf.expand_dims(inv_timescales, 0)
signal = tf.concat([tf.sin(scaled_time), tf.cos(scaled_time)], axis=1)
return signal
|
437321
|
import os
import re
import socket
import subprocess
from typing import List # noqa: F401
from libqtile import layout, bar, widget, hook
from libqtile.config import Click, Drag, Group, Key, Match, Screen, Rule
from libqtile.command import lazy
from libqtile.widget import Spacer
import arcobattery
#mod4 or mod = super key
mod = "mod4"
mod1 = "alt"
mod2 = "control"
home = os.path.expanduser('~')
@lazy.function
def window_to_prev_group(qtile):
if qtile.currentWindow is not None:
i = qtile.groups.index(qtile.currentGroup)
qtile.currentWindow.togroup(qtile.groups[i - 1].name)
@lazy.function
def window_to_next_group(qtile):
if qtile.currentWindow is not None:
i = qtile.groups.index(qtile.currentGroup)
qtile.currentWindow.togroup(qtile.groups[i + 1].name)
keys = [
# Most of our keybindings are in sxhkd file - except these
# SUPER + FUNCTION KEYS
Key([mod, "shift"], "f", lazy.window.toggle_fullscreen()),
Key([mod], "q", lazy.window.kill()),
# SUPER + SHIFT KEYS
Key([mod, "shift"], "q", lazy.window.kill()),
Key([mod, "shift"], "r", lazy.restart()),
# QTILE LAYOUT KEYS
Key([mod], "n", lazy.layout.normalize()),
Key([mod, "shift"], "space", lazy.next_layout()),
# CHANGE FOCUS
Key([mod], "Up", lazy.layout.up()),
Key([mod], "Down", lazy.layout.down()),
Key([mod], "Left", lazy.layout.left()),
Key([mod], "Right", lazy.layout.right()),
Key([mod], "k", lazy.layout.up()),
Key([mod], "j", lazy.layout.down()),
Key([mod], "h", lazy.layout.left()),
Key([mod], "l", lazy.layout.right()),
Key(["mod1"], "Tab", lazy.layout.next()),
# RESIZE UP, DOWN, LEFT, RIGHT
Key([mod, "control"], "l",
lazy.layout.grow_right(),
lazy.layout.grow(),
lazy.layout.increase_ratio(),
lazy.layout.delete(),
),
Key([mod, "control"], "Right",
lazy.layout.grow_right(),
lazy.layout.grow(),
lazy.layout.increase_ratio(),
lazy.layout.delete(),
),
Key([mod, "control"], "h",
lazy.layout.grow_left(),
lazy.layout.shrink(),
lazy.layout.decrease_ratio(),
lazy.layout.add(),
),
Key([mod, "control"], "Left",
lazy.layout.grow_left(),
lazy.layout.shrink(),
lazy.layout.decrease_ratio(),
lazy.layout.add(),
),
Key([mod, "control"], "k",
lazy.layout.grow_up(),
lazy.layout.grow(),
lazy.layout.decrease_nmaster(),
),
Key([mod, "control"], "Up",
lazy.layout.grow_up(),
lazy.layout.grow(),
lazy.layout.decrease_nmaster(),
),
Key([mod, "control"], "j",
lazy.layout.grow_down(),
lazy.layout.shrink(),
lazy.layout.increase_nmaster(),
),
Key([mod, "control"], "Down",
lazy.layout.grow_down(),
lazy.layout.shrink(),
lazy.layout.increase_nmaster(),
),
# FLIP LAYOUT FOR MONADTALL/MONADWIDE
Key([mod, "shift"], "f", lazy.layout.flip()),
# FLIP LAYOUT FOR BSP
Key([mod, "mod1"], "k", lazy.layout.flip_up()),
Key([mod, "mod1"], "j", lazy.layout.flip_down()),
Key([mod, "mod1"], "l", lazy.layout.flip_right()),
Key([mod, "mod1"], "h", lazy.layout.flip_left()),
# MOVE WINDOWS UP OR DOWN BSP LAYOUT
Key([mod, "shift"], "k", lazy.layout.shuffle_up()),
Key([mod, "shift"], "j", lazy.layout.shuffle_down()),
Key([mod, "shift"], "h", lazy.layout.shuffle_left()),
Key([mod, "shift"], "l", lazy.layout.shuffle_right()),
# MOVE WINDOWS UP OR DOWN MONADTALL/MONADWIDE LAYOUT
Key([mod, "shift"], "Up", lazy.layout.shuffle_up()),
Key([mod, "shift"], "Down", lazy.layout.shuffle_down()),
Key([mod, "shift"], "Left", lazy.layout.swap_left()),
Key([mod, "shift"], "Right", lazy.layout.swap_right()),
# TOGGLE FLOATING LAYOUT
Key([mod, "shift"], "space", lazy.window.toggle_floating()),
]
groups = []
# FOR QWERTY KEYBOARDS
group_names = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0",]
# FOR AZERTY KEYBOARDS
#group_names = ["ampersand", "eacute", "quotedbl", "apostrophe", "parenleft", "section", "egrave", "exclam", "ccedilla", "agrave",]
#group_labels = ["1 ", "2 ", "3 ", "4 ", "5 ", "6 ", "7 ", "8 ", "9 ", "0",]
#group_labels = ["", "", "", "", "", "", "", "", "", "",]
group_labels = [" globe-asia", " file-word", " code", " bug", " folder", " comment-dots", " music", " video", " images", " envelope-open-text",]
group_layouts = ["monadtall", "monadtall", "monadtall", "monadtall", "monadtall", "monadtall", "monadtall", "monadtall", "monadtall", "monadtall",]
#group_layouts = ["monadtall", "matrix", "monadtall", "bsp", "monadtall", "matrix", "monadtall", "bsp", "monadtall", "monadtall",]
for i in range(len(group_names)):
groups.append(
Group(
name=group_names[i],
layout=group_layouts[i].lower(),
label=group_labels[i],
))
for i in groups:
keys.extend([
#CHANGE WORKSPACES
Key([mod], i.name, lazy.group[i.name].toscreen()),
Key([mod], "Right", lazy.screen.next_group()),
Key([mod], "Left" , lazy.screen.prev_group()),
# Key(["mod1"], "Tab", lazy.screen.next_group()),
# Key(["mod1", "shift"], "Tab", lazy.screen.prev_group()),
# MOVE WINDOW TO SELECTED WORKSPACE 1-10 AND STAY ON WORKSPACE
#Key([mod, "shift"], i.name, lazy.window.togroup(i.name)),
# MOVE WINDOW TO SELECTED WORKSPACE 1-10 AND FOLLOW MOVED WINDOW TO WORKSPACE
Key([mod, "shift"], i.name, lazy.window.togroup(i.name) , lazy.group[i.name].toscreen()),
])
def init_layout_theme():
return {"margin":5,
"border_width":2,
"border_focus": "#5e81ac",
"border_normal": "#4c566a"
}
layout_theme = init_layout_theme()
layouts = [
layout.MonadTall(margin=4, border_width=2, border_focus="#660033", border_normal="#44475a"),
layout.MonadWide(margin=4, border_width=2, border_focus="#660033", border_normal="#44475a"),
layout.Matrix(**layout_theme),
layout.Bsp(**layout_theme),
layout.Floating(**layout_theme),
layout.RatioTile(**layout_theme),
layout.Max(**layout_theme)
]
# COLORS FOR THE BAR
def init_colors():
return [["#2F343F", "#2F343F"], # color 0
["#000000", "#000000"], # color 1
["#f8f8f2", "#f8f8f2"], # color 2
["#fba922", "#fba922"], # color 3
["#3384d0", "#3384d0"], # color 4
["#CC0066", "#CC0066"], # color 5
["#cd1f3f", "#cd1f3f"], # color 6
["#62FF00", "#62FF00"], # color 7
["#6272a4", "#6272a4"], # color 8
["#CC0066", "#CC0066"]] # color 9
colors = init_colors()
# WIDGETS FOR THE BAR
def init_widgets_defaults():
return dict(font="Noto Sans",
fontsize = 15,
padding = 2,
background=colors[1])
widget_defaults = init_widgets_defaults()
def init_widgets_list():
prompt = "{0}@{1}: ".format(os.environ["USER"], socket.gethostname())
widgets_list = [
widget.GroupBox(font="Font Awesome 5 Free Solid",
fontsize = 20,
margin_y = 2,
margin_x = 0,
padding_y = 8,
padding_x = 5,
borderwidth = 0,
disable_drag = True,
active = colors[9],
inactive = colors[5],
rounded = True,
highlight_method = "text",
this_current_screen_border = colors[8],
foreground = colors[2],
background = colors[1]
),
widget.Sep(
linewidth = 1,
padding = 20,
foreground = colors[8],
background = colors[1]
),
#widget.CurrentLayout(
# font = "Noto Sans Bold",
# foreground = colors[5],
# background = colors[1]
# ),
# widget.Net(
# font="Noto Sans",
# fontsize=12,
# interface="enp0s31f6",
# foreground=colors[2],
# background=colors[1],
# padding = 0,
# ),
widget.NetGraph(
font="Noto Sans",
fontsize=12,
bandwidth="down",
interface="auto",
fill_color = colors[2],
foreground=colors[2],
background=colors[1],
graph_color = colors[2],
border_color = colors[1],
padding = 0,
border_width = 1,
line_width = 1,
),
widget.Sep(
linewidth = 1,
padding = 20,
foreground = colors[8],
background = colors[1]
),
widget.WindowName(font="Ubuntu Mono Bold",
fontsize = 16,
foreground = colors[2],
background = colors[1],
),
# # do not activate in Virtualbox - will break qtile
# widget.ThermalSensor(
# foreground = colors[5],
# foreground_alert = colors[6],
# background = colors[1],
# metric = True,
# padding = 3,
# threshold = 80
# ),
# widget.CPUGraph(
# border_color = colors[2],
# fill_color = colors[8],
# graph_color = colors[8],
# background=colors[1],
# border_width = 1,
# line_width = 1,
# core = "all",
# type = "box"
# ),
widget.Memory(
font="Ubuntu Mono Bold",
format = '{MemUsed: .0f}{mm} /{MemTotal: .0f}{mm}',
update_interval = 1,
fontsize = 15,
foreground = colors[2],
background = colors[1],
),
widget.Sep(
linewidth = 1,
padding = 20,
foreground = colors[8],
background = colors[1]
),
widget.Clock(
font="Ubuntu Mono Bold",
foreground = colors[5],
background = colors[1],
fontsize = 16,
format=" %d-%m-%Y %H:%M "
),
widget.Sep(
linewidth = 1,
padding = 20,
foreground = colors[8],
background = colors[1]
),
widget.Systray(
background=colors[1],
icon_size=20,
padding = 4
),
arcobattery.BatteryIcon(
padding=0,
scale=0.7,
y_poss=2,
theme_path=home + "/.config/qtile/icons/battery_icons_horiz",
update_interval = 5,
background = colors[1]
),
widget.Battery(
font="Ubuntu Mono Bold",
format='{percent:2.0%}',
update_interval = 10,
fontsize = 16,
foreground = colors[2],
background = colors[1],
),
widget.Sep(
linewidth = 1,
padding = 10,
foreground = colors[1],
background = colors[1]
),
]
return widgets_list
widgets_list = init_widgets_list()
def init_widgets_screen1():
widgets_screen1 = init_widgets_list()
return widgets_screen1
def init_widgets_screen2():
widgets_screen2 = init_widgets_list()
return widgets_screen2
widgets_screen1 = init_widgets_screen1()
widgets_screen2 = init_widgets_screen2()
def init_screens():
return [Screen(top=bar.Bar(widgets=init_widgets_screen1(), size=35, opacity=0.9, margin=5)),
Screen(top=bar.Bar(widgets=init_widgets_screen2(), size=35, opacity=0.9, margin=5))]
screens = init_screens()
# MOUSE CONFIGURATION
mouse = [
Drag([mod], "Button1", lazy.window.set_position_floating(),
start=lazy.window.get_position()),
Drag([mod], "Button3", lazy.window.set_size_floating(),
start=lazy.window.get_size())
]
dgroups_key_binder = None
dgroups_app_rules = []
main = None
@hook.subscribe.startup_once
def start_once():
home = os.path.expanduser('~')
subprocess.call([home + '/.config/qtile/scripts/autostart.sh'])
@hook.subscribe.startup
def start_always():
# Set the cursor to something sane in X
subprocess.Popen(['xsetroot', '-cursor_name', 'left_ptr'])
@hook.subscribe.client_new
def set_floating(window):
if (window.window.get_wm_transient_for()
or window.window.get_wm_type() in floating_types):
window.floating = True
floating_types = ["notification", "toolbar", "splash", "dialog"]
follow_mouse_focus = False
bring_front_click = False
cursor_warp = False
floating_layout = layout.Floating(float_rules=[
# Run the utility of `xprop` to see the wm class and name of an X client.
*layout.Floating.default_float_rules,
Match(wm_class='confirmreset'), # gitk
Match(wm_class='makebranch'), # gitk
Match(wm_class='maketag'), # gitk
Match(wm_class='ssh-askpass'), # ssh-askpass
Match(title='branchdialog'), # gitk
Match(title='pinentry'), # GPG key password entry
Match(wm_class='Arcolinux-welcome-app.py'),
Match(wm_class='Arcolinux-tweak-tool.py'),
Match(wm_class='Arcolinux-calamares-tool.py'),
Match(wm_class='confirm'),
Match(wm_class='dialog'),
Match(wm_class='download'),
Match(wm_class='error'),
Match(wm_class='file_progress'),
Match(wm_class='notification'),
Match(wm_class='splash'),
Match(wm_class='toolbar'),
Match(wm_class='Arandr'),
Match(wm_class='feh'),
Match(wm_class='Galculator'),
Match(wm_class='arcolinux-logout'),
Match(wm_class='xfce4-terminal'),
], fullscreen_border_width = 0, border_width = 0)
auto_fullscreen = True
focus_on_window_activation = "focus" # or smart
wmname = "Qtile"
|
437451
|
from pydantic import BaseModel, validator
from tracardi.domain.named_entity import NamedEntity
class Content(BaseModel):
content: str
type: str
@validator("type")
def validate_type(cls, value):
if value not in ("text/plain", "text/html"):
raise ValueError("Message content type must be either HTML or plain text.")
return value
class Message(BaseModel):
recipient: str
subject: str = ""
content: Content
@validator("recipient")
def recipient_subject(cls, value):
if len(value) == 0:
raise ValueError("Recipient e-mail can not be empty.")
return value
@validator("subject")
def validate_subject(cls, value):
if len(value) == 0:
raise ValueError("Subject must be at least one character long.")
return value
class Config(BaseModel):
source: NamedEntity
sender_email: str
message: Message
@validator("sender_email")
def sender_email_subject(cls, value):
if len(value) == 0:
raise ValueError("Sender e-mail can not be empty.")
return value
class Token(BaseModel):
token: str
|
437475
|
import bagua.torch_api as bagua
import torch
import torch.optim as optim
import unittest
import os
from tests.internal.common_utils import find_free_port
from tests import skip_if_cuda_available, skip_if_cuda_not_available
import logging
logging.getLogger().setLevel(logging.INFO)
def construct_model_and_optimizer(opt, flag_param, device):
weight = torch.tensor(
[[-0.2109, -0.4976], [-0.1413, -0.3420], [-0.2524, 0.6976]],
requires_grad=True,
)
bias = torch.tensor(
[-0.1085, -0.2979, 0.6892],
requires_grad=True,
)
weight2 = torch.tensor(
[[-0.0508, -0.3941, -0.2843]],
requires_grad=True,
)
bias2 = torch.tensor([-0.0711], requires_grad=True)
model = torch.nn.Sequential(
torch.nn.Linear(2, 3),
torch.nn.Sigmoid(),
torch.nn.Linear(3, 1),
torch.nn.Sigmoid(),
)
pretrained_dict = model.state_dict()
pretrained_dict["0.weight"] = weight
pretrained_dict["0.bias"] = bias
pretrained_dict["2.weight"] = weight2
pretrained_dict["2.bias"] = bias2
model.load_state_dict(pretrained_dict)
model = model.to(device)
no_decay = ["bias"]
optimizer_grouped_parameters = [
{
"params": [
p
for n, p in model.named_parameters()
if not any(nd in n for nd in no_decay)
],
"weight_decay": 0.1,
},
{
"params": [
p
for n, p in model.named_parameters()
if any(nd in n for nd in no_decay)
],
"weight_decay": 0.0,
},
]
optimizer = opt(optimizer_grouped_parameters, **flag_param)
return model, optimizer
def train_model(model, optimizer, device, num_epochs):
input = torch.tensor([0.1, 0.2, 0.3, 0.4, 0.5, 0.6], device=device).reshape(3, 2)
for epoch in range(num_epochs):
optimizer.zero_grad()
output = model(input)
loss = output.sum()
loss.backward()
optimizer.step()
# logging.debug(f"#train model#{epoch} params: {optimizer.param_groups}")
# logging.debug(f"#train model#{epoch} state: {optimizer.state}")
def train_model_fused(model, optimizer, device, num_epochs):
input = torch.tensor([0.1, 0.2, 0.3, 0.4, 0.5, 0.6], device=device).reshape(3, 2)
for epoch in range(num_epochs):
optimizer.zero_grad()
output = model(input)
loss = output.sum()
loss.backward()
if epoch % 2 == 0:
optimizer.fuse_step()
else:
optimizer.step()
# logging.debug(
# f"#train model fused#{epoch} params: {optimizer._bagua_fused_optimizer.param_groups}"
# )
# logging.debug(f"#train model fused#{epoch} state: {optimizer.state}")
def bagua_init(model, optimizer, algorithm, do_flatten):
# wrap model
if algorithm == "gradient_allreduce":
from bagua.torch_api.algorithms import gradient_allreduce
bagua_algorithm = gradient_allreduce.GradientAllReduceAlgorithm()
elif algorithm == "bytegrad":
from bagua.torch_api.algorithms import bytegrad
bagua_algorithm = bytegrad.ByteGradAlgorithm()
elif algorithm == "decentralized":
from bagua.torch_api.algorithms import decentralized
bagua_algorithm = decentralized.DecentralizedAlgorithm(hierarchical=False)
elif algorithm == "async":
from bagua.torch_api.algorithms import async_model_average
bagua_algorithm = async_model_average.AsyncModelAverageAlgorithm(
sync_interval_ms=10,
)
elif algorithm == "low_prec_decentralized":
from bagua.torch_api.algorithms import decentralized
bagua_algorithm = decentralized.LowPrecisionDecentralizedAlgorithm(
hierarchical=False
)
elif algorithm == "qadam":
from bagua.torch_api.algorithms.q_adam import QAdamAlgorithm, QAdamOptimizer
optimizer = QAdamOptimizer(optimizer.param_groups, warmup_steps=1)
bagua_algorithm = QAdamAlgorithm(optimizer, hierarchical=False)
else:
raise ValueError("unsupported algorithm")
model = model.with_bagua([optimizer], bagua_algorithm, do_flatten=do_flatten)
return model, optimizer
def setup_bagua_env():
# init env
os.environ["WORLD_SIZE"] = "1"
os.environ["LOCAL_WORLD_SIZE"] = "1"
os.environ["MASTER_ADDR"] = "127.0.0.1"
os.environ["MASTER_PORT"] = str(find_free_port(8000, 8100))
os.environ["BAGUA_SERVICE_PORT"] = str(find_free_port(9000, 9100))
os.environ["RANK"] = "0"
os.environ["LOCAL_RANK"] = "0"
# init bagua distributed process group
torch.cuda.set_device(0)
# TODO: remove this after process group destroy supported
if not bagua.communication.is_initialized():
bagua.init_process_group()
def run(opt, flag_param, device, num_epochs):
model, optimizer = construct_model_and_optimizer(opt, flag_param, device)
train_model(model, optimizer, device, num_epochs=num_epochs)
return model.parameters()
def run_fused(opt, flag_param, device, num_epochs):
model, optimizer = construct_model_and_optimizer(opt, flag_param, device)
optimizer = bagua.contrib.fuse_optimizer(optimizer, do_flatten=True)
train_model_fused(model, optimizer, device, num_epochs=num_epochs)
return model.parameters(), optimizer._bagua_fused_count
def run_with_bagua(opt, flag_param, device, num_epochs, algorithm):
model, optimizer = construct_model_and_optimizer(opt, flag_param, device)
model, optimizer = bagua_init(model, optimizer, algorithm, do_flatten=True)
train_model(model, optimizer, device, num_epochs=num_epochs)
if algorithm == "async":
model.bagua_algorithm.abort(model)
return model.parameters()
def run_fused_with_bagua(
opt, flag_param, device, num_epochs, algorithm, optimizer_flatten, bagua_flatten
):
model, optimizer = construct_model_and_optimizer(opt, flag_param, device)
# First fuse optimizer, then wrap module
optimizer = bagua.contrib.fuse_optimizer(optimizer, do_flatten=optimizer_flatten)
model, optimizer = bagua_init(model, optimizer, algorithm, bagua_flatten)
train_model_fused(model, optimizer, device, num_epochs=num_epochs)
# torch.cuda.current_stream().synchronize()
if algorithm == "async":
model.bagua_algorithm.abort(model)
# torch.cuda.synchronize()
return model.parameters(), optimizer._bagua_fused_count
def run_fused_with_bagua_v2(
opt, flag_param, device, num_epochs, algorithm, optimizer_flatten, bagua_flatten
):
model, optimizer = construct_model_and_optimizer(opt, flag_param, device)
# First wrap module, then fuse optimizer
model, optimizer = bagua_init(model, optimizer, algorithm, bagua_flatten)
optimizer = bagua.contrib.fuse_optimizer(optimizer, do_flatten=optimizer_flatten)
train_model_fused(model, optimizer, device, num_epochs=num_epochs)
if algorithm == "async":
model.bagua_algorithm.abort(model)
return model.parameters(), optimizer._bagua_fused_count
class TestFusedOptimizer(unittest.TestCase):
def run_qadam(
self, device, num_epochs, fused_count, optimizer_flatten, bagua_flatten
):
res1 = run_with_bagua(
optim.SGD,
dict(lr=0.01),
device=device,
num_epochs=num_epochs,
algorithm="qadam",
)
res2, cnt2 = run_fused_with_bagua_v2(
optim.SGD,
dict(lr=0.01),
device=device,
num_epochs=num_epochs,
algorithm="qadam",
optimizer_flatten=optimizer_flatten,
bagua_flatten=bagua_flatten,
)
for p1, p2 in zip(res1, res2):
self.assertTrue(torch.equal(p1, p2))
self.assertTrue(cnt2 == fused_count)
def run_all_optimizers_once(self, fn1, fn2, device, num_epochs, fused_count):
optimizer_list = [
optim.SGD,
optim.SGD,
optim.Adam,
optim.Adam,
optim.Adam,
optim.Adam,
optim.AdamW,
optim.AdamW,
optim.AdamW,
optim.AdamW,
optim.RMSprop,
optim.RMSprop,
optim.RMSprop,
optim.RMSprop,
optim.Rprop,
optim.ASGD,
optim.ASGD,
optim.Adamax,
optim.Adamax,
optim.Adadelta,
optim.Adadelta,
]
flag_params = [
dict(lr=0.2, momentum=1, dampening=0, weight_decay=1, nesterov=True), # SGD
dict(
lr=0.2, momentum=1, dampening=0.5, weight_decay=1, nesterov=False
), # SGD
dict(weight_decay=1.0, amsgrad=True), # Adam
dict(weight_decay=1.0, amsgrad=False), # Adam
dict(weight_decay=0.0, amsgrad=True), # Adam
dict(weight_decay=0.0, amsgrad=False), # Adam
dict(weight_decay=1.0, amsgrad=True), # AdamW
dict(weight_decay=1.0, amsgrad=False), # AdamW
dict(weight_decay=0.0, amsgrad=True), # AdamW
dict(weight_decay=0.0, amsgrad=False), # AdamW
dict(weight_decay=1, momentum=1, centered=True), # RMSprop
dict(weight_decay=1, momentum=0, centered=True), # RMSprop
dict(weight_decay=1, momentum=1, centered=False), # RMSprop
dict(weight_decay=0, momentum=1, centered=False), # RMSprop
dict(lr=1e-2, etas=(0.5, 1.2), step_sizes=(1e-6, 50)), # Rprop
dict(weight_decay=0), # ASGD
dict(weight_decay=1), # ASGD
dict(weight_decay=0), # Adamax
dict(weight_decay=1), # Adamax
dict(weight_decay=0), # Adadelta
dict(weight_decay=1), # Adadelta
]
count = 0
for opt, flag_param in zip(optimizer_list, flag_params):
res1 = fn1(opt, flag_param, device=device, num_epochs=num_epochs)
res2, cnt2 = fn2(opt, flag_param, device=device, num_epochs=num_epochs)
for p1, p2 in zip(res1, res2):
self.assertTrue(torch.equal(p1, p2))
self.assertTrue(cnt2 == fused_count)
count += 1
if count % 5 == 0:
logging.info(f"Tests Passed [{count}/{len(optimizer_list)}]")
def run_fused_with_bagua_wrapper(self, fn1, fn2, num_epochs, fused_count):
self.run_all_optimizers_once(fn1, fn2, "cuda:0", num_epochs, fused_count)
@skip_if_cuda_available()
def test_fused_optimizer(self):
self.run_all_optimizers_once(
fn1=run, fn2=run_fused, device="cpu", num_epochs=101, fused_count=102
)
@skip_if_cuda_not_available()
def test_gradient_allreduce(self):
setup_bagua_env()
# check: optimizer param groups is flattened, should fuse
self.run_fused_with_bagua_wrapper(
fn1=run,
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "gradient_allreduce", True, False
),
num_epochs=101,
fused_count=102,
)
# check: both are falttened, should not fuse
self.run_fused_with_bagua_wrapper(
fn1=run,
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "gradient_allreduce", True, True
),
num_epochs=101,
fused_count=0,
)
# check: bagua module is falttened, should not fuse
self.run_fused_with_bagua_wrapper(
fn1=run,
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "gradient_allreduce", False, True
),
num_epochs=101,
fused_count=0,
)
@skip_if_cuda_not_available()
def test_bytegrad(self):
setup_bagua_env()
# check: optimizer param groups is flattened, should fuse
self.run_fused_with_bagua_wrapper(
fn1=lambda p1, p2, device, num_epochs: run_with_bagua(
p1, p2, device, num_epochs, "bytegrad"
),
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "bytegrad", True, False
),
num_epochs=101,
fused_count=102,
)
@skip_if_cuda_not_available()
def test_decentralized(self):
setup_bagua_env()
# check: optimizer param groups is flattened, should fuse
self.run_fused_with_bagua_wrapper(
fn1=run,
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "decentralized", True, False
),
num_epochs=101,
fused_count=102,
)
self.run_fused_with_bagua_wrapper(
fn1=run,
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "decentralized", True, True
),
num_epochs=101,
fused_count=0,
)
self.run_fused_with_bagua_wrapper(
fn1=run,
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "decentralized", False, True
),
num_epochs=101,
fused_count=0,
)
@skip_if_cuda_not_available()
def test_async(self):
return
setup_bagua_env()
self.run_fused_with_bagua_wrapper(
fn1=run,
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "async", True, False
),
num_epochs=101,
fused_count=102,
)
self.run_fused_with_bagua_wrapper(
fn1=run,
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "async", False, True
),
num_epochs=101,
fused_count=0,
)
@skip_if_cuda_not_available()
def test_low_prec_decentralized(self):
return
setup_bagua_env()
self.run_fused_with_bagua_wrapper(
fn1=lambda p1, p2, device, num_epochs: run_with_bagua(
p1, p2, device, num_epochs, "low_prec_decentralized"
),
fn2=lambda p1, p2, device, num_epochs: run_fused_with_bagua(
p1, p2, device, num_epochs, "low_prec_decentralized", True, False
),
num_epochs=101,
fused_count=102,
)
@skip_if_cuda_not_available()
def test_qadam(self):
setup_bagua_env()
self.run_qadam(
device="cuda:0",
num_epochs=101,
fused_count=102,
optimizer_flatten=True,
bagua_flatten=False,
)
@skip_if_cuda_available()
def test_calculate_mutual_groups(self):
from bagua.torch_api.contrib.fuse.optimizer import calculate_mutual_groups
tensor = torch.rand(100)
tensor_pieces = []
for i in range(10):
tensor_pieces.append(tensor[i * 10 : (i + 1) * 10])
g1 = [
tensor_pieces[3],
tensor_pieces[1],
tensor_pieces[2],
tensor_pieces[0],
tensor_pieces[8],
tensor_pieces[9],
torch.rand(10),
]
g2 = [torch.rand(10) for _ in range(len(g1))]
g3 = [
tensor_pieces[3],
tensor_pieces[1],
tensor_pieces[2],
tensor_pieces[0],
torch.rand(10),
torch.rand(10),
torch.rand(10),
]
g4 = [
torch.rand(10),
tensor_pieces[1],
tensor_pieces[2],
tensor_pieces[0],
tensor_pieces[8],
tensor_pieces[9],
torch.rand(10),
]
g5 = [
tensor_pieces[3],
tensor_pieces[1],
tensor_pieces[2],
tensor_pieces[0],
tensor_pieces[8],
tensor_pieces[9],
torch.rand(10),
]
ret = calculate_mutual_groups([g1, g2])
self.assertTrue(ret == [])
ret = calculate_mutual_groups([g1, g3])
self.assertTrue(ret == [[3, 1, 2, 0]])
ret = calculate_mutual_groups([g1, g4])
self.assertTrue(ret == [[4, 5]])
ret = calculate_mutual_groups([g1, g5])
self.assertTrue(ret == [[3, 1, 2, 0], [4, 5]])
if __name__ == "__main__":
unittest.main()
|
437480
|
import unittest
from asq.queryables import Queryable
from asq.test.test_queryable import TracingGenerator, infinite
__author__ = "<NAME>"
class TestTakeWhile(unittest.TestCase):
def test_take_while(self):
a = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
b = Queryable(a).take_while(lambda x: x < 'e').to_list()
c = ['a', 'b', 'c', 'd']
self.assertEqual(b, c)
def test_take_while_from_infinite(self):
b = Queryable(infinite()).take_while(lambda x: x < 5).to_list()
c = [0, 1, 2, 3, 4]
self.assertEqual(b, c)
def test_take_while_not_callable(self):
a = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
self.assertRaises(TypeError, lambda: Queryable(a).take_while("not callable"))
def test_take_while_is_deferred(self):
a = TracingGenerator()
self.assertEqual(a.trace, [])
b = Queryable(a).take_while(lambda x: x < 3)
self.assertEqual(a.trace, [])
c = b.to_list()
# 3 is included here in the trace because it must have been consumed in order to test
# whether it satisfies the predicate
self.assertEqual(a.trace, [0, 1, 2, 3])
def test_take_while_closed(self):
a = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
b = Queryable(a)
b.close()
self.assertRaises(ValueError, lambda: b.take_while(lambda x: x < 'e'))
|
437524
|
import os
import tensorflow as tf
from badgr.file_manager import FileManager
from badgr.datasets.tfrecord_rebalance_dataset import TfrecordRebalanceDataset
from badgr.jackal.envs.jackal_env_specs import JackalPositionCollisionEnvSpec
from badgr.jackal.models.jackal_position_model import JackalPositionModel
from badgr.utils.python_utils import AttrDict as d
###############
### Dataset ###
###############
def get_dataset_params(env_spec, horizon, batch_size):
all_tfrecord_folders = [
os.path.join(FileManager.data_dir, 'tfrecords_collision/{0}-2019_horizon_{1}'.format(f, horizon)) for f in
['08-02', '08-06', '08-08', '08-13', '08-15', '08-18', '08-20', '08-27', '08-29', '09-09', '09-12', '09-17',
'09-19', '10-20', '10-24', '10-31']
]
train_tfrecord_folders = [fname for fname in all_tfrecord_folders if '09-12' not in fname],
holdout_tfrecord_folders = [fname for fname in all_tfrecord_folders if '09-12' in fname],
kwargs_train = d(
rebalance_key='outputs/collision/close',
env_spec=env_spec,
tfrecord_folders=train_tfrecord_folders,
horizon=horizon,
batch_size=batch_size,
num_parallel_calls=6,
shuffle_buffer_size=1000,
prefetch_buffer_size_multiplier=10,
)
kwargs_holdout = kwargs_train.copy()
kwargs_holdout.tfrecord_folders = holdout_tfrecord_folders
return d(
cls=TfrecordRebalanceDataset,
kwargs_train=kwargs_train,
kwargs_holdout=kwargs_holdout
)
#############
### Model ###
#############
def get_model_params(env_spec, horizon):
kwargs_train = d(
# jackal mode
use_both_images=False,
# RNN
horizon=horizon,
rnn_dim=64,
# inputs/outputs
env_spec=env_spec,
output_observations=[
d(
name='jackal/position',
is_relative=True
),
d(
name='collision/close',
is_relative=False
)
],
is_output_gps=False,
)
kwargs_eval = kwargs_train.copy()
kwargs_eval.is_output_gps = True
return d(
cls=JackalPositionModel,
kwargs_train=kwargs_train,
kwargs_eval=kwargs_eval
)
################
### Training ###
################
def get_trainer_params():
def cost_fn(model_outputs, outputs):
batch_size = tf.shape(outputs.done)[0]
batch_size_float = tf.cast(batch_size, tf.float32)
done = tf.concat([tf.zeros([batch_size, 1], dtype=tf.bool), outputs.done[:, :-1]], axis=1)
mask = tf.cast(tf.logical_not(done), tf.float32)
tf.debugging.assert_positive(tf.reduce_sum(mask, axis=1))
mask = batch_size_float * (mask / tf.reduce_sum(mask))
mask = mask[..., tf.newaxis]
### position
cost_position = tf.reduce_sum(
mask * 0.5 * tf.square(model_outputs.jackal.position - outputs.jackal.position),
axis=(1, 2)
)
### collision
model_output_collision = model_outputs.collision.close[..., 0]
collision = tf.cast(outputs.collision.close, tf.bool)[..., 0]
collision = tf.logical_and(collision, tf.logical_not(done)) # don't count collisions after done!
collision = tf.cumsum(tf.cast(collision, tf.float32), axis=-1) > 0.5
# collision mask should be same as normal mask, but turned on for dones with collision = true
mask_collision = tf.cast(tf.logical_or(tf.logical_not(done), collision), tf.float32)
mask_collision = batch_size_float * (mask_collision / tf.reduce_sum(mask_collision))
cost_collision = 2.0 * tf.reduce_sum(
mask_collision * tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.cast(collision, tf.float32),
logits=model_output_collision),
axis=1
)
collision_accuracy = tf.reduce_mean(tf.cast(tf.equal(model_output_collision > 0,
tf.cast(collision, tf.bool)),
tf.float32),
axis=1)
collision_accuracy_random = tf.reduce_mean(1. - tf.cast(collision, tf.float32), axis=1)
### regularization
cost_l2_reg = 1e-2 * \
tf.reduce_mean([0.5 * tf.reduce_mean(kernel * kernel) for kernel in model_outputs.kernels]) * \
tf.ones(batch_size)
### filter out nans
costs_is_finite = tf.logical_and(tf.is_finite(cost_position), tf.is_finite(cost_collision))
cost_position = tf.boolean_mask(cost_position, costs_is_finite)
cost_collision = tf.boolean_mask(cost_collision, costs_is_finite)
cost_l2_reg = tf.boolean_mask(cost_l2_reg, costs_is_finite)
# assert cost_l2_reg.shape[0].value > 0.5 * batch_size
### total
cost = cost_position + cost_collision + cost_l2_reg
return d(
total=cost,
position=cost_position,
collision=cost_collision,
collision_accuracy=collision_accuracy,
collision_accuracy_random=collision_accuracy_random,
l2_reg=cost_l2_reg
)
return d(
# steps
max_steps=2e5,
holdout_every_n_steps=50,
log_every_n_steps=1e3,
save_every_n_steps=1e4,
# dataset
batch_size=32,
# optimizer
cost_fn=cost_fn,
optimizer_cls=tf.train.AdamOptimizer,
learning_rate=1e-4,
)
##################
### Get params ###
##################
def get_params():
horizon = 8
env_spec = JackalPositionCollisionEnvSpec(left_image_only=True)
model_params = get_model_params(env_spec, horizon)
trainer_params = get_trainer_params()
dataset_params = get_dataset_params(env_spec, horizon, trainer_params.batch_size)
return d(
exp_name='collision_position',
dataset=dataset_params,
model=model_params,
trainer=trainer_params,
)
params = get_params()
|
437525
|
import logging
import os.path as op
from functools import partial
from itertools import chain
import sublime
import sublime_plugin
import flower
from . import manager
from .utils import rootSplit, getBinaryFolder
from .compilerutils import getCompiler, COMPILER_KEY
from .process import Executor, Callback, Default
from .config import inlineIncludes
from ..env import expandEnv, expandPath
from ..pathutils import getExt, getFileName, getName
log = logging.getLogger(flower.NAME)
def snake_to_camel(s, sep=' '):
return '{}'.format(sep).join(map(str.capitalize, s.split('_')))
def option_keys(workdir, workpath, binaryfolder_):
name, pathname = op.basename(workpath), op.join(workdir, workpath)
binaryfolder = expandPath(binaryfolder_ or flower.ENV.get('binaryfolder'))
return Default(
name=name,
pathname=pathname,
workpath=workpath,
binaryfolder=getBinaryFolder(binaryfolder, workdir),
)
def meta_values(workdir):
"""Application is meta-app if we have root/(www2,flow.config,app)/app.flow"""
www2 = op.join(workdir, 'www2')
if op.exists(www2):
root = op.basename(workdir)
url = "http://${{localhost}}/{root}/flowjs.html?name={{name}}{{args}}".format(root=root)
log.info("Meta app overrides")
log.debug("binaryfolder: %s", www2)
log.debug("url: %s", url)
return www2, url
return None, None
class RunFlow(sublime_plugin.TextCommand):
"""Interactive main menu (F8)"""
@staticmethod
def selectPreset(action=None, runner=None):
"""Select preset from menu and run action/runner, or select runner"""
ext = runner and runner.ext
presets = manager.getPresets(ext)
onPreset = partial(RunFlow.get_run, action=action, runner=runner)
if len(presets) == 1:
onPreset(presets[0])
else:
items = [preset.toStr() for preset in presets]
onDone = lambda i: i > -1 and onPreset(presets[i])
sublime.active_window().show_quick_panel(items, onDone)
@staticmethod
def selectRunner(preset):
"""Select action/runner from menu for predefined preset"""
if not preset:
log.error("Can't select runner without preset")
return
ext = getExt(preset.main)
actions = manager.getActions(ext)
if not actions:
log.error("No actions available for `%s` file", ext)
return
# compiler makes sense for .flow
compiler = getCompiler(preset.main, key=COMPILER_KEY)
runners = manager.getRunners(ext)
wrap = lambda runner: partial(RunFlow.runCommand, preset, runner)
action_pairs = ((snake_to_camel(a), wrap(getattr(compiler, a)())) for a in actions)
runner_pairs = ((r.toStr()[0], wrap(r)) for r in runners)
view = sublime.active_window().active_view()
open_config = lambda: view.run_command("flower_open_config", {
"configpath": compiler.configpath
})
misc_pairs = filter(lambda x: x[0], [
(compiler.configpath and 'Configure {}'.format(compiler), open_config),
])
names, commands = zip(*(chain(action_pairs, runner_pairs, misc_pairs)))
onDone = lambda i: i > -1 and commands[i]()
sublime.active_window().show_quick_panel(names, onDone)
@staticmethod
def execAction(preset, action, key=COMPILER_KEY, format_keys=None, after_args=()):
runner, compiler = manager.actionToRunner(action, preset, key)
RunFlow.execRun(preset, runner, compiler, format_keys, after_args)
@staticmethod
def execRun(preset, runner, compiler, format_keys=None, after_args=()):
"""Prepare all necessary bits for executing a command & go for it"""
main = preset.main
workdir, name = rootSplit(main)
compiler = compiler or getCompiler(main)
# regular includes retrieved from config, add inline ones
includes = compiler.formatIncludes__(inlineIncludes(main))
meta_binaryfolder, meta_url = meta_values(workdir)
binaryfolder, url = preset.binaryfolder or meta_binaryfolder, preset.url or meta_url
format_keys = format_keys or dict()
# can't ChainMap Default-dict, so update
format_keys.update(option_keys(workdir, getName(name), binaryfolder))
expand_options = lambda option: option.format(**format_keys)
cmd = expandEnv(*chain(
runner.cmd,
map(expand_options, runner.options),
includes,
[name],
))
afterArgs = {
"cpp": (workdir, getName(name), preset.args),
"gdb": (workdir, name, preset.args),
"web": (url, getFileName(name), preset.args),
"find": (compiler.defn_regex,),
}.get(runner.after, ()) + after_args
Executor.run(
cmd=cmd,
workdir=workdir,
after=Callback(runner.after, afterArgs),
quiet=True
)
@staticmethod
def runCommand(preset, runner, compiler=None):
"""Run specified preset with runner"""
if not (preset and runner):
return
view = sublime.active_window().active_view()
if view.is_dirty():
view.run_command('save')
manager.setRun(preset, runner)
RunFlow.execRun(preset, runner, compiler)
@staticmethod
def get_preset(preset):
""" preset: None = select, 'invalid' = current """
if isinstance(preset, (type(None), manager.Preset)):
return preset
presets = tuple(filter(lambda p: p.key == preset.lower(), manager.getPresets()))
if presets:
got_preset = presets[0]
log.debug("Preset: %s", got_preset)
else:
got_preset = manager.currentFilePreset()
if preset:
log.warning("Preset `%s` is not specified", preset)
return got_preset
@staticmethod
def get_runner(runner, preset):
if isinstance(runner, (type(None), manager.Runner)):
return runner
ext = preset and getExt(preset.main)
runners = tuple(filter(lambda r: r.key == runner.lower(), manager.getRunners(ext)))
if runners:
got_runner = runners[0]
log.debug("Runner: %s", got_runner)
else:
got_runner = None
log.error("Runner `%s` is not specified", runner)
return got_runner
@staticmethod
def get_run(preset=None, action=None, runner=None):
got_preset = RunFlow.get_preset(preset)
got_runner = RunFlow.get_runner(runner, got_preset)
# nothing provided - select preset first
if got_preset is None:
RunFlow.selectPreset(action, got_runner)
# action provided
elif action is not None:
runner_, compiler_ = manager.actionToRunner(action, got_preset)
RunFlow.runCommand(got_preset, runner_, compiler_)
# preset provided
elif got_runner is None:
RunFlow.selectRunner(got_preset)
# preset & runner provided
else:
RunFlow.runCommand(got_preset, got_runner)
def run(self, edit, preset=None, action=None, runner=None):
return self.get_run(preset, action, runner)
|
437558
|
import inspect
from functools import wraps
def doublewrap(f):
'''
a decorator decorator, allowing the decorator to be used as:
@decorator(with, arguments, and=kwds)
or
@decorator
'''
@wraps(f)
def new_dec(*args, **kwds):
if len(args) == 1 and len(kwds) == 0 and callable(args[0]):
# actual decorated function
return f(args[0])
else:
# decorator arguments
return lambda realf: f(realf, *args, **kwds)
return new_dec
def perpetum(func, *args, **kwds):
while True:
yield func(*args, **kwds)
def is_standard_func(func):
return not (inspect.iscoroutinefunction(func) or inspect.isgeneratorfunction(func)
or is_async_gen(func))
def is_async_gen(func):
return bool(func.__code__.co_flags & inspect.CO_ASYNC_GENERATOR)
def get_function_context_dict(func):
if func.__closure__ is None:
return func.__globals__
context = {}
context.update(func.__globals__)
for name, cell in zip(func.__code__.co_freevars, func.__closure__):
try:
context[name] = cell.cell_contents
except ValueError:
# Cell is empty
pass
return context
|
437633
|
from setuptools import setup
from pipenv.project import Project
from pipenv.utils import convert_deps_to_pip
def get_packages_from_Pipfile():
pipfile = Project(chdir=False).parsed_pipfile
return convert_deps_to_pip(pipfile['packages'], r=False)
setup(install_requires=get_packages_from_Pipfile())
|
437658
|
import os
from collections import defaultdict, Counter
from pathlib import Path
import csv
from NewsSentiment.fxlogger import get_logger
from NewsSentiment.diskdict import DiskDict
EMOTION2INDEX = {
"anger": 0,
"anticipation": 1,
"disgust": 2,
"fear": 3,
"joy": 4,
"negative": 5,
"positive": 6,
"sadness": 7,
"surprise": 8,
"trust": 9,
}
THIS_DIR = Path(os.path.dirname(os.path.realpath(__file__)))
PATH_DICT_NRC_EMOLEX = THIS_DIR / "NRC-Emotion-Lexicon-Wordlevel-v0.92.txt.ddict"
logger = get_logger()
def convert_txt_to_dict():
path_dict = THIS_DIR / "NRC-Emotion-Lexicon-Wordlevel-v0.92.txt"
term2emotions = defaultdict(set)
emotion_counter = Counter()
with open(path_dict, "r") as csv_file:
csv_reader = csv.reader(csv_file, delimiter="\t")
for term, emotion, is_present in csv_reader:
if is_present == "1":
emotion_index = EMOTION2INDEX[emotion]
term2emotions[term].add(emotion_index)
emotion_counter[emotion] += 1
elif is_present == "0":
pass
else:
raise ValueError
logger.info("read %s terms", len(term2emotions))
logger.info("emotion count:\n%s", emotion_counter.most_common())
logger.info("saving to %s...", None)
ddict_emolex = DiskDict(PATH_DICT_NRC_EMOLEX)
ddict_emolex.update(term2emotions)
ddict_emolex.sync_to_disk()
logger.info("done")
if __name__ == "__main__":
convert_txt_to_dict()
|
437688
|
from __future__ import annotations
import typing
from ctc import binary
from ctc import rpc
from ctc import spec
from ctc.toolbox import backend_utils
from .event_backends import filesystem_events
from .event_backends import node_events
from .. import block_utils
from .. import abi_utils
def is_event_hash(data: spec.BinaryData) -> bool:
try:
binary.convert(data, 'binary')
return len(binary) == 32
except Exception:
return False
def get_event_backend_functions() -> dict[
str,
dict[
str,
typing.Callable[
..., typing.Coroutine[typing.Any, typing.Any, spec.DataFrame]
],
],
]:
return {
'get': {
'filesystem': filesystem_events.async_get_events_from_filesystem,
'download': async_download_events,
'node': node_events.async_get_events_from_node,
},
'save': {
'filesystem': filesystem_events.async_save_events_to_filesystem,
},
}
async def async_get_events(
*,
contract_address: spec.Address,
start_block: spec.BlockNumberReference | None = None,
end_block: spec.BlockNumberReference | None = None,
backend_order: typing.Sequence[str] | None = None,
keep_multiindex: bool = True,
**query: typing.Any,
) -> spec.DataFrame:
if start_block is None:
start_block = await block_utils.async_get_contract_creation_block(
contract_address
)
start_block = await block_utils.async_block_number_to_int(start_block)
if end_block is None:
end_block = 'latest'
start_block, end_block = await block_utils.async_block_numbers_to_int(
blocks=[start_block, end_block],
)
if backend_order is None:
backend_order = ['filesystem', 'download']
events = await backend_utils.async_run_on_backend(
get_event_backend_functions()['get'],
contract_address=contract_address,
start_block=start_block,
end_block=end_block,
backend_order=backend_order,
**query,
)
if not keep_multiindex:
from ctc.toolbox import pd_utils
events.index = pd_utils.keep_level(
index=events.index, level='block_number'
)
return events
async def async_save_events(
events: spec.DataFrame, **query: typing.Any
) -> spec.DataFrame:
return await backend_utils.async_run_on_backend(
get_event_backend_functions()['save'], events=events, **query
)
async def async_transfer_events(
*,
contract_address: spec.Address,
start_block: spec.BlockNumberReference | None = None,
end_block: spec.BlockNumberReference | None = None,
**query: typing.Any,
) -> spec.DataFrame:
if start_block is not None and end_block is not None:
start_block, end_block = await block_utils.async_block_numbers_to_int(
blocks=[start_block, end_block],
)
elif start_block is not None:
start_block = await block_utils.async_block_number_to_int(start_block)
elif end_block is not None:
end_block = await block_utils.async_block_number_to_int(end_block)
return await backend_utils.async_transfer_backends(
get=async_get_events,
save=async_save_events,
contract_address=contract_address,
start_block=start_block,
end_block=end_block,
**query,
)
async def async_download_events(
contract_address: spec.Address,
event_hash: str | None = None,
event_name: str | None = None,
event_abi: spec.EventABI | None = None,
start_block: spec.BlockNumberReference | None = None,
end_block: spec.BlockNumberReference | None = None,
provider: spec.ProviderSpec = None,
verbose: bool = True,
) -> spec.DataFrame:
if event_hash is None and event_name is None and event_abi is None:
raise Exception('must specify either event_hash or event_name')
contract_address = contract_address.lower()
if start_block is not None and end_block is not None:
start_block, end_block = await block_utils.async_block_numbers_to_int(
blocks=[start_block, end_block],
)
elif start_block is not None:
start_block = await block_utils.async_block_number_to_int(start_block)
elif end_block is not None:
end_block = await block_utils.async_block_number_to_int(end_block)
provider = rpc.get_provider(provider)
network = provider['network']
if network is None:
raise Exception('could not determine network')
# get event hash
if event_hash is None:
if event_abi is None:
if event_name is None:
raise Exception('must specify more event information')
event_abi = await abi_utils.async_get_event_abi(
contract_address=contract_address,
event_name=event_name,
network=network,
)
event_hash = binary.get_event_hash(event_abi)
# determine what needs to be downloaded
listed_events = filesystem_events.list_events(
contract_address=contract_address,
event_hash=event_hash,
)
downloads: list[typing.Mapping[str, typing.Any]] = []
if listed_events is None:
download: typing.Mapping[str, typing.Any] = {
'start_block': start_block,
'end_block': end_block,
}
downloads.append(download)
else:
block_range = listed_events['block_range']
if start_block < block_range[0]:
download = {
'start_block': start_block,
'end_block': block_range[0] - 1,
'common_kwargs': {'verbose': verbose},
}
downloads.append(download)
if end_block > block_range[-1]:
download = {
'start_block': block_range[-1] + 1,
'end_block': end_block,
'common_kwargs': {'verbose': verbose},
}
downloads.append(download)
# perform downloads
for download in downloads:
await async_transfer_events(
from_backend='node',
to_backend='filesystem',
event_hash=event_hash,
event_abi=event_abi,
contract_address=contract_address,
provider=provider,
**download,
)
# load from filesystem
return await filesystem_events.async_get_events_from_filesystem(
event_hash=event_hash,
event_abi=event_abi,
contract_address=contract_address,
start_block=start_block,
end_block=end_block,
verbose=verbose,
provider=provider,
)
|
437692
|
class Solution:
def minEatingSpeed(self, piles: List[int], h: int) -> int:
def isok(k):
count = 0
for p in piles:
count += (p - 1) // k + 1
return count <= h
l = 1
r = max(piles)
while l < r:
mid = (l + r)//2
if isok(mid):
r = mid
else:
l = mid + 1
return l
class Solution:
def minEatingSpeed(self, piles: List[int], h: int) -> int:
l, r = 1, max(piles)
while l < r:
m = (l + r) // 2
if sum((p + m - 1) // m for p in piles) > h:
l = m + 1
else:
r = m
return l
class Solution:
def minEatingSpeed(self, piles: List[int], h: int) -> int:
def isok(k):
count = 0
for p in piles:
if p <= k:
count += 1
else:
count += p // k + (1 if p % k != 0 else 0)
return count <= h
l = 1
r = max(piles)
while l < r:
mid = (l + r)//2
if isok(mid):
r = mid
else:
l = mid + 1
return l
|
437787
|
import pytest
import capnpy
from capnpy.testing.compiler.support import CompilerTest
class TestConst(CompilerTest):
def test_global_const(self):
schema = """
@0xbf5147cbbecf40c1;
const bar :UInt16 = 42;
const baz :Text = "baz";
"""
mod = self.compile(schema)
assert mod.bar == 42
assert mod.baz == b'baz'
def test_const_primitive(self):
schema = """
@0xbf5147cbbecf40c1;
struct Foo {
const bar :UInt16 = 42;
const baz :Text = "baz";
}
"""
mod = self.compile(schema)
assert mod.Foo.bar == 42
assert mod.Foo.baz == b'baz'
def test_struct(self):
schema = """
@0xbf5147cbbecf40c1;
struct Person {
name @0 :Text;
email @1 :Text;
}
const bob :Person = (name = "Bob", email = "<EMAIL>");
"""
mod = self.compile(schema)
assert mod.bob.name == b'Bob'
assert mod.bob.email == b'<EMAIL>'
#
# check that reflection data and constants share the same segment
reflection = capnpy.get_reflection_data(mod)
assert reflection.request._seg is mod.bob._seg
def test_list(self):
schema = """
@0xbf5147cbbecf40c1;
const int64List :List(Int64) = [1, 2, 3, 4];
const textList :List(Text) = ["hello", "world"];
"""
mod = self.compile(schema)
assert mod.int64List == [1, 2, 3, 4]
assert mod.textList == [b'hello', b'world']
def test_struct_no_reflection(self):
schema = """
@0xbf5147cbbecf40c1;
struct Person {
name @0 :Text;
email @1 :Text;
}
const bob :Person = (name = "Bob", email = "<EMAIL>");
"""
# check that we can emit the const even if we don't have the
# reflection data
mod = self.compile(schema, include_reflection_data=False)
assert mod.bob.name == b'Bob'
assert mod.bob.email == b'<EMAIL>'
|
437809
|
from .linear_regression import (
LinearRegressionGD,
LassoRegressionGD,
RidgeRegressionGD,
ElasticNetRegressionGD,
PolynomialRegressionGD,
)
|
437814
|
from dependency_injector import containers, providers
from server import db_dir
from tarkov.quests.repositories import QuestsRepository
class QuestsContainer(containers.DeclarativeContainer):
repository: providers.Provider[QuestsRepository] = providers.Singleton(
QuestsRepository, quests_path=db_dir.joinpath("quests", "all.json")
)
|
437874
|
import FWCore.ParameterSet.Config as cms
gmttree = cms.EDAnalyzer("L1MuGMTTree",
GeneratorInputTag = cms.InputTag("none"),
SimulationInputTag = cms.InputTag("none"),
GTInputTag = cms.InputTag("none"),
GTEvmInputTag = cms.InputTag("none"),
GMTInputTag = cms.InputTag("l1GmtEmulDigis"),
PhysVal = cms.bool(True),
OutputFile = cms.untracked.string('gmttree.root')
)
|
437956
|
import os
import cv2
import json
import math
import numpy as np
import torch
import torch.utils.data as data
import pycocotools.coco as coco
from pycocotools.cocoeval import COCOeval
from utils.image import get_border, get_affine_transform, affine_transform, color_aug
from utils.image import draw_umich_gaussian, gaussian_radius
COCO_NAMES = ['__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',
'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',
'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',
'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis',
'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',
'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass',
'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',
'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',
'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
'scissors', 'teddy bear', 'hair drier', 'toothbrush']
COCO_IDS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13,
14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 27, 28, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 67, 70,
72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
82, 84, 85, 86, 87, 88, 89, 90]
COCO_MEAN = [0.40789654, 0.44719302, 0.47026115]
COCO_STD = [0.28863828, 0.27408164, 0.27809835]
COCO_EIGEN_VALUES = [0.2141788, 0.01817699, 0.00341571]
COCO_EIGEN_VECTORS = [[-0.58752847, -0.69563484, 0.41340352],
[-0.5832747, 0.00994535, -0.81221408],
[-0.56089297, 0.71832671, 0.41158938]]
class COCO(data.Dataset):
def __init__(self, data_dir, split, split_ratio=1.0, img_size=512):
super(COCO, self).__init__()
self.num_classes = 80
self.class_name = COCO_NAMES
self.valid_ids = COCO_IDS
self.cat_ids = {v: i for i, v in enumerate(self.valid_ids)}
self.data_rng = np.random.RandomState(123)
self.eig_val = np.array(COCO_EIGEN_VALUES, dtype=np.float32)
self.eig_vec = np.array(COCO_EIGEN_VECTORS, dtype=np.float32)
self.mean = np.array(COCO_MEAN, dtype=np.float32)[None, None, :]
self.std = np.array(COCO_STD, dtype=np.float32)[None, None, :]
self.split = split
self.data_dir = os.path.join(data_dir, 'coco')
self.img_dir = os.path.join(self.data_dir, '%s2017' % split)
if split == 'test':
self.annot_path = os.path.join(
self.data_dir, 'annotations', 'image_info_test-dev2017.json')
else:
self.annot_path = os.path.join(
self.data_dir, 'annotations', 'instances_%s2017.json' % split)
self.max_objs = 128
self.padding = 127 # 31 for resnet/resdcn
self.down_ratio = 4
self.img_size = {'h': img_size, 'w': img_size}
self.fmap_size = {'h': img_size // self.down_ratio,
'w': img_size // self.down_ratio}
self.rand_scales = np.arange(0.6, 1.4, 0.1)
self.gaussian_iou = 0.7
print('==> initializing coco 2017 %s data.' % split)
self.coco = coco.COCO(self.annot_path)
self.images = self.coco.getImgIds()
if 0 < split_ratio < 1:
split_size = int(
np.clip(split_ratio * len(self.images), 1, len(self.images)))
self.images = self.images[:split_size]
self.num_samples = len(self.images)
print('Loaded %d %s samples' % (self.num_samples, split))
def __getitem__(self, index):
img_id = self.images[index]
img_path = os.path.join(
self.img_dir, self.coco.loadImgs(ids=[img_id])[0]['file_name'])
ann_ids = self.coco.getAnnIds(imgIds=[img_id])
annotations = self.coco.loadAnns(ids=ann_ids)
labels = np.array([self.cat_ids[anno['category_id']]
for anno in annotations])
bboxes = np.array([anno['bbox']
for anno in annotations], dtype=np.float32)
if len(bboxes) == 0:
bboxes = np.array([[0., 0., 0., 0.]], dtype=np.float32)
labels = np.array([[0]])
bboxes[:, 2:] += bboxes[:, :2] # xywh to xyxy
img = cv2.imread(img_path)
height, width = img.shape[0], img.shape[1]
center = np.array([width / 2., height / 2.],
dtype=np.float32) # center of image
scale = max(height, width) * 1.0
flipped = False
if self.split == 'train':
scale = scale * np.random.choice(self.rand_scales)
w_border = get_border(128, width)
h_border = get_border(128, height)
center[0] = np.random.randint(low=w_border, high=width - w_border)
center[1] = np.random.randint(low=h_border, high=height - h_border)
if np.random.random() < 0.5:
flipped = True
img = img[:, ::-1, :]
center[0] = width - center[0] - 1
trans_img = get_affine_transform(
center, scale, 0, [self.img_size['w'], self.img_size['h']])
img = cv2.warpAffine(
img, trans_img, (self.img_size['w'], self.img_size['h']))
# -----------------------------------debug---------------------------------
# for bbox, label in zip(bboxes, labels):
# if flipped:
# bbox[[0, 2]] = width - bbox[[2, 0]] - 1
# bbox[:2] = affine_transform(bbox[:2], trans_img)
# bbox[2:] = affine_transform(bbox[2:], trans_img)
# bbox[[0, 2]] = np.clip(bbox[[0, 2]], 0, self.img_size['w'] - 1)
# bbox[[1, 3]] = np.clip(bbox[[1, 3]], 0, self.img_size['h'] - 1)
# cv2.rectangle(img, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (255, 0, 0), 2)
# cv2.putText(img, self.class_name[label + 1], (int(bbox[0]), int(bbox[1])),
# cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
# cv2.imshow('img', img)
# cv2.waitKey()
# -----------------------------------debug---------------------------------
img = img.astype(np.float32) / 255.
if self.split == 'train':
color_aug(self.data_rng, img, self.eig_val, self.eig_vec)
img -= self.mean
img /= self.std
img = img.transpose(2, 0, 1) # from [H, W, C] to [C, H, W]
trans_fmap = get_affine_transform(
center, scale, 0, [self.fmap_size['w'], self.fmap_size['h']])
hmap = np.zeros(
(self.num_classes, self.fmap_size['h'], self.fmap_size['w']), dtype=np.float32) # heatmap
# width and height
w_h_ = np.zeros((self.max_objs, 2), dtype=np.float32)
regs = np.zeros((self.max_objs, 2), dtype=np.float32) # regression
inds = np.zeros((self.max_objs,), dtype=np.int64)
ind_masks = np.zeros((self.max_objs,), dtype=np.uint8)
# detections = []
for k, (bbox, label) in enumerate(zip(bboxes, labels)):
if flipped:
bbox[[0, 2]] = width - bbox[[2, 0]] - 1
bbox[:2] = affine_transform(bbox[:2], trans_fmap)
bbox[2:] = affine_transform(bbox[2:], trans_fmap)
bbox[[0, 2]] = np.clip(bbox[[0, 2]], 0, self.fmap_size['w'] - 1)
bbox[[1, 3]] = np.clip(bbox[[1, 3]], 0, self.fmap_size['h'] - 1)
h, w = bbox[3] - bbox[1], bbox[2] - bbox[0]
if h > 0 and w > 0:
obj_c = np.array(
[(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2], dtype=np.float32)
obj_c_int = obj_c.astype(np.int32)
radius = max(0, int(gaussian_radius(
(math.ceil(h), math.ceil(w)), self.gaussian_iou)))
draw_umich_gaussian(hmap[label], obj_c_int, radius)
w_h_[k] = 1. * w, 1. * h
regs[k] = obj_c - obj_c_int # discretization error
inds[k] = obj_c_int[1] * self.fmap_size['w'] + obj_c_int[0]
ind_masks[k] = 1
# groundtruth bounding box coordinate with class
# detections.append([obj_c[0] - w / 2, obj_c[1] - h / 2,
# obj_c[0] + w / 2, obj_c[1] + h / 2, 1, label])
# detections = np.array(detections, dtype=np.float32) \
# if len(detections) > 0 else np.zeros((1, 6), dtype=np.float32)
return {'image': img,
'hmap': hmap, 'w_h_': w_h_, 'regs': regs, 'inds': inds, 'ind_masks': ind_masks,
'c': center, 's': scale, 'img_id': img_id}
def __len__(self):
return self.num_samples
class COCO_eval(COCO):
def __init__(self, data_dir, split, test_scales=(1,), test_flip=False, fix_size=False):
super(COCO_eval, self).__init__(data_dir, split)
self.test_flip = test_flip
self.test_scales = test_scales
self.fix_size = fix_size
def __getitem__(self, index):
img_id = self.images[index]
img_path = os.path.join(
self.img_dir, self.coco.loadImgs(ids=[img_id])[0]['file_name'])
image = cv2.imread(img_path)
height, width = image.shape[0:2]
out = {}
for scale in self.test_scales:
new_height = int(height * scale)
new_width = int(width * scale)
if self.fix_size:
img_height, img_width = self.img_size['h'], self.img_size['w']
center = np.array(
[new_width / 2., new_height / 2.], dtype=np.float32)
scaled_size = max(height, width) * 1.0
scaled_size = np.array(
[scaled_size, scaled_size], dtype=np.float32)
else:
img_height = (new_height | self.padding) + 1
img_width = (new_width | self.padding) + 1
center = np.array(
[new_width // 2, new_height // 2], dtype=np.float32)
scaled_size = np.array(
[img_width, img_height], dtype=np.float32)
img = cv2.resize(image, (new_width, new_height))
trans_img = get_affine_transform(
center, scaled_size, 0, [img_width, img_height])
img = cv2.warpAffine(img, trans_img, (img_width, img_height))
img = img.astype(np.float32) / 255.
img -= self.mean
img /= self.std
# from [H, W, C] to [1, C, H, W]
img = img.transpose(2, 0, 1)[None, :, :, :]
if self.test_flip:
img = np.concatenate((img, img[:, :, :, ::-1].copy()), axis=0)
out[scale] = {'image': img,
'center': center,
'scale': scaled_size,
'fmap_h': img_height // self.down_ratio,
'fmap_w': img_width // self.down_ratio}
return img_id, out
def convert_eval_format(self, all_bboxes):
# all_bboxes: num_samples x num_classes x 5
detections = []
for image_id in all_bboxes:
for cls_ind in all_bboxes[image_id]:
category_id = self.valid_ids[cls_ind - 1]
for bbox in all_bboxes[image_id][cls_ind]:
bbox[2] -= bbox[0]
bbox[3] -= bbox[1]
score = bbox[4]
bbox_out = list(
map(lambda x: float("{:.2f}".format(x)), bbox[0:4]))
detection = {"image_id": int(image_id),
"category_id": int(category_id),
"bbox": bbox_out,
"score": float("{:.2f}".format(score))}
detections.append(detection)
return detections
def run_eval(self, results, save_dir=None):
print("+"*30)
detections = self.convert_eval_format(results)
if save_dir is not None:
result_json = os.path.join(save_dir, "results.json")
json.dump(detections, open(result_json, "w"))
coco_dets = self.coco.loadRes(detections)
coco_eval = COCOeval(self.coco, coco_dets, "bbox")
coco_eval.evaluate()
coco_eval.accumulate()
coco_eval.summarize()
print("recall", coco_eval.eval['recall'])
return coco_eval.stats
@staticmethod
def collate_fn(batch):
out = []
for img_id, sample in batch:
out.append((img_id, {s: {k: torch.from_numpy(sample[s][k]).float()
if k == 'image' else np.array(sample[s][k]) for k in sample[s]} for s in sample}))
return out
if __name__ == '__main__':
from tqdm import tqdm
import pickle
dataset = COCO('E:\\coco_debug', 'train')
for d in dataset:
b1 = d
# pass
pass
# train_loader = torch.utils.data.DataLoader(dataset, batch_size=2,
# shuffle=False, num_workers=0,
# pin_memory=True, drop_last=True)
#
# for b in tqdm(train_loader):
# pass
|
437976
|
import serial
import time
import datetime
import math
import numpy as np
#import math
import matplotlib.pyplot as plt
class Embo(object):
TIMEOUT_CMD = 0.1
TIMEOUT_READ = 2.0
VM_MAX_LEN = 200
READY_STR = "Ready"
NOT_READY_STR = "Not ready"
def __init__(self):
if __name__ == '__main__':
com = self.input2("Select COM port:", "COM16")
self.ser = serial.Serial(com, 115200, timeout=0,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS)
self.ser.flush()
self.receive(self.TIMEOUT_CMD)
rx = self.send_cmd("*IDN?", self.TIMEOUT_CMD)
print(rx)
if (rx == ""):
print("Device not connected!")
return False
rx = self.send_cmd("*RST", self.TIMEOUT_CMD)
print(rx)
if (rx == ""):
print("Device not connected!")
return False
self.limits()
if self.input2("\nWant to setup PWM? (n, y)", "n") == "y":
self.pwm()
if not self.choose_mode():
return
self.it = 0
self.vm_data = []
self.vm_data.extend(([], [], [], [], []))
self.tm_last = datetime.datetime.now()
self.loop()
def choose_mode(self):
while True:
self.mode = self.input2("\nChoose mode (SCOPE, VM, LA, CNTR):", "SCOPE")
if self.mode == "CNTR":
self.counter()
rx = self.send_cmd("SYS:MODE " + self.mode, self.TIMEOUT_CMD)
print(rx + "\n")
if ("OK" in rx):
time.sleep(0.25)
break
return True
def counter(self):
self.send_cmd("CNTR:ENABLE 1", self.TIMEOUT_CMD)
while True:
rx = self.send_cmd("CNTR:READ?", self.TIMEOUT_READ)
print(rx + "\n")
time.sleep(0.5)
def limits(self):
self.receive(self.TIMEOUT_CMD)
rx = self.send_cmd("SYS:LIM?", self.TIMEOUT_CMD)
print(rx + "\n")
toks = rx.split(",")
self.lim_adc_1ch_smpl_tm12 = float(toks[0])
self.lim_adc_1ch_smpl_tm8 = float(toks[1])
self.lim_mem = int(toks[2])
self.lim_la_fs = int(toks[3])
self.lim_pwm_fs = int(toks[4])
self.lim_adcs = int(toks[5].replace("D", "").replace("I", ""))
self.lim_dual = "D" in toks[5]
self.lim_inter = "I" in toks[5]
self.lim_bit8 = bool(toks[6])
self.lim_dac = bool(toks[7])
def pwm(self):
default_pwm = "1000,25,25,50,1,1";
while True:
cmd = input("Enter PWM 2-ch settings (FREQ1,DUTY1,DUTY2,OFFSET,EN1,EN2): [" + default_pwm + "]\n")
if cmd == "":
cmd = default_pwm
rx = self.send_cmd("PWM:SET " + cmd, self.TIMEOUT_CMD)
print(rx + "\n")
if "OK" in rx:
break
print(self.send_cmd("PWM:SET?", self.TIMEOUT_CMD) + "\n")
def loop(self):
try:
self.setup()
plt.ion()
fig=plt.figure()
fig.canvas.set_window_title('EMBO')
while True:
if self.read():
self.plot()
self.it = self.it + 1
if self.mode != "VM" and self.trig_mode == "S":
input("Press enter for continue...")
if self.mode == "SCOPE":
rx = self.send_cmd("SYS:MODE SCOPE", self.TIMEOUT_CMD)
else:
rx = self.send_cmd("SYS:MODE LA", self.TIMEOUT_CMD)
if self.READY_STR in rx:
self.ready = True
except KeyboardInterrupt:
pass
self.ser.close()
def setup(self):
while True:
if self.mode == "VM":
self.avg = self.input3("Enter num of averaging samples:", "1", 1, 200)
while True:
self.ch = self.input2("Enter enabled channels (XXXX => T/F):", "TTFF")
if len(self.ch) == 4:
break
self.parse_ch()
self.vcc = self.input2("Show VCC:", "True")
self.vcc = "True" in self.vcc
else:
self.bits = 1
if self.mode == "SCOPE":
if not self.lim_bit8:
self.bits = self.input2("Enter bitness (8 / 12):", "12")
else:
self.bits = "12"
self.bits = int(self.bits)
while True:
self.ch = self.input2("Enter enabled channels (XXXX => T/F):", "TFFF")
if len(self.ch) == 4:
break
self.parse_ch()
max_mem = self.lim_mem
if self.bits == 12:
max_mem = max_mem / 2
if self.mode == "SCOPE":
max_mem = max_mem / ((self.ch_num * 2))
if self.mode == "LA":
max_mem = max_mem / 2
self.mem = self.input3("Enter memory depth", str(int(max_mem)), 1, int(max_mem))
self.mem = int(self.mem)
max_fs = self.lim_la_fs
if self.mode == "SCOPE":
smpltm = self.lim_adc_1ch_smpl_tm12;
if self.bits == 8:
smpltm = self.lim_adc_1ch_smpl_tm8;
if self.lim_adcs == 1:
max_fs = smpltm / float(self.ch_num)
if self.lim_dual and (self.ch_num == 2 or self.ch_num == 4):
print("Dual mode enabled (x2)\n");
max_fs = max_fs * 2.0
elif self.lim_adcs == 2:
cnt1 = int(self.ch1) + int(self.ch2)
cnt2 = int(self.ch3) + int(self.ch4)
cnt_result = cnt1
if cnt2 > cnt1:
cnt_result = cnt2
max_fs = smpltm / float(cnt_result)
else: # 4
max_fs = smpltm
fs_max = int(math.floor(max_fs / 100.0)) * 100
if self.mode == "SCOPE" and self.lim_inter and self.ch_num == 1:
tmpstr = "Interleaved mode enabled";
if self.lim_adcs == 4:
fs_max = fs_max * 4.0;
tmpstr = tmpstr + " (x4)\n"
else:
fs_max = fs_max * 2.0;
tmpstr = tmpstr + " (x2)\n"
print(tmpstr)
self.fs = self.input3("\nEnter sample frequency", str(fs_max), 0, fs_max)
self.fs = int(float(self.fs))
self.trig_ch = self.input3("Enter trigger channel", "1", 1, 4)
self.trig_ch = int(self.trig_ch)
self.trig_val = 0
if self.mode == "SCOPE":
self.trig_val = self.input3("Enter trigger value in percentage", "50", 0, 100)
self.trig_edge = self.input4("Enter trigger edge (R - Rising / F - Falling):", "R", ["R", "F"])
self.trig_mode = self.input4("Enter trigger mode (A - Auto / N - Normal / S - Single / D - Disabled):",
"A", ["A", "N", "S", "D"])
self.trig_pre = self.input3("Enter pretrigger value in percentage", "50", 0, 100)
self.trig_pre = int(self.trig_pre)
rx = ""
#self.ser.flush()
self.receive(self.TIMEOUT_CMD)
if self.mode == "SCOPE":
rx = self.send_cmd('SCOP:SET {},{},{},{},{},{},{},{},{}'.format(self.bits, self.mem, self.fs, self.ch,
self.trig_ch, self.trig_val, self.trig_edge, self.trig_mode, self.trig_pre), self.TIMEOUT_CMD)
elif self.mode == "LA":
rx = self.send_cmd('LA:SET {},{},{},{},{},{}'.format(self.mem, self.fs, self.trig_ch, self.trig_edge,
self.trig_mode, self.trig_pre), self.TIMEOUT_CMD)
elif self.mode == "VM":
rx = "OK"
if self.mode == "VM":
break
print(rx + "\n")
self.ready = False
if self.READY_STR in rx:
self.ready = True
if "OK" not in rx:
continue
"""
if self.mode == "SCOPE":
rx = self.send_cmd("SCOP:SET?", self.TIMEOUT_CMD)
elif self.mode == "LA":
rx = self.send_cmd("LA:SET?", self.TIMEOUT_CMD)
if self.READY_STR in rx:
self.ready = True
print("settings: " + rx + "\n")
"""
break
def read(self):
rx = ""
if self.mode == "VM":
rx = self.send_cmd("VM:READ? " + str(self.avg), self.TIMEOUT_CMD)
toks = rx.split(",")
if len(toks) != 5:
print("Invalid data!")
return False
print(rx)
self.vm_data[0].append(float(toks[0]))
self.vm_data[1].append(float(toks[1]))
self.vm_data[2].append(float(toks[2]))
self.vm_data[3].append(float(toks[3]))
self.vm_data[4].append(float(toks[4]))
if len(self.vm_data[0]) > self.VM_MAX_LEN:
del self.vm_data[0][0]
del self.vm_data[1][0]
del self.vm_data[2][0]
del self.vm_data[3][0]
del self.vm_data[4][0]
el = datetime.datetime.now() - self.tm_last
self.tm_last = datetime.datetime.now()
print("\n" + str(self.it) + f"., " + str(el.total_seconds()) + " ms")
print("---------------------")
return True
else:
#if self.trig_mode != "D":
if not self.ready:
rx2 = self.receive(0.1)
if self.READY_STR not in rx2:
print(".", sep='', end='', flush=True)
time.sleep(0.05)
return False
else:
print(rx2)
#print(rx2)
if self.mode == "SCOPE":
rx = self.read_bin_data("SCOP:READ?", self.TIMEOUT_READ)
elif self.mode == "LA":
rx = self.read_bin_data("LA:READ?", self.TIMEOUT_READ)
self.ready = False
if rx == "DATA":
pass
elif rx == "TIMEOUT":
print("No answer from device")
print("---------------------")
return False
elif self.NOT_READY_STR in rx:
print(".", sep='', end='', flush=True)
return False
else:
print(rx)
print("---------------------")
return False
print("\n")
el = datetime.datetime.now() - self.tm_last
self.tm_last = datetime.datetime.now()
#print(self.raw_data)
buff = []
if self.mode == "SCOPE":
if self.bits == 12:
for i in range(0, int(len(self.raw_data) / 2)):
j = i * 2
buff.append(float((self.raw_data[j + 1] << 8 | self.raw_data[j]) / 10000.0))
else:
for i in range(0, int(len(self.raw_data))):
buff.append(float((self.raw_data[i]) / 100.0))
buff_split = np.array_split(buff, self.ch_num)
self.scope_data = []
self.scope_data.extend(([], [], [], []))
i = 0
if self.ch1:
self.scope_data[0] = buff_split[i]
i = i + 1
if self.ch2:
self.scope_data[1] = buff_split[i]
i = i + 1
if self.ch3:
self.scope_data[2] = buff_split[i]
i = i + 1
if self.ch4:
self.scope_data[3] = buff_split[i]
i = i + 1
else: # LA
self.la_data = []
self.la_data.extend(([], [], [], []))
for i in range(0, int(len(self.raw_data))):
ch1 = self.raw_data[i] & 2 != 0
ch2 = self.raw_data[i] & 4 != 0
ch3 = self.raw_data[i] & 8 != 0
ch4 = self.raw_data[i] & 16 != 0
self.la_data[0].append(ch1)
self.la_data[1].append(ch2)
self.la_data[2].append(ch3)
self.la_data[3].append(ch4)
print(str(self.it) + f"., {(float(len(self.raw_data)) / 1024.0):.1f} KB, " + str(el.total_seconds()) + " s")
print("---------------------")
return True
def plot(self):
ax = plt.gca()
plt.clf()
plt.grid(True, linestyle=':')
ax.grid(which='major', alpha=0.9)
if self.mode != "VM":
rngx = (self.mem / self.fs * 1000) * 1.0
rngx_l = -1 * rngx * (self.trig_pre / 100.0)
rngx_r = rngx * ((100.0 - self.trig_pre) / 100.0)
#rngx = self.mem
#rngx_l = 0
#rngx_r = rngx
major_ticks_x = np.linspace(rngx_l, rngx_r, 50)
minor_ticks_x = np.linspace(rngx_l, rngx_r, 10)
ax.set_xticks(major_ticks_x)
ax.set_xticks(minor_ticks_x, minor=True)
plt.xlim(rngx_l, rngx_r)
plt.axvline(x=0, color='k', linestyle='--', linewidth=2.5, alpha=0.8)
if self.mode != "LA":
plt.axhline(y=3.3 * (float(self.trig_val) / 100.0), color='k', linestyle='--', linewidth=2.5, alpha=0.8)
plt.xlabel("Time [ms]")
else:
plt.xlabel("Time")
major_ticks_x = np.arange(0, self.VM_MAX_LEN, 50)
minor_ticks_x = np.arange(0, self.VM_MAX_LEN, 10)
ax.set_xticks(major_ticks_x)
ax.set_xticks(minor_ticks_x, minor=True)
plt.xlim(0, self.VM_MAX_LEN)
if self.mode == "LA":
plt.ylim(-0.1, 1.1)
major_ticks_y = np.linspace(0, 1.0, 10)
minor_ticks_y = np.linspace(0, 1.0, 20)
plt.ylabel("Logic value")
else:
plt.ylim(0, 3.5)
major_ticks_y = np.linspace(0, 3.3, 10)
minor_ticks_y = np.linspace(0, 3.3, 20)
plt.ylabel("Voltage [V]")
ax.set_yticks(major_ticks_y)
#ax.set_xticklabels(major_ticks_y)
ax.set_yticks(minor_ticks_y, minor=True)
LINE_WIDTH = 2.0
if self.mode == "SCOPE":
t = np.linspace(rngx_l, rngx_r, self.mem)
if self.ch1:
plt.plot(t, self.scope_data[0], 'g', label="Channel 1", linewidth=LINE_WIDTH)
if self.ch2:
plt.plot(t, self.scope_data[1], 'r', label="Channel 2", linewidth=LINE_WIDTH)
if self.ch3:
plt.plot(t, self.scope_data[2], 'b', label="Channel 3", linewidth=LINE_WIDTH)
if self.ch4:
plt.plot(t, self.scope_data[3], 'm', label="Channel 4", linewidth=LINE_WIDTH)
elif self.mode == "LA":
t = np.linspace(rngx_l, rngx_r, self.mem)
if self.ch1:
plt.plot(t, self.la_data[0], 'g', label="Channel 1", linewidth=LINE_WIDTH)
if self.ch2:
plt.plot(t, self.la_data[1], 'r', label="Channel 2", linewidth=LINE_WIDTH)
if self.ch3:
plt.plot(t, self.la_data[2], 'b', label="Channel 3", linewidth=LINE_WIDTH)
if self.ch4:
plt.plot(t, self.la_data[3], 'm', label="Channel 4", linewidth=LINE_WIDTH)
else:
t = np.arange(0, len(self.vm_data[0]))
if self.ch1:
plt.plot(t, self.vm_data[0], 'g', label="Channel 1", linewidth=LINE_WIDTH)
if self.ch2:
plt.plot(t, self.vm_data[1], 'r', label="Channel 2", linewidth=LINE_WIDTH)
if self.ch3:
plt.plot(t, self.vm_data[2], 'b', label="Channel 3", linewidth=LINE_WIDTH)
if self.ch4:
plt.plot(t, self.vm_data[3], 'm', label="Channel 4", linewidth=LINE_WIDTH)
if self.vcc:
plt.plot(t, self.vm_data[4], 'c', label="Vcc", linewidth=LINE_WIDTH)
plt.legend(loc="lower right")
plt.rcParams.update({'font.size': 22})
plt.show()
plt.pause(0.0001) # ?
def receive(self, timeout):
start = datetime.datetime.now()
buffer_string = ""
while True:
try:
buffer_string = buffer_string + (self.ser.read(self.ser.inWaiting())).decode("utf-8")
except Exception as e:
pass
#print("--" + str(buffer_string) + "--")
#print(e)
if (datetime.datetime.now() - start).total_seconds() > timeout:
#print("Command timeout!")
return ""
if "\r\n" in buffer_string:
return buffer_string.replace("\r\n", "").strip("\"")
def input2(self, text, default):
ret = input(text + " [" + default + "]\n")
if (ret == ""):
return default
return ret
def input3(self, text, default, lim_min, lim_max):
while True:
ret = input(text + " (" + str(lim_min) + " - " + str(lim_max) + "):" + " [" + default + "]\n")
if (ret == ""):
return default
if int(ret) <= lim_max and int(ret) >= lim_min:
return ret
def input4(self, text, default, allowed):
while True:
ret = input(text + " [" + default + "]\n")
if (ret == ""):
return default
if ret in allowed:
return ret
def send_cmd(self, cmd, timeout):
print(cmd)
self.ser.write(str.encode(cmd + "\r\n"))
return self.receive(timeout)
def read_bin_data(self, cmd, timeout):
self.ser.write(str.encode(cmd + "\r\n"))
state = "hash"
num = 0
count = 0
start = datetime.datetime.now()
bin_buff = b''
rx = ""
while True:
if state == "hash":
rx = self.ser.read(1).decode("utf-8")
if len(rx) == 0:
pass
elif rx == "#":
state = "num"
else:
rx2 = self.receive(self.TIMEOUT_CMD)
return rx + rx2
elif state == "num":
rx = self.ser.read(1).decode("utf-8")
if len(rx) == 1:
num = int(rx)
state = "count"
elif state == "count":
rx = self.ser.read(num).decode("utf-8")
if len(rx) == num:
count = int(rx)
state = "data"
elif state == "data":
rx = self.ser.read(1)
if len(rx) == 1:
bin_buff += rx
if len(bin_buff) == count:
self.raw_data = np.frombuffer(bin_buff, dtype=np.uint8)
state = "crlf"
elif state == "crlf":
rx = self.ser.read(2).decode("utf-8")
if "\r\n" in rx:
return "DATA"
if (datetime.datetime.now() - start).total_seconds() > timeout:
#print("Read binary data timeout!")
print(rx)
print(str(state))
print(str(len(bin_buff)))
return "TIMEOUT"
def parse_ch(self):
self.ch_num = self.ch.count('T')
self.ch1 = False
self.ch2 = False
self.ch3 = False
self.ch4 = False
if self.ch[0] == 'T':
self.ch1 = True
if self.ch[1] == 'T':
self.ch2 = True
if self.ch[2] == 'T':
self.ch3 = True
if self.ch[3] == 'T':
self.ch4 = True
Embo()
|
437992
|
import numpy as np
import random
A=np.array(([2, 4, 0, 0], [3, 5, 1, 0], [0, 6, 2, 0],
[5, 7, 0, 1], [6, 8, 4, 2], [0, 9, 5, 3],
[8, 0, 0, 4], [9, 0, 7, 5], [0, 0, 8, 6]))
def Nbr(n, k): return A.T[n-1, k-1]
L=3
N=L**2
sigma=[random.choice([-1, 1]) for i in range(N)]
##sigma=[-1, 1, -1, 1, -1, 1, 1, 1, -1]
print("sigma=",sigma)
def energy_ising(sigma):
N=len(sigma)
E=0
for k in range(1, N+1):
for n in range(1, 3):
j=Nbr(n,k)
if j!=0: E-=sigma[k-1]*sigma[j-1]
return E
print(energy_ising(sigma))
|
437999
|
set_name(0x8007D77C, "GetTpY__FUs", SN_NOWARN)
set_name(0x8007D798, "GetTpX__FUs", SN_NOWARN)
set_name(0x8007D7A4, "Remove96__Fv", SN_NOWARN)
set_name(0x8007D7DC, "AppMain", SN_NOWARN)
set_name(0x8007D884, "MAIN_RestartGameTask__Fv", SN_NOWARN)
set_name(0x8007D8B0, "GameTask__FP4TASK", SN_NOWARN)
set_name(0x8007D948, "MAIN_MainLoop__Fv", SN_NOWARN)
set_name(0x8007D99C, "CheckMaxArgs__Fv", SN_NOWARN)
set_name(0x8007D9D0, "GPUQ_InitModule__Fv", SN_NOWARN)
set_name(0x8007D9DC, "GPUQ_FlushQ__Fv", SN_NOWARN)
set_name(0x8007DB50, "GPUQ_LoadImage__FP4RECTli", SN_NOWARN)
set_name(0x8007DC04, "GPUQ_DiscardHandle__Fl", SN_NOWARN)
set_name(0x8007DCA4, "GPUQ_LoadClutAddr__FiiiPv", SN_NOWARN)
set_name(0x8007DD40, "GPUQ_MoveImage__FP4RECTii", SN_NOWARN)
set_name(0x8007DDE0, "PRIM_Open__FiiiP10SCREEN_ENVUl", SN_NOWARN)
set_name(0x8007DEFC, "InitPrimBuffer__FP11PRIM_BUFFERii", SN_NOWARN)
set_name(0x8007DFD8, "PRIM_Clip__FP4RECTi", SN_NOWARN)
set_name(0x8007E100, "PRIM_FullScreen__Fi", SN_NOWARN)
set_name(0x8007E13C, "PRIM_Flush__Fv", SN_NOWARN)
set_name(0x8007E344, "ClearPbOnDrawSync", SN_NOWARN)
set_name(0x8007E380, "ClearedYet__Fv", SN_NOWARN)
set_name(0x8007E38C, "PrimDrawSycnCallBack", SN_NOWARN)
set_name(0x8007E3AC, "SendDispEnv__Fv", SN_NOWARN)
set_name(0x8007E3D0, "PRIM_GetNextPolyF4__Fv", SN_NOWARN)
set_name(0x8007E3E8, "PRIM_GetNextPolyFt4__Fv", SN_NOWARN)
set_name(0x8007E400, "PRIM_GetNextPolyGt4__Fv", SN_NOWARN)
set_name(0x8007E418, "PRIM_GetNextPolyG4__Fv", SN_NOWARN)
set_name(0x8007E430, "PRIM_GetNextPolyF3__Fv", SN_NOWARN)
set_name(0x8007E448, "PRIM_GetNextDrArea__Fv", SN_NOWARN)
set_name(0x8007E460, "ClipRect__FRC4RECTR4RECT", SN_NOWARN)
set_name(0x8007E574, "IsColiding__FRC4RECTT0", SN_NOWARN)
set_name(0x8007E5DC, "VID_AfterDisplay__Fv", SN_NOWARN)
set_name(0x8007E5FC, "VID_ScrOn__Fv", SN_NOWARN)
set_name(0x8007E624, "VID_DoThisNextSync__FPFv_v", SN_NOWARN)
set_name(0x8007E67C, "VID_NextSyncRoutHasExecuted__Fv", SN_NOWARN)
set_name(0x8007E688, "VID_GetTick__Fv", SN_NOWARN)
set_name(0x8007E694, "VID_DispEnvSend", SN_NOWARN)
set_name(0x8007E6D0, "VID_SetXYOff__Fii", SN_NOWARN)
set_name(0x8007E6E0, "VID_GetXOff__Fv", SN_NOWARN)
set_name(0x8007E6EC, "VID_GetYOff__Fv", SN_NOWARN)
set_name(0x8007E6F8, "MyFilter__FUlUlPCc", SN_NOWARN)
set_name(0x8007E700, "SlowMemMove__FPvT0Ul", SN_NOWARN)
set_name(0x8007E720, "GetTpY__FUs_addr_8007E720", SN_NOWARN)
set_name(0x8007E73C, "GetTpX__FUs_addr_8007E73C", SN_NOWARN)
set_name(0x8007E748, "SYSI_GetFs__Fv", SN_NOWARN)
set_name(0x8007E754, "SYSI_GetOverlayFs__Fv", SN_NOWARN)
set_name(0x8007E760, "SortOutFileSystem__Fv", SN_NOWARN)
set_name(0x8007E89C, "MemCb__FlPvUlPCcii", SN_NOWARN)
set_name(0x8007E8BC, "Spanker__Fv", SN_NOWARN)
set_name(0x8007E8FC, "GaryLiddon__Fv", SN_NOWARN)
set_name(0x8007E904, "ReadPad__Fi", SN_NOWARN)
set_name(0x8007E964, "DummyPoll__Fv", SN_NOWARN)
set_name(0x8007E96C, "DaveOwens__Fv", SN_NOWARN)
set_name(0x8007E994, "GetCur__C4CPad", SN_NOWARN)
set_name(0x8007E9BC, "GetTpY__FUs_addr_8007E9BC", SN_NOWARN)
set_name(0x8007E9D8, "GetTpX__FUs_addr_8007E9D8", SN_NOWARN)
set_name(0x8007E9E4, "TimSwann__Fv", SN_NOWARN)
set_name(0x8007E9EC, "stub__FPcPv", SN_NOWARN)
set_name(0x8007E9F4, "eprint__FPcT0i", SN_NOWARN)
set_name(0x8007EA28, "leighbird__Fv", SN_NOWARN)
set_name(0x8007EA50, "__6FileIOUl", SN_NOWARN)
set_name(0x8007EAA0, "___6FileIO", SN_NOWARN)
set_name(0x8007EAF4, "Read__6FileIOPCcUl", SN_NOWARN)
set_name(0x8007EC5C, "FileLen__6FileIOPCc", SN_NOWARN)
set_name(0x8007ECC0, "FileNotFound__6FileIOPCc", SN_NOWARN)
set_name(0x8007ECE0, "StreamFile__6FileIOPCciPFPUciib_bii", SN_NOWARN)
set_name(0x8007EDC0, "ReadAtAddr__6FileIOPCcPUci", SN_NOWARN)
set_name(0x8007EE84, "DumpOldPath__6FileIO", SN_NOWARN)
set_name(0x8007EEE8, "SetSearchPath__6FileIOPCc", SN_NOWARN)
set_name(0x8007EFC4, "FindFile__6FileIOPCcPc", SN_NOWARN)
set_name(0x8007F0D8, "CopyPathItem__6FileIOPcPCc", SN_NOWARN)
set_name(0x8007F180, "LockSearchPath__6FileIO", SN_NOWARN)
set_name(0x8007F1D8, "UnlockSearchPath__6FileIO", SN_NOWARN)
set_name(0x8007F230, "SearchPathExists__6FileIO", SN_NOWARN)
set_name(0x8007F244, "Save__6FileIOPCcPUci", SN_NOWARN)
set_name(0x8007F280, "__4PCIOUl", SN_NOWARN)
set_name(0x8007F2E8, "___4PCIO", SN_NOWARN)
set_name(0x8007F340, "FileExists__4PCIOPCc", SN_NOWARN)
set_name(0x8007F384, "LoReadFileAtAddr__4PCIOPCcPUci", SN_NOWARN)
set_name(0x8007F448, "GetFileLength__4PCIOPCc", SN_NOWARN)
set_name(0x8007F500, "LoSave__4PCIOPCcPUci", SN_NOWARN)
set_name(0x8007F5D4, "LoStreamFile__4PCIOPCciPFPUciib_bii", SN_NOWARN)
set_name(0x8007F7E4, "__6SysObj", SN_NOWARN)
set_name(0x8007F7FC, "__nw__6SysObji", SN_NOWARN)
set_name(0x8007F828, "__nw__6SysObjiUl", SN_NOWARN)
set_name(0x8007F8A4, "__dl__6SysObjPv", SN_NOWARN)
set_name(0x8007F910, "__5DatIOUl", SN_NOWARN)
set_name(0x8007F94C, "___5DatIO", SN_NOWARN)
set_name(0x8007F9A4, "FileExists__5DatIOPCc", SN_NOWARN)
set_name(0x8007F9E4, "LoReadFileAtAddr__5DatIOPCcPUci", SN_NOWARN)
set_name(0x8007FAA4, "GetFileLength__5DatIOPCc", SN_NOWARN)
set_name(0x8007FB58, "LoSave__5DatIOPCcPUci", SN_NOWARN)
set_name(0x8007FC00, "LoStreamFile__5DatIOPCciPFPUciib_bii", SN_NOWARN)
set_name(0x8007FE0C, "__7TextDat", SN_NOWARN)
set_name(0x8007FE4C, "___7TextDat", SN_NOWARN)
set_name(0x8007FE94, "Use__7TextDat", SN_NOWARN)
set_name(0x80080088, "TpLoadCallBack__FPUciib", SN_NOWARN)
set_name(0x80080158, "StreamLoadTP__7TextDat", SN_NOWARN)
set_name(0x80080210, "FinishedUsing__7TextDat", SN_NOWARN)
set_name(0x8008026C, "MakeBlockOffsetTab__7TextDat", SN_NOWARN)
set_name(0x800802DC, "MakeOffsetTab__C9CBlockHdr", SN_NOWARN)
set_name(0x80080408, "SetUVTp__7TextDatP9FRAME_HDRP8POLY_FT4ii", SN_NOWARN)
set_name(0x80080504, "PrintMonster__7TextDatiiibi", SN_NOWARN)
set_name(0x8008090C, "PrepareFt4__7TextDatP8POLY_FT4iiiii", SN_NOWARN)
set_name(0x80080B78, "GetDecompBufffer__7TextDati", SN_NOWARN)
set_name(0x80080CD8, "SetUVTpGT4__7TextDatP9FRAME_HDRP8POLY_GT4ii", SN_NOWARN)
set_name(0x80080DD4, "PrepareGt4__7TextDatP8POLY_GT4iiiii", SN_NOWARN)
set_name(0x80081030, "SetUVTpGT3__7TextDatP9FRAME_HDRP8POLY_GT3", SN_NOWARN)
set_name(0x800810B0, "PrepareGt3__7TextDatP8POLY_GT3iii", SN_NOWARN)
set_name(0x80081274, "PrintFt4__7TextDatiiiiii", SN_NOWARN)
set_name(0x800813C8, "PrintGt4__7TextDatiiiiii", SN_NOWARN)
set_name(0x8008151C, "PrintGt3__7TextDatiiii", SN_NOWARN)
set_name(0x80081600, "DecompFrame__7TextDatP9FRAME_HDR", SN_NOWARN)
set_name(0x80081754, "MakeCreatureOffsetTab__7TextDat", SN_NOWARN)
set_name(0x80081894, "MakePalOffsetTab__7TextDat", SN_NOWARN)
set_name(0x80081990, "InitData__7TextDat", SN_NOWARN)
set_name(0x800819BC, "DumpData__7TextDat", SN_NOWARN)
set_name(0x80081B04, "GM_UseTexData__Fi", SN_NOWARN)
set_name(0x80081B78, "GM_FinishedUsing__FP7TextDat", SN_NOWARN)
set_name(0x80081B98, "GetFrNum__7TextDatiiii", SN_NOWARN)
set_name(0x80081BEC, "IsDirAliased__7TextDatiii", SN_NOWARN)
set_name(0x80081C44, "DoDecompRequests__7TextDat", SN_NOWARN)
set_name(0x80081D68, "FindDecompArea__7TextDatR4RECT", SN_NOWARN)
set_name(0x80081E3C, "GetFileInfo__7TextDati", SN_NOWARN)
set_name(0x80081E8C, "GetSize__C15CCreatureAction", SN_NOWARN)
set_name(0x80081EB4, "GetFrNum__C15CCreatureActionii", SN_NOWARN)
set_name(0x80081F5C, "InitDirRemap__15CCreatureAction", SN_NOWARN)
set_name(0x8008201C, "GetFrNum__C12CCreatureHdriii", SN_NOWARN)
set_name(0x80082060, "GetAction__C12CCreatureHdri", SN_NOWARN)
set_name(0x800820F0, "InitActionDirRemaps__12CCreatureHdr", SN_NOWARN)
set_name(0x80082160, "GetSize__C12CCreatureHdr", SN_NOWARN)
set_name(0x800821CC, "LoadDat__C13CTextFileInfo", SN_NOWARN)
set_name(0x8008221C, "LoadHdr__C13CTextFileInfo", SN_NOWARN)
set_name(0x80082244, "GetFile__C13CTextFileInfoPc", SN_NOWARN)
set_name(0x800822E0, "HasFile__C13CTextFileInfoPc", SN_NOWARN)
set_name(0x80082348, "Un64__FPUcT0l", SN_NOWARN)
set_name(0x8008241C, "__7CScreen", SN_NOWARN)
set_name(0x80082450, "Load__7CScreeniii", SN_NOWARN)
set_name(0x80082604, "Unload__7CScreen", SN_NOWARN)
set_name(0x80082628, "Display__7CScreeniii", SN_NOWARN)
set_name(0x800828FC, "SetRect__5CPartR7TextDatR4RECT", SN_NOWARN)
set_name(0x80082974, "GetBoundingBox__6CBlockR7TextDatR4RECT", SN_NOWARN)
set_name(0x80082AD0, "_GLOBAL__D_AllDats", SN_NOWARN)
set_name(0x80082B28, "_GLOBAL__I_AllDats", SN_NOWARN)
set_name(0x80082B7C, "PRIM_GetPrim__FPP8POLY_GT3", SN_NOWARN)
set_name(0x80082BF8, "PRIM_GetPrim__FPP8POLY_GT4", SN_NOWARN)
set_name(0x80082C74, "PRIM_GetPrim__FPP8POLY_FT4", SN_NOWARN)
set_name(0x80082CF0, "SetPal__7TextDatP9FRAME_HDRP8POLY_FT4", SN_NOWARN)
set_name(0x80082DB8, "CanXferFrame__7TextDat", SN_NOWARN)
set_name(0x80082DE0, "CanXferPal__7TextDat", SN_NOWARN)
set_name(0x80082E08, "GetCreature__7TextDati", SN_NOWARN)
set_name(0x80082E80, "GetNumOfCreatures__7TextDat", SN_NOWARN)
set_name(0x80082E94, "SetFileInfo__7TextDatPC13CTextFileInfo", SN_NOWARN)
set_name(0x80082E9C, "GetNumOfFrames__7TextDat", SN_NOWARN)
set_name(0x80082EB0, "GetPal__7TextDati", SN_NOWARN)
set_name(0x80082ECC, "GetFr__7TextDati", SN_NOWARN)
set_name(0x80082EE8, "GetName__C13CTextFileInfo", SN_NOWARN)
set_name(0x80082EF4, "HasDat__C13CTextFileInfo", SN_NOWARN)
set_name(0x80082F1C, "HasTp__C13CTextFileInfo", SN_NOWARN)
set_name(0x80082F44, "GetSize__C6CBlock", SN_NOWARN)
set_name(0x80082F58, "__4CdIOUl", SN_NOWARN)
set_name(0x80082F9C, "___4CdIO", SN_NOWARN)
set_name(0x80082FF4, "FileExists__4CdIOPCc", SN_NOWARN)
set_name(0x80083018, "LoReadFileAtAddr__4CdIOPCcPUci", SN_NOWARN)
set_name(0x80083040, "GetFileLength__4CdIOPCc", SN_NOWARN)
set_name(0x80083064, "LoSave__4CdIOPCcPUci", SN_NOWARN)
set_name(0x80083144, "LoStreamCallBack__Fi", SN_NOWARN)
set_name(0x80083154, "CD_GetCdlFILE__FPCcP7CdlFILE", SN_NOWARN)
set_name(0x800832A0, "LoStreamFile__4CdIOPCciPFPUciib_bii", SN_NOWARN)
set_name(0x80083500, "BL_InitEAC__Fv", SN_NOWARN)
set_name(0x800835EC, "BL_ReadFile__FPcUl", SN_NOWARN)
set_name(0x80083718, "BL_LoadDirectory__Fv", SN_NOWARN)
set_name(0x80083884, "BL_LoadStreamDir__Fv", SN_NOWARN)
set_name(0x80083B3C, "BL_MakeFilePosTab__FPUcUl", SN_NOWARN)
set_name(0x80083C3C, "BL_FindStreamFile__FPcc", SN_NOWARN)
set_name(0x80083DD8, "BL_FileExists__FPcc", SN_NOWARN)
set_name(0x80083DFC, "BL_FileLength__FPcc", SN_NOWARN)
set_name(0x80083E30, "BL_LoadFileAtAddr__FPcPUcc", SN_NOWARN)
set_name(0x80083F18, "BL_AsyncLoadDone__Fv", SN_NOWARN)
set_name(0x80083F24, "BL_AsyncLoadTASK__FP4TASK", SN_NOWARN)
set_name(0x80083F90, "BL_LoadFileAsync__FPcPUcc", SN_NOWARN)
set_name(0x80084088, "BL_OpenStreamFile__FPcc", SN_NOWARN)
set_name(0x800840B4, "BL_CloseStreamFile__FP6STRHDR", SN_NOWARN)
set_name(0x800840EC, "BL_LoadFile__FPcUl", SN_NOWARN)
set_name(0x80084204, "LZNP_Decode__FPUcT0", SN_NOWARN)
set_name(0x800842D8, "Tmalloc__Fi", SN_NOWARN)
set_name(0x800843FC, "Tfree__FPv", SN_NOWARN)
set_name(0x800844AC, "InitTmalloc__Fv", SN_NOWARN)
set_name(0x800844D4, "strupr__FPc", SN_NOWARN)
set_name(0x80084528, "PauseTask__FP4TASK", SN_NOWARN)
set_name(0x80084574, "GetPausePad__Fv", SN_NOWARN)
set_name(0x80084604, "TryPadForPause__Fi", SN_NOWARN)
set_name(0x80084630, "DoPause__14CPauseMessagesi", SN_NOWARN)
set_name(0x800847D0, "DoPausedMessage__14CPauseMessages", SN_NOWARN)
set_name(0x80084AC4, "DoQuitMessage__14CPauseMessages", SN_NOWARN)
set_name(0x80084BAC, "AreYouSureMessage__14CPauseMessages", SN_NOWARN)
set_name(0x80084C94, "PA_SetPauseOk__Fb", SN_NOWARN)
set_name(0x80084CA4, "PA_GetPauseOk__Fv", SN_NOWARN)
set_name(0x80084CB0, "MY_PausePrint__17CTempPauseMessageiPci", SN_NOWARN)
set_name(0x80084E00, "InitPrintQuitMessage__17CTempPauseMessage", SN_NOWARN)
set_name(0x80084E08, "PrintQuitMessage__17CTempPauseMessagei", SN_NOWARN)
set_name(0x80084F08, "LeavePrintQuitMessage__17CTempPauseMessagei", SN_NOWARN)
set_name(0x80084F10, "InitPrintAreYouSure__17CTempPauseMessage", SN_NOWARN)
set_name(0x80084F18, "PrintAreYouSure__17CTempPauseMessagei", SN_NOWARN)
set_name(0x80085018, "LeavePrintAreYouSure__17CTempPauseMessagei", SN_NOWARN)
set_name(0x80085020, "InitPrintPaused__17CTempPauseMessage", SN_NOWARN)
set_name(0x80085028, "PrintPaused__17CTempPauseMessage", SN_NOWARN)
set_name(0x8008510C, "LeavePrintPaused__17CTempPauseMessage", SN_NOWARN)
set_name(0x80085114, "___17CTempPauseMessage", SN_NOWARN)
set_name(0x8008513C, "_GLOBAL__D_DoPause__14CPauseMessagesi", SN_NOWARN)
set_name(0x80085164, "_GLOBAL__I_DoPause__14CPauseMessagesi", SN_NOWARN)
set_name(0x8008518C, "__17CTempPauseMessage", SN_NOWARN)
set_name(0x800851D0, "___14CPauseMessages", SN_NOWARN)
set_name(0x80085204, "__14CPauseMessages", SN_NOWARN)
set_name(0x80085218, "SetRGB__6DialogUcUcUc", SN_NOWARN)
set_name(0x80085238, "SetBack__6Dialogi", SN_NOWARN)
set_name(0x80085240, "SetBorder__6Dialogi", SN_NOWARN)
set_name(0x80085248, "___6Dialog", SN_NOWARN)
set_name(0x80085270, "__6Dialog", SN_NOWARN)
set_name(0x800852CC, "GetDown__C4CPad", SN_NOWARN)
set_name(0x800852F4, "GetUp__C4CPad", SN_NOWARN)
set_name(0x8008531C, "PAD_Handler__Fv", SN_NOWARN)
set_name(0x800854D0, "PAD_GetPad__FiUc", SN_NOWARN)
set_name(0x8008556C, "NewVal__4CPadUs", SN_NOWARN)
set_name(0x800856A4, "BothNewVal__4CPadUsUs", SN_NOWARN)
set_name(0x80085800, "Trans__4CPadUs", SN_NOWARN)
set_name(0x80085924, "_GLOBAL__I_Pad0", SN_NOWARN)
set_name(0x8008595C, "SetBothFlag__4CPadUc", SN_NOWARN)
set_name(0x80085964, "__4CPadi", SN_NOWARN)
set_name(0x80085998, "Flush__4CPad", SN_NOWARN)
set_name(0x800859BC, "Set__7FontTab", SN_NOWARN)
set_name(0x80085A58, "InitPrinty__Fv", SN_NOWARN)
set_name(0x80085AE0, "PrintChar__5CFontUsUscUcUcUc", SN_NOWARN)
set_name(0x80085C68, "Print__5CFontiiPc8TXT_JUSTP4RECTUcUcUc", SN_NOWARN)
set_name(0x80086000, "GetStrWidth__5CFontPc", SN_NOWARN)
set_name(0x80086068, "SetChar__5CFontiUs", SN_NOWARN)
set_name(0x800860CC, "SetOTpos__5CFonti", SN_NOWARN)
set_name(0x800860D8, "ClearFont__5CFont", SN_NOWARN)
set_name(0x800860FC, "IsDefined__5CFontUc", SN_NOWARN)
set_name(0x8008611C, "GetCharFrameNum__5CFontc", SN_NOWARN)
set_name(0x80086134, "GetCharWidth__5CFontc", SN_NOWARN)
set_name(0x8008618C, "Init__5CFont", SN_NOWARN)
set_name(0x800861C0, "GetFr__7TextDati_addr_800861C0", SN_NOWARN)
set_name(0x800861DC, "TrimCol__Fs", SN_NOWARN)
set_name(0x80086214, "DialogPrint__Fiiiiiiiiii", SN_NOWARN)
set_name(0x80086B8C, "GetDropShadowG4__FUcUcUcUcUcUcUcUcUcUcUcUc", SN_NOWARN)
set_name(0x80086CC4, "DropShadows__Fiiii", SN_NOWARN)
set_name(0x80086F68, "InitDialog__Fv", SN_NOWARN)
set_name(0x800870A0, "GetSizes__6Dialog", SN_NOWARN)
set_name(0x800872F8, "Back__6Dialogiiii", SN_NOWARN)
set_name(0x800884B8, "Line__6Dialogiii", SN_NOWARN)
set_name(0x800886D0, "GetPal__7TextDati_addr_800886D0", SN_NOWARN)
set_name(0x800886EC, "GetFr__7TextDati_addr_800886EC", SN_NOWARN)
set_name(0x80088708, "ATT_DoAttract__Fv", SN_NOWARN)
set_name(0x800887C0, "CreatePlayersFromFeData__FR9FE_CREATE", SN_NOWARN)
set_name(0x8008885C, "UpdateSel__FPUsUsPUc", SN_NOWARN)
set_name(0x8008889C, "CycleSelCols__Fv", SN_NOWARN)
set_name(0x80088A2C, "FindTownCreature__7CBlocksi", SN_NOWARN)
set_name(0x80088AA0, "FindCreature__7CBlocksi", SN_NOWARN)
set_name(0x80088AF4, "__7CBlocksiiiii", SN_NOWARN)
set_name(0x80088C48, "SetTownersGraphics__7CBlocks", SN_NOWARN)
set_name(0x80088C80, "SetMonsterGraphics__7CBlocksii", SN_NOWARN)
set_name(0x80088D48, "___7CBlocks", SN_NOWARN)
set_name(0x80088DD0, "DumpGt4s__7CBlocks", SN_NOWARN)
set_name(0x80088E38, "DumpRects__7CBlocks", SN_NOWARN)
set_name(0x80088EA0, "SetGraphics__7CBlocksPP7TextDatPii", SN_NOWARN)
set_name(0x80088EFC, "DumpGraphics__7CBlocksPP7TextDatPi", SN_NOWARN)
set_name(0x80088F4C, "PrintBlockOutline__7CBlocksiiiii", SN_NOWARN)
set_name(0x80089298, "Load__7CBlocksi", SN_NOWARN)
set_name(0x80089340, "MakeRectTable__7CBlocks", SN_NOWARN)
set_name(0x80089414, "MakeGt4Table__7CBlocks", SN_NOWARN)
set_name(0x8008951C, "MakeGt4__7CBlocksP8POLY_GT4P9FRAME_HDR", SN_NOWARN)
set_name(0x80089658, "GetBlock__7CBlocksi", SN_NOWARN)
set_name(0x800896D0, "Print__7CBlocks", SN_NOWARN)
set_name(0x800896F8, "SetXY__7CBlocksii", SN_NOWARN)
set_name(0x80089720, "GetXY__7CBlocksPiT1", SN_NOWARN)
set_name(0x80089738, "PrintMap__7CBlocksii", SN_NOWARN)
set_name(0x8008AEA0, "PrintGameSprites__7CBlocksiiiii", SN_NOWARN)
set_name(0x8008B010, "PrintGameSprites__7CBlocksP8map_infoiiiiiii", SN_NOWARN)
set_name(0x8008BD14, "PrintSprites__7CBlocksP8map_infoiiiiiii", SN_NOWARN)
set_name(0x8008C3D4, "PrintSprites__7CBlocksiiiii", SN_NOWARN)
set_name(0x8008C544, "ScrToWorldX__7CBlocksii", SN_NOWARN)
set_name(0x8008C558, "ScrToWorldY__7CBlocksii", SN_NOWARN)
set_name(0x8008C56C, "SetScrollTarget__7CBlocksii", SN_NOWARN)
set_name(0x8008C630, "DoScroll__7CBlocks", SN_NOWARN)
set_name(0x8008C698, "SetPlayerPosBlocks__7CBlocksiii", SN_NOWARN)
set_name(0x8008C738, "GetScrXY__7CBlocksR4RECTiiii", SN_NOWARN)
set_name(0x8008C80C, "ShadScaleSkew__7CBlocksP8POLY_FT4", SN_NOWARN)
set_name(0x8008C88C, "WorldToScrX__7CBlocksii", SN_NOWARN)
set_name(0x8008C894, "WorldToScrY__7CBlocksii", SN_NOWARN)
set_name(0x8008C8A8, "BL_GetCurrentBlocks__Fv", SN_NOWARN)
set_name(0x8008C8B4, "PRIM_GetPrim__FPP8POLY_FT4_addr_8008C8B4", SN_NOWARN)
set_name(0x8008C930, "GetHighlightCol__FiPiUsUsUs", SN_NOWARN)
set_name(0x8008C978, "PRIM_GetCopy__FP8POLY_FT4", SN_NOWARN)
set_name(0x8008C9B4, "GetHighlightCol__FiPcUsUsUs", SN_NOWARN)
set_name(0x8008C9FC, "PRIM_GetPrim__FPP8POLY_GT4_addr_8008C9FC", SN_NOWARN)
set_name(0x8008CA78, "PRIM_GetPrim__FPP7LINE_F2", SN_NOWARN)
set_name(0x8008CAF4, "PRIM_CopyPrim__FP8POLY_FT4T0", SN_NOWARN)
set_name(0x8008CB1C, "GetCreature__14TownToCreaturei", SN_NOWARN)
set_name(0x8008CB38, "SetItemGraphics__7CBlocksi", SN_NOWARN)
set_name(0x8008CB60, "SetObjGraphics__7CBlocksi", SN_NOWARN)
set_name(0x8008CB88, "DumpItems__7CBlocks", SN_NOWARN)
set_name(0x8008CBAC, "DumpObjs__7CBlocks", SN_NOWARN)
set_name(0x8008CBD0, "DumpMonsters__7CBlocks", SN_NOWARN)
set_name(0x8008CBF8, "GetNumOfBlocks__7CBlocks", SN_NOWARN)
set_name(0x8008CC04, "CopyToGt4__9LittleGt4P8POLY_GT4", SN_NOWARN)
set_name(0x8008CC9C, "InitFromGt4__9LittleGt4P8POLY_GT4ii", SN_NOWARN)
set_name(0x8008CD2C, "SetPal__7TextDatP9FRAME_HDRP8POLY_FT4_addr_8008CD2C", SN_NOWARN)
set_name(0x8008CDF4, "CanXferPal__7TextDat_addr_8008CDF4", SN_NOWARN)
set_name(0x8008CE1C, "GetNumOfFrames__7TextDatii", SN_NOWARN)
set_name(0x8008CE54, "GetCreature__7TextDati_addr_8008CE54", SN_NOWARN)
set_name(0x8008CECC, "GetNumOfCreatures__7TextDat_addr_8008CECC", SN_NOWARN)
set_name(0x8008CEE0, "SetFileInfo__7TextDatPC13CTextFileInfo_addr_8008CEE0", SN_NOWARN)
set_name(0x8008CEE8, "GetPal__7TextDati_addr_8008CEE8", SN_NOWARN)
set_name(0x8008CF04, "GetFr__7TextDati_addr_8008CF04", SN_NOWARN)
set_name(0x8008CF20, "OVR_IsMemcardOverlayBlank__Fv", SN_NOWARN)
set_name(0x8008CF4C, "OVR_LoadPregame__Fv", SN_NOWARN)
set_name(0x8008CF7C, "OVR_LoadFrontend__Fv", SN_NOWARN)
set_name(0x8008CFAC, "OVR_LoadGame__Fv", SN_NOWARN)
set_name(0x8008CFDC, "OVR_LoadMemcard__Fv", SN_NOWARN)
set_name(0x8008D008, "ClearOutOverlays__Fv", SN_NOWARN)
set_name(0x8008D050, "ClearOut__7Overlay", SN_NOWARN)
set_name(0x8008D114, "Load__7Overlay", SN_NOWARN)
set_name(0x8008D184, "_GLOBAL__I_OVR_Open__Fv", SN_NOWARN)
set_name(0x8008D260, "StevesDummyPoll__Fv", SN_NOWARN)
set_name(0x8008D268, "Lambo__Fv", SN_NOWARN)
set_name(0x8008D270, "__7CPlayerbi", SN_NOWARN)
set_name(0x8008D354, "___7CPlayer", SN_NOWARN)
set_name(0x8008D3AC, "Load__7CPlayeri", SN_NOWARN)
set_name(0x8008D404, "SetBlockXY__7CPlayerR7CBlocksR12PlayerStruct", SN_NOWARN)
set_name(0x8008D550, "SetScrollTarget__7CPlayerR12PlayerStructR7CBlocks", SN_NOWARN)
set_name(0x8008D97C, "GetNumOfSpellAnims__FR12PlayerStruct", SN_NOWARN)
set_name(0x8008D9FC, "Print__7CPlayerR12PlayerStructR7CBlocks", SN_NOWARN)
set_name(0x8008DE4C, "SetpNscrnxy__7CPlayeriiii", SN_NOWARN)
set_name(0x8008DEB4, "FindAction__7CPlayerR12PlayerStruct", SN_NOWARN)
set_name(0x8008DF30, "FindActionEnum__7CPlayerR12PlayerStruct", SN_NOWARN)
set_name(0x8008DF98, "Init__7CPlayer", SN_NOWARN)
set_name(0x8008DFA0, "Dump__7CPlayer", SN_NOWARN)
set_name(0x8008DFA8, "PRIM_GetPrim__FPP8POLY_FT4_addr_8008DFA8", SN_NOWARN)
set_name(0x8008E024, "PRIM_GetCopy__FP8POLY_FT4_addr_8008E024", SN_NOWARN)
set_name(0x8008E060, "PRIM_CopyPrim__FP8POLY_FT4T0_addr_8008E060", SN_NOWARN)
set_name(0x8008E088, "GetPlrOt__7CBlocksi", SN_NOWARN)
set_name(0x8008E09C, "SetDecompArea__7TextDatiiii", SN_NOWARN)
set_name(0x8008E0B4, "GetNumOfFrames__7TextDatii_addr_8008E0B4", SN_NOWARN)
set_name(0x8008E0EC, "GetNumOfActions__7TextDati", SN_NOWARN)
set_name(0x8008E110, "GetCreature__7TextDati_addr_8008E110", SN_NOWARN)
set_name(0x8008E188, "GetNumOfCreatures__7TextDat_addr_8008E188", SN_NOWARN)
set_name(0x8008E19C, "SetFileInfo__7TextDatPC13CTextFileInfo_addr_8008E19C", SN_NOWARN)
set_name(0x8008E1A4, "PROF_Open__Fv", SN_NOWARN)
set_name(0x8008E1E4, "PROF_State__Fv", SN_NOWARN)
set_name(0x8008E1F0, "PROF_On__Fv", SN_NOWARN)
set_name(0x8008E200, "PROF_Off__Fv", SN_NOWARN)
set_name(0x8008E20C, "PROF_CpuEnd__Fv", SN_NOWARN)
set_name(0x8008E23C, "PROF_CpuStart__Fv", SN_NOWARN)
set_name(0x8008E260, "PROF_DrawStart__Fv", SN_NOWARN)
set_name(0x8008E284, "PROF_DrawEnd__Fv", SN_NOWARN)
set_name(0x8008E2B4, "PROF_Draw__FPUl", SN_NOWARN)
set_name(0x8008E4A8, "PROF_Restart__Fv", SN_NOWARN)
set_name(0x8008E4C8, "PSX_WndProc__FUilUl", SN_NOWARN)
set_name(0x8008E578, "PSX_PostWndProc__FUilUl", SN_NOWARN)
set_name(0x8008E618, "GoBackLevel__Fv", SN_NOWARN)
set_name(0x8008E690, "GoWarpLevel__Fv", SN_NOWARN)
set_name(0x8008E6C8, "PostLoadGame__Fv", SN_NOWARN)
set_name(0x8008E764, "GoLoadGame__Fv", SN_NOWARN)
set_name(0x8008E7EC, "PostGoBackLevel__Fv", SN_NOWARN)
set_name(0x8008E884, "GoForwardLevel__Fv", SN_NOWARN)
set_name(0x8008E8DC, "PostGoForwardLevel__Fv", SN_NOWARN)
set_name(0x8008E974, "GoNewGame__Fv", SN_NOWARN)
set_name(0x8008E9C4, "PostNewGame__Fv", SN_NOWARN)
set_name(0x8008E9FC, "LevelToLevelInit__Fv", SN_NOWARN)
set_name(0x8008EA54, "GetPal__6GPaneli", SN_NOWARN)
set_name(0x8008EA98, "__6GPaneli", SN_NOWARN)
set_name(0x8008EAF0, "DrawFlask__6GPanelP7PanelXYP12PlayerStruct", SN_NOWARN)
set_name(0x8008EF64, "DrawSpeedBar__6GPanelP7PanelXYP12PlayerStruct", SN_NOWARN)
set_name(0x8008F3E8, "DrawSpell__6GPanelP7PanelXYP12PlayerStruct", SN_NOWARN)
set_name(0x8008F548, "DrawMsgWindow__6GPanelP7PanelXYP12PlayerStruct", SN_NOWARN)
set_name(0x8008F594, "DrawDurThingy__6GPaneliiP10ItemStructi", SN_NOWARN)
set_name(0x8008F950, "DrawDurIcon__6GPanelP7PanelXYP12PlayerStruct", SN_NOWARN)
set_name(0x8008FA44, "Print__6GPanelP7PanelXYP12PlayerStruct", SN_NOWARN)
set_name(0x8008FB48, "GetPal__7TextDati_addr_8008FB48", SN_NOWARN)
set_name(0x8008FB64, "GetFr__7TextDati_addr_8008FB64", SN_NOWARN)
set_name(0x8008FB80, "STR_Debug__FP6SFXHDRPce", SN_NOWARN)
set_name(0x8008FB94, "STR_SystemTask__FP4TASK", SN_NOWARN)
set_name(0x8008FBD4, "STR_AllocBuffer__Fv", SN_NOWARN)
set_name(0x8008FC60, "STR_Init__Fv", SN_NOWARN)
set_name(0x8008FD28, "STR_InitStream__Fv", SN_NOWARN)
set_name(0x8008FE60, "STR_PlaySound__FUscic", SN_NOWARN)
set_name(0x8008FF9C, "STR_setvolume__FP6SFXHDR", SN_NOWARN)
set_name(0x8008FFF4, "STR_PlaySFX__FP6SFXHDR", SN_NOWARN)
set_name(0x80090100, "STR_pauseall__Fv", SN_NOWARN)
set_name(0x80090150, "STR_resumeall__Fv", SN_NOWARN)
set_name(0x800901A0, "STR_CloseStream__FP6SFXHDR", SN_NOWARN)
set_name(0x8009020C, "STR_SoundCommand__FP6SFXHDRi", SN_NOWARN)
set_name(0x80090318, "STR_Command__FP6SFXHDR", SN_NOWARN)
set_name(0x80090438, "STR_DMAControl__FP6SFXHDR", SN_NOWARN)
set_name(0x80090500, "STR_PlayStream__FP6SFXHDRPUci", SN_NOWARN)
set_name(0x800906DC, "STR_AsyncWeeTASK__FP4TASK", SN_NOWARN)
set_name(0x800909D4, "STR_AsyncTASK__FP4TASK", SN_NOWARN)
set_name(0x80090E00, "STR_StreamMainTask__FP6SFXHDRc", SN_NOWARN)
set_name(0x80090F10, "SPU_Init__Fv", SN_NOWARN)
set_name(0x80090FE0, "SND_FindChannel__Fv", SN_NOWARN)
set_name(0x8009104C, "SND_ClearBank__Fv", SN_NOWARN)
set_name(0x800910C4, "SndLoadCallBack__FPUciib", SN_NOWARN)
set_name(0x8009113C, "SND_LoadBank__Fi", SN_NOWARN)
set_name(0x80091270, "SND_FindSFX__FUs", SN_NOWARN)
set_name(0x800912C4, "SND_StopSnd__Fi", SN_NOWARN)
set_name(0x800912E8, "SND_RemapSnd__Fi", SN_NOWARN)
set_name(0x8009134C, "SND_PlaySnd__FUsiii", SN_NOWARN)
set_name(0x80091500, "AS_CallBack0__Fi", SN_NOWARN)
set_name(0x80091514, "AS_CallBack1__Fi", SN_NOWARN)
set_name(0x80091528, "AS_WasLastBlock__FiP6STRHDRP6SFXHDR", SN_NOWARN)
set_name(0x80091604, "AS_OpenStream__FP6STRHDRP6SFXHDR", SN_NOWARN)
set_name(0x800916A4, "AS_GetBlock__FP6SFXHDR", SN_NOWARN)
set_name(0x800916B0, "AS_CloseStream__FP6STRHDRP6SFXHDR", SN_NOWARN)
set_name(0x800916DC, "AS_LoopStream__FiP6STRHDRP6SFXHDR", SN_NOWARN)
set_name(0x800917FC, "SCR_NeedHighlightPal__FUsUsi", SN_NOWARN)
set_name(0x80091830, "Init__13PalCollectionPC7InitPos", SN_NOWARN)
set_name(0x800918C0, "FindPal__13PalCollectionUsUsi", SN_NOWARN)
set_name(0x8009199C, "NewPal__13PalCollectionUsUsi", SN_NOWARN)
set_name(0x80091A1C, "MakePal__8PalEntryUsUsi", SN_NOWARN)
set_name(0x80091ABC, "GetHighlightPal__13PalCollectionUsUsi", SN_NOWARN)
set_name(0x80091B50, "UpdatePals__13PalCollection", SN_NOWARN)
set_name(0x80091BC4, "SCR_Handler__Fv", SN_NOWARN)
set_name(0x80091BEC, "GetNumOfObjs__t10Collection2Z8PalEntryi16", SN_NOWARN)
set_name(0x80091BF4, "GetObj__t10Collection2Z8PalEntryi16", SN_NOWARN)
set_name(0x80091C30, "Init__t10Collection2Z8PalEntryi16", SN_NOWARN)
set_name(0x80091C94, "MoveFromUsedToUnused__t10Collection2Z8PalEntryi16P8PalEntry", SN_NOWARN)
set_name(0x80091CEC, "MoveFromUnusedToUsed__t10Collection2Z8PalEntryi16P8PalEntry", SN_NOWARN)
set_name(0x80091D44, "Set__8PalEntryUsUsi", SN_NOWARN)
set_name(0x80091D58, "Set__8PalEntryRC7InitPos", SN_NOWARN)
set_name(0x80091D84, "SetJustUsed__8PalEntryb", SN_NOWARN)
set_name(0x80091D8C, "Init__8PalEntry", SN_NOWARN)
set_name(0x80091D94, "GetClut__C8PalEntry", SN_NOWARN)
set_name(0x80091DA0, "IsEqual__C8PalEntryUsUsi", SN_NOWARN)
set_name(0x80091DD8, "GetNext__Ct11TLinkedList1Z8PalEntry", SN_NOWARN)
set_name(0x80091DE4, "AddToList__t11TLinkedList1Z8PalEntryPP8PalEntry", SN_NOWARN)
set_name(0x80091E04, "DetachFromList__t11TLinkedList1Z8PalEntryPP8PalEntry", SN_NOWARN)
set_name(0x80091E50, "stub__FPcPv_addr_80091E50", SN_NOWARN)
set_name(0x80091E58, "new_eprint__FPcT0i", SN_NOWARN)
set_name(0x80091E8C, "TonysGameTask__FP4TASK", SN_NOWARN)
set_name(0x80091F14, "print_demo_task__FP4TASK", SN_NOWARN)
set_name(0x80092044, "TonysDummyPoll__Fv", SN_NOWARN)
set_name(0x8009204C, "load_demo_pad_data__FUl", SN_NOWARN)
set_name(0x8009209C, "save_demo_pad_data__FUl", SN_NOWARN)
set_name(0x800920EC, "set_pad_record_play__Fi", SN_NOWARN)
set_name(0x80092164, "demo_game_task__FP4TASK", SN_NOWARN)
set_name(0x8009219C, "start_demo__Fv", SN_NOWARN)
set_name(0x800921F0, "tony__Fv", SN_NOWARN)
set_name(0x80092244, "GLUE_SetMonsterList__Fi", SN_NOWARN)
set_name(0x80092250, "GLUE_GetMonsterList__Fv", SN_NOWARN)
set_name(0x8009225C, "GLUE_SuspendGame__Fv", SN_NOWARN)
set_name(0x800922B0, "GLUE_ResumeGame__Fv", SN_NOWARN)
set_name(0x80092304, "GLUE_PreTown__Fv", SN_NOWARN)
set_name(0x80092368, "GLUE_Finished__Fv", SN_NOWARN)
set_name(0x80092374, "GLUE_SetFinished__Fb", SN_NOWARN)
set_name(0x80092380, "GLUE_StartBg__Fibi", SN_NOWARN)
set_name(0x80092404, "GLUE_SetShowGameScreenFlag__Fb", SN_NOWARN)
set_name(0x80092414, "GLUE_SetHomingScrollFlag__Fb", SN_NOWARN)
set_name(0x80092424, "GLUE_SetShowPanelFlag__Fb", SN_NOWARN)
set_name(0x80092434, "DoShowPanelGFX__FP6GPanelT0", SN_NOWARN)
set_name(0x8009250C, "BgTask__FP4TASK", SN_NOWARN)
set_name(0x800929C4, "FindPlayerChar__FPc", SN_NOWARN)
set_name(0x80092A4C, "FindPlayerChar__Fiii", SN_NOWARN)
set_name(0x80092AA8, "FindPlayerChar__FP12PlayerStruct", SN_NOWARN)
set_name(0x80092AD8, "FindPlayerChar__FP12PlayerStructb", SN_NOWARN)
set_name(0x80092B18, "MakeSurePlayerDressedProperly__FR7CPlayerR12PlayerStructb", SN_NOWARN)
set_name(0x80092B6C, "GLUE_GetCurrentList__Fi", SN_NOWARN)
set_name(0x80092C18, "GetTexId__7CPlayer", SN_NOWARN)
set_name(0x80092C24, "SetTown__7CBlocksb", SN_NOWARN)
set_name(0x80092C2C, "MoveToScrollTarget__7CBlocks", SN_NOWARN)
set_name(0x80092C40, "get_action_str__Fii", SN_NOWARN)
set_name(0x80092CC0, "get_key_pad__Fi", SN_NOWARN)
set_name(0x80092CFC, "RemoveCtrlScreen__Fv", SN_NOWARN)
set_name(0x80092D44, "Init_ctrl_pos__Fv", SN_NOWARN)
set_name(0x80093348, "remove_padval__Fi", SN_NOWARN)
set_name(0x80093388, "remove_comboval__Fi", SN_NOWARN)
set_name(0x800933C8, "set_buttons__Fii", SN_NOWARN)
set_name(0x80093568, "restore_controller_settings__Fv", SN_NOWARN)
set_name(0x800935B8, "main_ctrl_setup__Fv", SN_NOWARN)
set_name(0x80093848, "PrintCtrlString__FiiUcic", SN_NOWARN)
set_name(0x80093E9C, "DrawCtrlSetup__Fv", SN_NOWARN)
set_name(0x8009429C, "_GLOBAL__D_CtrlBorder", SN_NOWARN)
set_name(0x800942D4, "_GLOBAL__I_CtrlBorder", SN_NOWARN)
set_name(0x8009430C, "GetDown__C4CPad_addr_8009430C", SN_NOWARN)
set_name(0x80094334, "GetCur__C4CPad_addr_80094334", SN_NOWARN)
set_name(0x8009435C, "SetRGB__6DialogUcUcUc_addr_8009435C", SN_NOWARN)
set_name(0x8009437C, "SetBorder__6Dialogi_addr_8009437C", SN_NOWARN)
set_name(0x80094384, "___6Dialog_addr_80094384", SN_NOWARN)
set_name(0x800943AC, "__6Dialog_addr_800943AC", SN_NOWARN)
set_name(0x80094408, "___7CScreen", SN_NOWARN)
set_name(0x80094428, "switchnight__FP4TASK", SN_NOWARN)
set_name(0x80094474, "city_lights__FP4TASK", SN_NOWARN)
set_name(0x80094600, "color_cycle__FP4TASK", SN_NOWARN)
set_name(0x80094730, "DrawFlameLogo__Fv", SN_NOWARN)
set_name(0x8009496C, "TitleScreen__FP7CScreen", SN_NOWARN)
set_name(0x800949BC, "TryCreaturePrint__Fiiiiiii", SN_NOWARN)
set_name(0x80094C20, "TryWater__FiiP8POLY_GT4i", SN_NOWARN)
set_name(0x80094DCC, "nightgfx__FibiP8POLY_GT4i", SN_NOWARN)
set_name(0x80094F94, "PRIM_GetCopy__FP8POLY_FT4_addr_80094F94", SN_NOWARN)
set_name(0x80094FD0, "PRIM_CopyPrim__FP8POLY_FT4T0_addr_80094FD0", SN_NOWARN)
set_name(0x80094FF8, "PRIM_GetPrim__FPP8POLY_FT4_addr_80094FF8", SN_NOWARN)
set_name(0x80095074, "GetNumOfActions__7TextDati_addr_80095074", SN_NOWARN)
set_name(0x80095098, "GetCreature__7TextDati_addr_80095098", SN_NOWARN)
set_name(0x80095110, "GetNumOfCreatures__7TextDat_addr_80095110", SN_NOWARN)
set_name(0x80095124, "DaveLDummyPoll__Fv", SN_NOWARN)
set_name(0x8009512C, "DaveL__Fv", SN_NOWARN)
set_name(0x80095154, "DoReflection__FP8POLY_FT4iii", SN_NOWARN)
set_name(0x80095434, "mteleportfx__Fv", SN_NOWARN)
set_name(0x8009570C, "invistimer__Fv", SN_NOWARN)
set_name(0x800957DC, "setUVparams__FP8POLY_FT4P9FRAME_HDR", SN_NOWARN)
set_name(0x80095864, "drawparticle__Fiiiiii", SN_NOWARN)
set_name(0x80095A54, "drawpolyF4__Fiiiiii", SN_NOWARN)
set_name(0x80095B88, "drawpolyG4__Fiiiiiiii", SN_NOWARN)
set_name(0x80095D58, "particlejump__Fv", SN_NOWARN)
set_name(0x80095EF8, "particleglow__Fv", SN_NOWARN)
set_name(0x80095FDC, "doparticlejump__Fv", SN_NOWARN)
set_name(0x8009601C, "StartPartJump__Fiiiiii", SN_NOWARN)
set_name(0x80096184, "doparticlechain__Fiiiiiiiiiiii", SN_NOWARN)
set_name(0x8009657C, "Teleportfx__Fiiiiiii", SN_NOWARN)
set_name(0x80096824, "ResurrectFX__Fiiii", SN_NOWARN)
set_name(0x80096A48, "healFX__Fv", SN_NOWARN)
set_name(0x80096ADC, "ParticleMissile__FP13MissileStructiiii", SN_NOWARN)
set_name(0x80096B9C, "HealStart__Fi", SN_NOWARN)
set_name(0x80096BB8, "HealotherStart__Fi", SN_NOWARN)
set_name(0x80096BD8, "TeleStart__Fi", SN_NOWARN)
set_name(0x80096C20, "PhaseStart__Fi", SN_NOWARN)
set_name(0x80096C50, "InvisStart__Fi", SN_NOWARN)
set_name(0x80096C80, "PhaseEnd__Fi", SN_NOWARN)
set_name(0x80096CA8, "ApocaStart__Fi", SN_NOWARN)
set_name(0x80096DD0, "doapocaFX__Fv", SN_NOWARN)
set_name(0x80097004, "DaveLTask__FP4TASK", SN_NOWARN)
set_name(0x80097068, "PRIM_GetPrim__FPP7POLY_G4", SN_NOWARN)
set_name(0x800970E4, "PRIM_GetPrim__FPP7POLY_F4", SN_NOWARN)
set_name(0x80097160, "PRIM_GetPrim__FPP8POLY_FT4_addr_80097160", SN_NOWARN)
set_name(0x800971DC, "GetFr__7TextDati_addr_800971DC", SN_NOWARN)
set_name(0x800971F8, "DrawArrow__Fii", SN_NOWARN)
set_name(0x80097640, "show_spell_dir__Fi", SN_NOWARN)
set_name(0x80097A34, "release_spell__Fi", SN_NOWARN)
set_name(0x80097A98, "select_belt_item__Fi", SN_NOWARN)
set_name(0x80097AA0, "any_belt_items__Fv", SN_NOWARN)
set_name(0x80097B08, "get_last_inv__Fv", SN_NOWARN)
set_name(0x80097C3C, "get_next_inv__Fv", SN_NOWARN)
set_name(0x80097D78, "pad_func_up__Fi", SN_NOWARN)
set_name(0x80097DA4, "pad_func_down__Fi", SN_NOWARN)
set_name(0x80097DD0, "pad_func_left__Fi", SN_NOWARN)
set_name(0x80097DD8, "pad_func_right__Fi", SN_NOWARN)
set_name(0x80097DE0, "pad_func_select__Fi", SN_NOWARN)
set_name(0x80097ED0, "pad_func_Attack__Fi", SN_NOWARN)
set_name(0x80098258, "pad_func_Action__Fi", SN_NOWARN)
set_name(0x80098524, "InitTargetCursor__Fi", SN_NOWARN)
set_name(0x800986F0, "RemoveTargetCursor__Fi", SN_NOWARN)
set_name(0x8009878C, "pad_func_Cast_Spell__Fi", SN_NOWARN)
set_name(0x80098E58, "pad_func_Use_Item__Fi", SN_NOWARN)
set_name(0x80098F4C, "pad_func_Chr__Fi", SN_NOWARN)
set_name(0x80099088, "pad_func_Inv__Fi", SN_NOWARN)
set_name(0x800991A8, "pad_func_SplBook__Fi", SN_NOWARN)
set_name(0x800992C0, "pad_func_QLog__Fi", SN_NOWARN)
set_name(0x8009936C, "pad_func_SpellBook__Fi", SN_NOWARN)
set_name(0x80099424, "pad_func_AutoMap__Fi", SN_NOWARN)
set_name(0x8009953C, "pad_func_Quick_Spell__Fi", SN_NOWARN)
set_name(0x800995B8, "check_inv__FiPci", SN_NOWARN)
set_name(0x80099790, "pad_func_Quick_Use_Health__Fi", SN_NOWARN)
set_name(0x800997B8, "pad_func_Quick_Use_Mana__Fi", SN_NOWARN)
set_name(0x800997E0, "get_max_find_size__FPici", SN_NOWARN)
set_name(0x80099920, "sort_gold__Fi", SN_NOWARN)
set_name(0x80099A28, "DrawObjSelector__Fi", SN_NOWARN)
set_name(0x8009A288, "DrawObjTask__FP4TASK", SN_NOWARN)
set_name(0x8009A364, "add_area_find_object__Fciii", SN_NOWARN)
set_name(0x8009A470, "CheckRangeObject__Fiici", SN_NOWARN)
set_name(0x8009A848, "CheckArea__FiiicUci", SN_NOWARN)
set_name(0x8009AA9C, "PlacePlayer__FiiiUc", SN_NOWARN)
set_name(0x8009ACF8, "_GLOBAL__D_gplayer", SN_NOWARN)
set_name(0x8009AD20, "_GLOBAL__I_gplayer", SN_NOWARN)
set_name(0x8009AD48, "SetRGB__6DialogUcUcUc_addr_8009AD48", SN_NOWARN)
set_name(0x8009AD68, "SetBack__6Dialogi_addr_8009AD68", SN_NOWARN)
set_name(0x8009AD70, "SetBorder__6Dialogi_addr_8009AD70", SN_NOWARN)
set_name(0x8009AD78, "___6Dialog_addr_8009AD78", SN_NOWARN)
set_name(0x8009ADA0, "__6Dialog_addr_8009ADA0", SN_NOWARN)
set_name(0x8009ADFC, "MoveToScrollTarget__7CBlocks_addr_8009ADFC", SN_NOWARN)
set_name(0x8009AE10, "GetDown__C4CPad_addr_8009AE10", SN_NOWARN)
set_name(0x8009AE38, "GetCur__C4CPad_addr_8009AE38", SN_NOWARN)
set_name(0x8009AE60, "DEC_AddAsDecRequestor__FP7TextDat", SN_NOWARN)
set_name(0x8009AEDC, "DEC_RemoveAsDecRequestor__FP7TextDat", SN_NOWARN)
set_name(0x8009AF34, "DEC_DoDecompRequests__Fv", SN_NOWARN)
set_name(0x8009AF90, "FindThisTd__FP7TextDat", SN_NOWARN)
set_name(0x8009AFC8, "FindEmptyIndex__Fv", SN_NOWARN)
set_name(0x8009B000, "UPDATEPROGRESS__Fi", SN_NOWARN)
set_name(0x8009B060, "IsGameLoading__Fv", SN_NOWARN)
set_name(0x8009B06C, "PutUpCutScreenTSK__FP4TASK", SN_NOWARN)
set_name(0x8009B4C0, "PutUpCutScreen__Fi", SN_NOWARN)
set_name(0x8009B570, "TakeDownCutScreen__Fv", SN_NOWARN)
set_name(0x8009B5B8, "FinishProgress__Fv", SN_NOWARN)
set_name(0x8009B600, "PRIM_GetPrim__FPP7POLY_G4_addr_8009B600", SN_NOWARN)
set_name(0x8009B67C, "_GLOBAL__D_UPDATEPROGRESS__Fi", SN_NOWARN)
set_name(0x8009B6B4, "_GLOBAL__I_UPDATEPROGRESS__Fi", SN_NOWARN)
set_name(0x8009B6EC, "SetRGB__6DialogUcUcUc_addr_8009B6EC", SN_NOWARN)
set_name(0x8009B70C, "SetBack__6Dialogi_addr_8009B70C", SN_NOWARN)
set_name(0x8009B714, "SetBorder__6Dialogi_addr_8009B714", SN_NOWARN)
set_name(0x8009B71C, "___6Dialog_addr_8009B71C", SN_NOWARN)
set_name(0x8009B744, "__6Dialog_addr_8009B744", SN_NOWARN)
set_name(0x8009B7A0, "___7CScreen_addr_8009B7A0", SN_NOWARN)
set_name(0x8009B7C0, "init_mem_card__FPFii_v", SN_NOWARN)
set_name(0x8009B9DC, "memcard_event__Fii", SN_NOWARN)
set_name(0x8009B9E8, "init_card__Fi", SN_NOWARN)
set_name(0x8009BA1C, "ping_card__Fi", SN_NOWARN)
set_name(0x8009BAB0, "CardUpdateTask__FP4TASK", SN_NOWARN)
set_name(0x8009BAE8, "MemcardON__Fv", SN_NOWARN)
set_name(0x8009BB50, "MemcardOFF__Fv", SN_NOWARN)
set_name(0x8009BBC0, "DrawDialogBox__FiiP4RECTiiii", SN_NOWARN)
set_name(0x8009BCA4, "DrawSpinner__FiiUcUcUciiibiT8", SN_NOWARN)
set_name(0x8009C1A4, "DrawMenu__Fi", SN_NOWARN)
set_name(0x8009CBA8, "ShowCharacterFiles__Fv", SN_NOWARN)
set_name(0x8009D0C0, "MemcardPad__Fv", SN_NOWARN)
set_name(0x8009D738, "SoundPad__Fv", SN_NOWARN)
set_name(0x8009DD0C, "CentrePad__Fv", SN_NOWARN)
set_name(0x8009E288, "CalcVolumes__Fv", SN_NOWARN)
set_name(0x8009E3C8, "GetVolumes__Fv", SN_NOWARN)
set_name(0x8009E4D0, "DrawOptions__FP4TASK", SN_NOWARN)
set_name(0x8009E85C, "ToggleOptions__Fv", SN_NOWARN)
set_name(0x8009E8FC, "FormatPad__Fv", SN_NOWARN)
set_name(0x8009EC08, "_GLOBAL__I_cmenu", SN_NOWARN)
set_name(0x8009F02C, "PRIM_GetPrim__FPP7POLY_G4_addr_8009F02C", SN_NOWARN)
set_name(0x8009F0A8, "GetTick__C4CPad", SN_NOWARN)
set_name(0x8009F0D0, "GetDown__C4CPad_addr_8009F0D0", SN_NOWARN)
set_name(0x8009F0F8, "GetUp__C4CPad_addr_8009F0F8", SN_NOWARN)
set_name(0x8009F120, "GetCur__C4CPad_addr_8009F120", SN_NOWARN)
set_name(0x8009F148, "SetPadTickMask__4CPadUs", SN_NOWARN)
set_name(0x8009F150, "SetPadTick__4CPadUs", SN_NOWARN)
set_name(0x8009F158, "SetRGB__6DialogUcUcUc_addr_8009F158", SN_NOWARN)
set_name(0x8009F178, "SetBack__6Dialogi_addr_8009F178", SN_NOWARN)
set_name(0x8009F180, "SetBorder__6Dialogi_addr_8009F180", SN_NOWARN)
set_name(0x8009F188, "___6Dialog_addr_8009F188", SN_NOWARN)
set_name(0x8009F1B0, "__6Dialog_addr_8009F1B0", SN_NOWARN)
set_name(0x8009F20C, "GetFr__7TextDati_addr_8009F20C", SN_NOWARN)
set_name(0x8009F228, "BirdDistanceOK__Fiiii", SN_NOWARN)
set_name(0x8009F280, "AlterBirdPos__FP10BIRDSTRUCTUc", SN_NOWARN)
set_name(0x8009F3C4, "BirdWorld__FP10BIRDSTRUCTii", SN_NOWARN)
set_name(0x8009F440, "BirdScared__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009F520, "GetPerch__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009F574, "BIRD_StartHop__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009F5D0, "BIRD_DoHop__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009F6B0, "BIRD_StartPerch__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009F6EC, "BIRD_DoPerch__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009F770, "BIRD_DoScatter__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009F814, "BIRD_StartFly__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009F95C, "BIRD_DoFly__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009FB88, "BIRD_StartLanding__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009FB94, "BIRD_DoLanding__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009FBE4, "PlaceFlock__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009FCD0, "ProcessFlock__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x8009FD84, "LBirdTask__FP4TASK", SN_NOWARN)
set_name(0x8009FDDC, "InitBird__Fv", SN_NOWARN)
set_name(0x8009FECC, "ProcessBird__Fv", SN_NOWARN)
set_name(0x800A0024, "GetBirdFrame__FP10BIRDSTRUCT", SN_NOWARN)
set_name(0x800A007C, "doshadow__FP10BIRDSTRUCTii", SN_NOWARN)
set_name(0x800A0154, "DrawLBird__Fv", SN_NOWARN)
set_name(0x800A034C, "PRIM_GetPrim__FPP8POLY_FT4_addr_800A034C", SN_NOWARN)
set_name(0x8002F644, "TrimCol__Fs_addr_8002F644", SN_NOWARN)
set_name(0x8002F67C, "DrawSpellCel__FllUclUc", SN_NOWARN)
set_name(0x80030198, "SetSpellTrans__Fc", SN_NOWARN)
set_name(0x800301A4, "DrawSpellBookTSK__FP4TASK", SN_NOWARN)
set_name(0x8003023C, "DrawSpeedSpellTSK__FP4TASK", SN_NOWARN)
set_name(0x800302B4, "ToggleSpell__Fi", SN_NOWARN)
set_name(0x80030368, "DrawSpellList__Fv", SN_NOWARN)
set_name(0x800310F0, "SetSpell__Fi", SN_NOWARN)
set_name(0x800311C4, "AddPanelString__FPCci", SN_NOWARN)
set_name(0x80031274, "ClearPanel__Fv", SN_NOWARN)
set_name(0x800312A4, "InitPanelStr__Fv", SN_NOWARN)
set_name(0x800312C4, "InitControlPan__Fv", SN_NOWARN)
set_name(0x8003150C, "DrawCtrlPan__Fv", SN_NOWARN)
set_name(0x80031538, "DoAutoMap__Fv", SN_NOWARN)
set_name(0x800315AC, "CheckPanelInfo__Fv", SN_NOWARN)
set_name(0x80031E70, "FreeControlPan__Fv", SN_NOWARN)
set_name(0x80031F80, "CPrintString__FiPci", SN_NOWARN)
set_name(0x8003209C, "PrintInfo__Fv", SN_NOWARN)
set_name(0x800322D8, "DrawInfoBox__FP4RECT", SN_NOWARN)
set_name(0x80032A48, "MY_PlrStringXY__Fv", SN_NOWARN)
set_name(0x80032F94, "ADD_PlrStringXY__FPCcc", SN_NOWARN)
set_name(0x8003303C, "DrawPlus__Fii", SN_NOWARN)
set_name(0x800331A4, "ChrCheckValidButton__Fi", SN_NOWARN)
set_name(0x80033270, "DrawArrows__Fv", SN_NOWARN)
set_name(0x80033368, "BuildChr__Fv", SN_NOWARN)
set_name(0x80034640, "DrawChr__Fv", SN_NOWARN)
set_name(0x80034AE4, "DrawChrTSK__FP4TASK", SN_NOWARN)
set_name(0x80034B84, "DrawLevelUpIcon__Fi", SN_NOWARN)
set_name(0x80034C18, "CheckChrBtns__Fv", SN_NOWARN)
set_name(0x80034E5C, "DrawDurIcon4Item__FPC10ItemStructii", SN_NOWARN)
set_name(0x80034EE0, "RedBack__Fv", SN_NOWARN)
set_name(0x80034FC8, "PrintSBookStr__FiiUcPCcUc", SN_NOWARN)
set_name(0x80035060, "GetSBookTrans__FiUc", SN_NOWARN)
set_name(0x80035278, "DrawSpellBook__Fv", SN_NOWARN)
set_name(0x80035BD8, "CheckSBook__Fv", SN_NOWARN)
set_name(0x80035E3C, "get_pieces_str__Fi", SN_NOWARN)
set_name(0x80035E70, "_GLOBAL__D_fontkern", SN_NOWARN)
set_name(0x80035E98, "_GLOBAL__I_fontkern", SN_NOWARN)
set_name(0x80035ED4, "GetDown__C4CPad_addr_80035ED4", SN_NOWARN)
set_name(0x80035EFC, "SetRGB__6DialogUcUcUc_addr_80035EFC", SN_NOWARN)
set_name(0x80035F1C, "SetBack__6Dialogi_addr_80035F1C", SN_NOWARN)
set_name(0x80035F24, "SetBorder__6Dialogi_addr_80035F24", SN_NOWARN)
set_name(0x80035F2C, "___6Dialog_addr_80035F2C", SN_NOWARN)
set_name(0x80035F54, "__6Dialog_addr_80035F54", SN_NOWARN)
set_name(0x80035FB0, "GetPal__7TextDati_addr_80035FB0", SN_NOWARN)
set_name(0x80035FCC, "GetFr__7TextDati_addr_80035FCC", SN_NOWARN)
set_name(0x80035FE8, "InitCursor__Fv", SN_NOWARN)
set_name(0x80035FF0, "FreeCursor__Fv", SN_NOWARN)
set_name(0x80035FF8, "SetICursor__Fi", SN_NOWARN)
set_name(0x80036054, "SetCursor__Fi", SN_NOWARN)
set_name(0x800360B8, "NewCursor__Fi", SN_NOWARN)
set_name(0x800360D8, "InitLevelCursor__Fv", SN_NOWARN)
set_name(0x80036138, "CheckTown__Fv", SN_NOWARN)
set_name(0x80036390, "CheckRportal__Fv", SN_NOWARN)
set_name(0x800365B8, "CheckCursMove__Fv", SN_NOWARN)
set_name(0x800365C0, "InitDead__Fv", SN_NOWARN)
set_name(0x800367E4, "AddDead__Fiici", SN_NOWARN)
set_name(0x8003682C, "FreeGameMem__Fv", SN_NOWARN)
set_name(0x8003687C, "start_game__FUi", SN_NOWARN)
set_name(0x800368F8, "free_game__Fv", SN_NOWARN)
set_name(0x8003696C, "LittleStart__FUcUc", SN_NOWARN)
set_name(0x80036A30, "StartGame__FUcUc", SN_NOWARN)
set_name(0x80036BBC, "run_game_loop__FUi", SN_NOWARN)
set_name(0x80036D3C, "TryIconCurs__Fv", SN_NOWARN)
set_name(0x80037118, "DisableInputWndProc__FUlUilUl", SN_NOWARN)
set_name(0x80037120, "GM_Game__FUlUilUl", SN_NOWARN)
set_name(0x800371D0, "LoadLvlGFX__Fv", SN_NOWARN)
set_name(0x80037294, "LoadAllGFX__Fv", SN_NOWARN)
set_name(0x800372B4, "CreateLevel__Fi", SN_NOWARN)
set_name(0x800373AC, "LoCreateLevel__FPv", SN_NOWARN)
set_name(0x80037578, "ClearOutDungeonMap__Fv", SN_NOWARN)
set_name(0x80037654, "LoadGameLevel__FUci", SN_NOWARN)
set_name(0x80037F94, "game_logic__Fv", SN_NOWARN)
set_name(0x800380A0, "timeout_cursor__FUc", SN_NOWARN)
set_name(0x80038148, "game_loop__FUc", SN_NOWARN)
set_name(0x80038180, "alloc_plr__Fv", SN_NOWARN)
set_name(0x80038188, "plr_encrypt__FUc", SN_NOWARN)
set_name(0x80038190, "assert_fail__FiPCcT1", SN_NOWARN)
set_name(0x800381B0, "assert_fail__FiPCc", SN_NOWARN)
set_name(0x800381D0, "app_fatal", SN_NOWARN)
set_name(0x80038200, "DoMemCardFromFrontEnd__Fv", SN_NOWARN)
set_name(0x80038228, "DoMemCardFromInGame__Fv", SN_NOWARN)
set_name(0x80038250, "GetActiveTowner__Fi", SN_NOWARN)
set_name(0x800382A4, "SetTownerGPtrs__FPUcPPUc", SN_NOWARN)
set_name(0x800382C4, "NewTownerAnim__FiPUcii", SN_NOWARN)
set_name(0x8003830C, "InitTownerInfo__FilUciiici", SN_NOWARN)
set_name(0x8003846C, "InitQstSnds__Fi", SN_NOWARN)
set_name(0x80038524, "InitSmith__Fv", SN_NOWARN)
set_name(0x80038688, "InitBarOwner__Fv", SN_NOWARN)
set_name(0x800387F4, "InitTownDead__Fv", SN_NOWARN)
set_name(0x8003895C, "InitWitch__Fv", SN_NOWARN)
set_name(0x80038AC4, "InitBarmaid__Fv", SN_NOWARN)
set_name(0x80038C2C, "InitBoy__Fv", SN_NOWARN)
set_name(0x80038D9C, "InitHealer__Fv", SN_NOWARN)
set_name(0x80038F04, "InitTeller__Fv", SN_NOWARN)
set_name(0x8003906C, "InitDrunk__Fv", SN_NOWARN)
set_name(0x800391D4, "InitCows__Fv", SN_NOWARN)
set_name(0x800394B4, "InitTowners__Fv", SN_NOWARN)
set_name(0x80039540, "FreeTownerGFX__Fv", SN_NOWARN)
set_name(0x800395E4, "TownCtrlMsg__Fi", SN_NOWARN)
set_name(0x80039704, "TownBlackSmith__Fv", SN_NOWARN)
set_name(0x80039738, "TownBarOwner__Fv", SN_NOWARN)
set_name(0x8003976C, "TownDead__Fv", SN_NOWARN)
set_name(0x80039854, "TownHealer__Fv", SN_NOWARN)
set_name(0x8003987C, "TownStory__Fv", SN_NOWARN)
set_name(0x800398A4, "TownDrunk__Fv", SN_NOWARN)
set_name(0x800398CC, "TownBoy__Fv", SN_NOWARN)
set_name(0x800398F4, "TownWitch__Fv", SN_NOWARN)
set_name(0x8003991C, "TownBarMaid__Fv", SN_NOWARN)
set_name(0x80039944, "TownCow__Fv", SN_NOWARN)
set_name(0x8003996C, "ProcessTowners__Fv", SN_NOWARN)
set_name(0x80039BBC, "PlrHasItem__FiiRi", SN_NOWARN)
set_name(0x80039C90, "CowSFX__Fi", SN_NOWARN)
set_name(0x80039DAC, "TownerTalk__Fii", SN_NOWARN)
set_name(0x80039DEC, "TalkToTowner__Fii", SN_NOWARN)
set_name(0x8003B214, "effect_is_playing__Fi", SN_NOWARN)
set_name(0x8003B248, "stream_stop__Fv", SN_NOWARN)
set_name(0x8003B290, "stream_play__FP4TSFXll", SN_NOWARN)
set_name(0x8003B36C, "stream_update__Fv", SN_NOWARN)
set_name(0x8003B374, "sfx_stop__Fv", SN_NOWARN)
set_name(0x8003B390, "InitMonsterSND__Fi", SN_NOWARN)
set_name(0x8003B3E8, "FreeMonsterSnd__Fv", SN_NOWARN)
set_name(0x8003B3F0, "calc_snd_position__FiiPlT2", SN_NOWARN)
set_name(0x8003B4F4, "PlaySFX_priv__FP4TSFXUcii", SN_NOWARN)
set_name(0x8003B604, "PlayEffect__Fii", SN_NOWARN)
set_name(0x8003B730, "RndSFX__Fi", SN_NOWARN)
set_name(0x8003B7C8, "PlaySFX__Fi", SN_NOWARN)
set_name(0x8003B830, "PlaySfxLoc__Fiii", SN_NOWARN)
set_name(0x8003B8B0, "sound_stop__Fv", SN_NOWARN)
set_name(0x8003B948, "sound_update__Fv", SN_NOWARN)
set_name(0x8003B97C, "priv_sound_init__FUc", SN_NOWARN)
set_name(0x8003B9C0, "sound_init__Fv", SN_NOWARN)
set_name(0x8003BA94, "GetDirection__Fiiii", SN_NOWARN)
set_name(0x8003BB38, "SetRndSeed__Fl", SN_NOWARN)
set_name(0x8003BB48, "GetRndSeed__Fv", SN_NOWARN)
set_name(0x8003BB90, "random__Fil", SN_NOWARN)
set_name(0x8003BBFC, "DiabloAllocPtr__FUl", SN_NOWARN)
set_name(0x8003BC48, "mem_free_dbg__FPv", SN_NOWARN)
set_name(0x8003BC98, "LoadFileInMem__FPCcPUl", SN_NOWARN)
set_name(0x8003BCA0, "PlayInGameMovie__FPCc", SN_NOWARN)
set_name(0x8003BCA8, "Enter__9CCritSect", SN_NOWARN)
set_name(0x8003BCB0, "InitDiabloMsg__Fc", SN_NOWARN)
set_name(0x8003BD44, "ClrDiabloMsg__Fv", SN_NOWARN)
set_name(0x8003BD70, "DrawDiabloMsg__Fv", SN_NOWARN)
set_name(0x8003BE7C, "interface_msg_pump__Fv", SN_NOWARN)
set_name(0x8003BE84, "ShowProgress__FUi", SN_NOWARN)
set_name(0x8003C51C, "InitAllItemsUseable__Fv", SN_NOWARN)
set_name(0x8003C554, "InitItemGFX__Fv", SN_NOWARN)
set_name(0x8003C580, "ItemPlace__Fii", SN_NOWARN)
set_name(0x8003C648, "AddInitItems__Fv", SN_NOWARN)
set_name(0x8003C860, "InitItems__Fv", SN_NOWARN)
set_name(0x8003CA20, "CalcPlrItemVals__FiUc", SN_NOWARN)
set_name(0x8003DA44, "CalcPlrScrolls__Fi", SN_NOWARN)
set_name(0x8003DDC4, "CalcPlrStaff__Fi", SN_NOWARN)
set_name(0x8003DEC0, "CalcSelfItems__Fi", SN_NOWARN)
set_name(0x8003E020, "ItemMinStats__FPC12PlayerStructPC10ItemStruct", SN_NOWARN)
set_name(0x8003E06C, "CalcPlrItemMin__Fi", SN_NOWARN)
set_name(0x8003E14C, "CalcPlrBookVals__Fi", SN_NOWARN)
set_name(0x8003E3E0, "CalcPlrInv__FiUc", SN_NOWARN)
set_name(0x8003E478, "SetPlrHandItem__FP10ItemStructi", SN_NOWARN)
set_name(0x8003E590, "GetPlrHandSeed__FP10ItemStruct", SN_NOWARN)
set_name(0x8003E5BC, "GetGoldSeed__FiP10ItemStruct", SN_NOWARN)
set_name(0x8003E738, "SetPlrHandSeed__FP10ItemStructi", SN_NOWARN)
set_name(0x8003E740, "SetPlrHandGoldCurs__FP10ItemStruct", SN_NOWARN)
set_name(0x8003E770, "CreatePlrItems__Fi", SN_NOWARN)
set_name(0x8003EBA8, "ItemSpaceOk__Fii", SN_NOWARN)
set_name(0x8003EE80, "GetItemSpace__Fiic", SN_NOWARN)
set_name(0x8003F0AC, "GetSuperItemSpace__Fiic", SN_NOWARN)
set_name(0x8003F214, "GetSuperItemLoc__FiiRiT2", SN_NOWARN)
set_name(0x8003F2DC, "CalcItemValue__Fi", SN_NOWARN)
set_name(0x8003F394, "GetBookSpell__Fii", SN_NOWARN)
set_name(0x8003F5FC, "GetStaffPower__FiiiUc", SN_NOWARN)
set_name(0x8003F7EC, "GetStaffSpell__FiiUc", SN_NOWARN)
set_name(0x8003FAA0, "GetItemAttrs__Fiii", SN_NOWARN)
set_name(0x8003FFEC, "RndPL__Fii", SN_NOWARN)
set_name(0x80040024, "PLVal__Fiiiii", SN_NOWARN)
set_name(0x80040098, "SaveItemPower__Fiiiiiii", SN_NOWARN)
set_name(0x800416A4, "GetItemPower__FiiilUc", SN_NOWARN)
set_name(0x80041B0C, "GetItemBonus__FiiiiUc", SN_NOWARN)
set_name(0x80041C08, "SetupItem__Fi", SN_NOWARN)
set_name(0x80041D1C, "RndItem__Fi", SN_NOWARN)
set_name(0x80041F60, "RndUItem__Fi", SN_NOWARN)
set_name(0x800421A0, "RndAllItems__Fv", SN_NOWARN)
set_name(0x80042314, "RndTypeItems__Fii", SN_NOWARN)
set_name(0x80042414, "CheckUnique__FiiiUc", SN_NOWARN)
set_name(0x800425C4, "GetUniqueItem__Fii", SN_NOWARN)
set_name(0x8004286C, "SpawnUnique__Fiii", SN_NOWARN)
set_name(0x80042978, "ItemRndDur__Fi", SN_NOWARN)
set_name(0x80042A08, "SetupAllItems__FiiiiiUcUcUc", SN_NOWARN)
set_name(0x80042D14, "SpawnItem__FiiiUc", SN_NOWARN)
set_name(0x80042F5C, "CreateItem__Fiii", SN_NOWARN)
set_name(0x8004308C, "CreateRndItem__FiiUcUcUc", SN_NOWARN)
set_name(0x800431D4, "SetupAllUseful__Fiii", SN_NOWARN)
set_name(0x800432AC, "CreateRndUseful__FiiiUc", SN_NOWARN)
set_name(0x8004336C, "CreateTypeItem__FiiUciiUcUc", SN_NOWARN)
set_name(0x800434B0, "RecreateEar__FiUsiUciiiiii", SN_NOWARN)
set_name(0x8004369C, "SpawnQuestItem__Fiiiii", SN_NOWARN)
set_name(0x800438C8, "SpawnRock__Fv", SN_NOWARN)
set_name(0x80043A88, "RespawnItem__FiUc", SN_NOWARN)
set_name(0x80043C4C, "DeleteItem__Fii", SN_NOWARN)
set_name(0x80043CA0, "ItemDoppel__Fv", SN_NOWARN)
set_name(0x80043D68, "ProcessItems__Fv", SN_NOWARN)
set_name(0x80043EAC, "FreeItemGFX__Fv", SN_NOWARN)
set_name(0x80043EB4, "GetItemStr__Fi", SN_NOWARN)
set_name(0x8004403C, "CheckIdentify__Fii", SN_NOWARN)
set_name(0x8004412C, "RepairItem__FP10ItemStructi", SN_NOWARN)
set_name(0x800441FC, "DoRepair__Fii", SN_NOWARN)
set_name(0x800442C0, "RechargeItem__FP10ItemStructi", SN_NOWARN)
set_name(0x80044330, "DoRecharge__Fii", SN_NOWARN)
set_name(0x80044430, "PrintItemOil__Fc", SN_NOWARN)
set_name(0x80044524, "PrintItemPower__FcPC10ItemStruct", SN_NOWARN)
set_name(0x80044BD0, "PrintItemMisc__FPC10ItemStruct", SN_NOWARN)
set_name(0x80044E5C, "PrintItemDetails__FPC10ItemStruct", SN_NOWARN)
set_name(0x800451C8, "PrintItemDur__FPC10ItemStruct", SN_NOWARN)
set_name(0x800454D8, "CastScroll__Fi", SN_NOWARN)
set_name(0x800454E0, "UseItem__Fiii", SN_NOWARN)
set_name(0x80045ECC, "StoreStatOk__FP10ItemStruct", SN_NOWARN)
set_name(0x80045F60, "PremiumItemOk__Fi", SN_NOWARN)
set_name(0x80045FDC, "RndPremiumItem__Fii", SN_NOWARN)
set_name(0x800460E4, "SpawnOnePremium__Fii", SN_NOWARN)
set_name(0x800462F8, "SpawnPremium__Fi", SN_NOWARN)
set_name(0x8004652C, "WitchBookLevel__Fi", SN_NOWARN)
set_name(0x8004667C, "SpawnStoreGold__Fv", SN_NOWARN)
set_name(0x800466FC, "RecalcStoreStats__Fv", SN_NOWARN)
set_name(0x8004689C, "ItemNoFlippy__Fv", SN_NOWARN)
set_name(0x80046900, "CreateSpellBook__FiiiUcUc", SN_NOWARN)
set_name(0x80046A90, "CreateMagicArmor__FiiiiUcUc", SN_NOWARN)
set_name(0x80046C0C, "CreateMagicWeapon__FiiiiUcUc", SN_NOWARN)
set_name(0x80046D88, "MakeItemStr__FP10ItemStructUs", SN_NOWARN)
set_name(0x80046F88, "veclen2__Fii", SN_NOWARN)
set_name(0x80046FF0, "set_light_bands__Fv", SN_NOWARN)
set_name(0x80047064, "SetLightFX__FiisssUcUcUc", SN_NOWARN)
set_name(0x800470D0, "DoLighting__Fiiii", SN_NOWARN)
set_name(0x80047D80, "DoUnLight__Fv", SN_NOWARN)
set_name(0x80047FC4, "DoUnVision__Fiii", SN_NOWARN)
set_name(0x80048088, "DoVision__FiiiUcUc", SN_NOWARN)
set_name(0x80048598, "FreeLightTable__Fv", SN_NOWARN)
set_name(0x800485A0, "InitLightTable__Fv", SN_NOWARN)
set_name(0x800485A8, "MakeLightTable__Fv", SN_NOWARN)
set_name(0x800485B0, "InitLightMax__Fv", SN_NOWARN)
set_name(0x800485D4, "InitLighting__Fv", SN_NOWARN)
set_name(0x80048618, "AddLight__Fiii", SN_NOWARN)
set_name(0x800486AC, "AddUnLight__Fi", SN_NOWARN)
set_name(0x800486DC, "ChangeLightRadius__Fii", SN_NOWARN)
set_name(0x80048708, "ChangeLightXY__Fiii", SN_NOWARN)
set_name(0x80048740, "light_fix__Fi", SN_NOWARN)
set_name(0x80048748, "ChangeLightOff__Fiii", SN_NOWARN)
set_name(0x80048780, "ChangeLight__Fiiii", SN_NOWARN)
set_name(0x800487C4, "ChangeLightColour__Fii", SN_NOWARN)
set_name(0x800487F4, "ProcessLightList__Fv", SN_NOWARN)
set_name(0x80048920, "SavePreLighting__Fv", SN_NOWARN)
set_name(0x80048928, "InitVision__Fv", SN_NOWARN)
set_name(0x80048978, "AddVision__FiiiUc", SN_NOWARN)
set_name(0x80048A7C, "ChangeVisionRadius__Fii", SN_NOWARN)
set_name(0x80048B30, "ChangeVisionXY__Fiii", SN_NOWARN)
set_name(0x80048BE8, "ProcessVisionList__Fv", SN_NOWARN)
set_name(0x80048E48, "FreeQuestText__Fv", SN_NOWARN)
set_name(0x80048E50, "InitQuestText__Fv", SN_NOWARN)
set_name(0x80048E5C, "CalcTextSpeed__FPCc", SN_NOWARN)
set_name(0x80048F9C, "InitQTextMsg__Fi", SN_NOWARN)
set_name(0x800490C4, "DrawQTextBack__Fv", SN_NOWARN)
set_name(0x80049134, "PrintCDWait__Fv", SN_NOWARN)
set_name(0x800491C0, "DrawQTextTSK__FP4TASK", SN_NOWARN)
set_name(0x8004928C, "DrawQText__Fv", SN_NOWARN)
set_name(0x800495BC, "_GLOBAL__D_QBack", SN_NOWARN)
set_name(0x800495E4, "_GLOBAL__I_QBack", SN_NOWARN)
set_name(0x8004960C, "SetRGB__6DialogUcUcUc_addr_8004960C", SN_NOWARN)
set_name(0x8004962C, "SetBorder__6Dialogi_addr_8004962C", SN_NOWARN)
set_name(0x80049634, "___6Dialog_addr_80049634", SN_NOWARN)
set_name(0x8004965C, "__6Dialog_addr_8004965C", SN_NOWARN)
set_name(0x800496B8, "GetCharWidth__5CFontc_addr_800496B8", SN_NOWARN)
set_name(0x80049710, "GetFr__7TextDati_addr_80049710", SN_NOWARN)
set_name(0x8004972C, "nullmissile__Fiiiiiicii", SN_NOWARN)
set_name(0x80049734, "FuncNULL__FP13MissileStructiii", SN_NOWARN)
set_name(0x8004973C, "run_delta_info__Fv", SN_NOWARN)
set_name(0x80049744, "delta_init__Fv", SN_NOWARN)
set_name(0x800497A4, "delta_kill_monster__FiUcUcUc", SN_NOWARN)
set_name(0x800498D8, "delta_monster_hp__FilUc", SN_NOWARN)
set_name(0x800499A8, "delta_sync_monster__FPC12TSyncMonsterUc", SN_NOWARN)
set_name(0x80049A80, "delta_sync_golem__FPC9TCmdGolemiUc", SN_NOWARN)
set_name(0x80049B64, "delta_leave_sync__FUc", SN_NOWARN)
set_name(0x80049DDC, "delta_sync_object__FiUcUc", SN_NOWARN)
set_name(0x80049E90, "delta_get_item__FPC9TCmdGItemUc", SN_NOWARN)
set_name(0x8004A0D0, "delta_put_item__FPC9TCmdPItemiiUc", SN_NOWARN)
set_name(0x8004A300, "delta_portal_inited__Fi", SN_NOWARN)
set_name(0x8004A360, "delta_quest_inited__Fi", SN_NOWARN)
set_name(0x8004A3C0, "DeltaAddItem__Fi", SN_NOWARN)
set_name(0x8004A634, "DeltaExportData__FPc", SN_NOWARN)
set_name(0x8004A664, "DeltaImportData__FPc", SN_NOWARN)
set_name(0x8004A698, "DeltaSaveLevel__Fv", SN_NOWARN)
set_name(0x8004A8B8, "NetSendCmd__FUcUc", SN_NOWARN)
set_name(0x8004A8E0, "NetSendCmdGolem__FUcUcUcUclUc", SN_NOWARN)
set_name(0x8004A9B0, "NetSendCmdLoc__FUcUcUcUc", SN_NOWARN)
set_name(0x8004AA48, "NetSendCmdLocParam1__FUcUcUcUcUs", SN_NOWARN)
set_name(0x8004AAF0, "NetSendCmdLocParam2__FUcUcUcUcUsUs", SN_NOWARN)
set_name(0x8004ABA8, "NetSendCmdLocParam3__FUcUcUcUcUsUsUs", SN_NOWARN)
set_name(0x8004AC70, "NetSendCmdParam1__FUcUcUs", SN_NOWARN)
set_name(0x8004AC9C, "NetSendCmdParam2__FUcUcUsUs", SN_NOWARN)
set_name(0x8004ACCC, "NetSendCmdParam3__FUcUcUsUsUs", SN_NOWARN)
set_name(0x8004AD04, "NetSendCmdQuest__FUcUc", SN_NOWARN)
set_name(0x8004AD78, "NetSendCmdGItem__FUcUcUcUcUc", SN_NOWARN)
set_name(0x8004AF1C, "NetSendCmdGItem2__FUcUcUcUcPC9TCmdGItem", SN_NOWARN)
set_name(0x8004B00C, "NetSendCmdReq2__FUcUcUcPC9TCmdGItem", SN_NOWARN)
set_name(0x8004B0DC, "NetSendCmdExtra__FPC9TCmdGItem", SN_NOWARN)
set_name(0x8004B170, "NetSendCmdPItem__FUcUcUcUc", SN_NOWARN)
set_name(0x8004B2DC, "NetSendCmdChItem__FUcUc", SN_NOWARN)
set_name(0x8004B380, "NetSendCmdDelItem__FUcUc", SN_NOWARN)
set_name(0x8004B3B0, "NetSendCmdDItem__FUci", SN_NOWARN)
set_name(0x8004B4EC, "i_own_level__Fi", SN_NOWARN)
set_name(0x8004B4F4, "NetSendCmdDamage__FUcUcUl", SN_NOWARN)
set_name(0x8004B560, "delta_open_portal__FiUcUcUcUcUc", SN_NOWARN)
set_name(0x8004B694, "delta_close_portal__Fi", SN_NOWARN)
set_name(0x8004B6FC, "check_update_plr__Fi", SN_NOWARN)
set_name(0x8004B730, "On_SYNCDATA__FPC4TCmdi", SN_NOWARN)
set_name(0x8004B758, "On_WALKXY__FPC4TCmdi", SN_NOWARN)
set_name(0x8004B830, "On_ADDSTR__FPC4TCmdi", SN_NOWARN)
set_name(0x8004B860, "On_ADDMAG__FPC4TCmdi", SN_NOWARN)
set_name(0x8004B890, "On_ADDDEX__FPC4TCmdi", SN_NOWARN)
set_name(0x8004B8C0, "On_ADDVIT__FPC4TCmdi", SN_NOWARN)
set_name(0x8004B8F0, "On_SBSPELL__FPC4TCmdi", SN_NOWARN)
set_name(0x8004B9B0, "On_GOTOGETITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004BA84, "On_REQUESTGITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004BC4C, "On_GETITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004BE24, "On_GOTOAGETITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004BEF8, "On_REQUESTAGITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004C0B4, "On_AGETITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004C284, "On_ITEMEXTRA__FPC4TCmdi", SN_NOWARN)
set_name(0x8004C324, "On_PUTITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004C4C4, "On_SYNCPUTITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004C614, "On_RESPAWNITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004C734, "On_SATTACKXY__FPC4TCmdi", SN_NOWARN)
set_name(0x8004C80C, "On_SPELLXYD__FPC4TCmdi", SN_NOWARN)
set_name(0x8004C93C, "On_SPELLXY__FPC4TCmdi", SN_NOWARN)
set_name(0x8004CA5C, "On_TSPELLXY__FPC4TCmdi", SN_NOWARN)
set_name(0x8004CB80, "On_OPOBJXY__FPC4TCmdi", SN_NOWARN)
set_name(0x8004CCCC, "On_DISARMXY__FPC4TCmdi", SN_NOWARN)
set_name(0x8004CE18, "On_OPOBJT__FPC4TCmdi", SN_NOWARN)
set_name(0x8004CED0, "On_ATTACKID__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D050, "On_SPELLID__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D160, "On_SPELLPID__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D26C, "On_TSPELLID__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D37C, "On_TSPELLPID__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D48C, "On_KNOCKBACK__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D51C, "On_RESURRECT__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D558, "On_HEALOTHER__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D5C8, "On_TALKXY__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D69C, "On_NEWLVL__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D6D4, "On_WARP__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D7C0, "On_MONSTDEATH__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D82C, "On_KILLGOLEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004D898, "On_AWAKEGOLEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004DA0C, "On_MONSTDAMAGE__FPC4TCmdi", SN_NOWARN)
set_name(0x8004DB14, "On_PLRDEAD__FPC4TCmdi", SN_NOWARN)
set_name(0x8004DB5C, "On_PLRDAMAGE__FPC4TCmdi", SN_NOWARN)
set_name(0x8004DD58, "On_OPENDOOR__FPC4TCmdi", SN_NOWARN)
set_name(0x8004DDF4, "On_CLOSEDOOR__FPC4TCmdi", SN_NOWARN)
set_name(0x8004DE90, "On_OPERATEOBJ__FPC4TCmdi", SN_NOWARN)
set_name(0x8004DF2C, "On_PLROPOBJ__FPC4TCmdi", SN_NOWARN)
set_name(0x8004DFC4, "On_BREAKOBJ__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E05C, "On_CHANGEPLRITEMS__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E064, "On_DELPLRITEMS__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E06C, "On_PLRLEVEL__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E074, "On_DROPITEM__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E0CC, "On_PLAYER_JOINLEVEL__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E38C, "On_ACTIVATEPORTAL__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E520, "On_DEACTIVATEPORTAL__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E574, "On_RETOWN__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E5C0, "On_SETSTR__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E600, "On_SETDEX__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E640, "On_SETMAG__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E680, "On_SETVIT__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E6C0, "On_SYNCQUEST__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E708, "On_ENDSHIELD__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E82C, "On_CHEAT_EXPERIENCE__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E834, "On_CHEAT_SPELL_LEVEL__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E83C, "On_DEBUG__FPC4TCmdi", SN_NOWARN)
set_name(0x8004E844, "ParseCmd__FiPC4TCmd", SN_NOWARN)
set_name(0x8004EDEC, "buffer_init__FP7TBuffer", SN_NOWARN)
set_name(0x8004EDF8, "NetSendLoPri__FPCUcUc", SN_NOWARN)
set_name(0x8004EE1C, "InitLevelType__Fi", SN_NOWARN)
set_name(0x8004EE68, "SetupLocalCoords__Fv", SN_NOWARN)
set_name(0x8004EFF8, "InitNewSeed__Fl", SN_NOWARN)
set_name(0x8004F06C, "NetInit__FUcPUc", SN_NOWARN)
set_name(0x8004F38C, "InitObjectGFX__Fv", SN_NOWARN)
set_name(0x8004F5C8, "FreeObjectGFX__Fv", SN_NOWARN)
set_name(0x8004F5D4, "DeleteObject__Fii", SN_NOWARN)
set_name(0x8004F6CC, "SetupObject__Fiiii", SN_NOWARN)
set_name(0x8004F974, "SetObjMapRange__Fiiiiii", SN_NOWARN)
set_name(0x8004FA40, "SetBookMsg__Fii", SN_NOWARN)
set_name(0x8004FAAC, "AddObject__Fiii", SN_NOWARN)
set_name(0x8004FBD4, "Obj_Light__Fii", SN_NOWARN)
set_name(0x8004FE00, "Obj_Circle__Fi", SN_NOWARN)
set_name(0x80050144, "Obj_StopAnim__Fi", SN_NOWARN)
set_name(0x800501E0, "DrawExpl__Fiiiiiccc", SN_NOWARN)
set_name(0x800504C4, "DrawObjExpl__FP12ObjectStructiii", SN_NOWARN)
set_name(0x80050534, "Obj_Door__Fi", SN_NOWARN)
set_name(0x80050700, "Obj_Sarc__Fi", SN_NOWARN)
set_name(0x80050784, "ActivateTrapLine__Fii", SN_NOWARN)
set_name(0x80050894, "Obj_FlameTrap__Fi", SN_NOWARN)
set_name(0x80050B84, "Obj_Trap__Fi", SN_NOWARN)
set_name(0x80050EF4, "Obj_BCrossDamage__Fi", SN_NOWARN)
set_name(0x800511B0, "ProcessObjects__Fv", SN_NOWARN)
set_name(0x80051470, "ObjSetMicro__Fiii", SN_NOWARN)
set_name(0x800514A8, "ObjSetMini__Fiii", SN_NOWARN)
set_name(0x8005157C, "ObjL1Special__Fiiii", SN_NOWARN)
set_name(0x80051584, "ObjL2Special__Fiiii", SN_NOWARN)
set_name(0x8005158C, "DoorSet__Fiii", SN_NOWARN)
set_name(0x8005182C, "RedoPlayerVision__Fv", SN_NOWARN)
set_name(0x800518D0, "OperateL1RDoor__FiiUc", SN_NOWARN)
set_name(0x80051C94, "OperateL1LDoor__FiiUc", SN_NOWARN)
set_name(0x8005208C, "OperateL2RDoor__FiiUc", SN_NOWARN)
set_name(0x80052444, "OperateL2LDoor__FiiUc", SN_NOWARN)
set_name(0x800527FC, "OperateL3RDoor__FiiUc", SN_NOWARN)
set_name(0x80052B24, "OperateL3LDoor__FiiUc", SN_NOWARN)
set_name(0x80052E4C, "MonstCheckDoors__Fi", SN_NOWARN)
set_name(0x80053368, "ObjChangeMap__Fiiii", SN_NOWARN)
set_name(0x80053520, "ObjChangeMapResync__Fiiii", SN_NOWARN)
set_name(0x80053690, "OperateL1Door__FiiUc", SN_NOWARN)
set_name(0x80053808, "OperateLever__Fii", SN_NOWARN)
set_name(0x80053A14, "OperateBook__Fii", SN_NOWARN)
set_name(0x80053F28, "OperateBookLever__Fii", SN_NOWARN)
set_name(0x80054314, "OperateSChambBk__Fii", SN_NOWARN)
set_name(0x8005450C, "OperateChest__FiiUc", SN_NOWARN)
set_name(0x800548FC, "OperateMushPatch__Fii", SN_NOWARN)
set_name(0x80054AE4, "OperateInnSignChest__Fii", SN_NOWARN)
set_name(0x80054C7C, "OperateSlainHero__FiiUc", SN_NOWARN)
set_name(0x80054EF0, "OperateTrapLvr__Fi", SN_NOWARN)
set_name(0x800550F0, "OperateSarc__FiiUc", SN_NOWARN)
set_name(0x800552C8, "OperateL2Door__FiiUc", SN_NOWARN)
set_name(0x80055440, "OperateL3Door__FiiUc", SN_NOWARN)
set_name(0x800555B8, "LoadMapObjs__FPUcii", SN_NOWARN)
set_name(0x800556C0, "OperatePedistal__Fii", SN_NOWARN)
set_name(0x80055998, "TryDisarm__Fii", SN_NOWARN)
set_name(0x80055B7C, "ItemMiscIdIdx__Fi", SN_NOWARN)
set_name(0x80055BEC, "OperateShrine__Fiii", SN_NOWARN)
set_name(0x800581F0, "OperateSkelBook__FiiUc", SN_NOWARN)
set_name(0x8005838C, "OperateBookCase__FiiUc", SN_NOWARN)
set_name(0x8005857C, "OperateDecap__FiiUc", SN_NOWARN)
set_name(0x80058684, "OperateArmorStand__FiiUc", SN_NOWARN)
set_name(0x80058814, "FindValidShrine__Fi", SN_NOWARN)
set_name(0x80058904, "OperateGoatShrine__Fiii", SN_NOWARN)
set_name(0x800589CC, "OperateCauldron__Fiii", SN_NOWARN)
set_name(0x80058AA0, "OperateFountains__Fii", SN_NOWARN)
set_name(0x8005906C, "OperateWeaponRack__FiiUc", SN_NOWARN)
set_name(0x80059238, "OperateStoryBook__Fii", SN_NOWARN)
set_name(0x80059350, "OperateLazStand__Fii", SN_NOWARN)
set_name(0x80059464, "OperateObject__FiiUc", SN_NOWARN)
set_name(0x800598CC, "SyncOpL1Door__Fiii", SN_NOWARN)
set_name(0x80059A0C, "SyncOpL2Door__Fiii", SN_NOWARN)
set_name(0x80059B4C, "SyncOpL3Door__Fiii", SN_NOWARN)
set_name(0x80059C8C, "SyncOpObject__Fiii", SN_NOWARN)
set_name(0x80059F0C, "BreakCrux__Fi", SN_NOWARN)
set_name(0x8005A118, "BreakBarrel__FiiiUcUc", SN_NOWARN)
set_name(0x8005A690, "BreakObject__Fii", SN_NOWARN)
set_name(0x8005A814, "SyncBreakObj__Fii", SN_NOWARN)
set_name(0x8005A8AC, "SyncL1Doors__Fi", SN_NOWARN)
set_name(0x8005A9E0, "SyncCrux__Fi", SN_NOWARN)
set_name(0x8005AB5C, "SyncLever__Fi", SN_NOWARN)
set_name(0x8005AC00, "SyncQSTLever__Fi", SN_NOWARN)
set_name(0x8005AD18, "SyncPedistal__Fi", SN_NOWARN)
set_name(0x8005AE94, "SyncL2Doors__Fi", SN_NOWARN)
set_name(0x8005B010, "SyncL3Doors__Fi", SN_NOWARN)
set_name(0x8005B150, "SyncObjectAnim__Fi", SN_NOWARN)
set_name(0x8005B2B8, "GetObjectStr__Fi", SN_NOWARN)
set_name(0x8005B6F0, "RestoreObjectLight__Fv", SN_NOWARN)
set_name(0x8005B99C, "GetNumOfFrames__7TextDatii_addr_8005B99C", SN_NOWARN)
set_name(0x8005B9D4, "GetCreature__7TextDati_addr_8005B9D4", SN_NOWARN)
set_name(0x8005BA4C, "GetNumOfCreatures__7TextDat_addr_8005BA4C", SN_NOWARN)
set_name(0x8005BA60, "FindPath__FPFiii_UciiiiiPc", SN_NOWARN)
set_name(0x8005BA68, "game_2_ui_class__FPC12PlayerStruct", SN_NOWARN)
set_name(0x8005BA94, "game_2_ui_player__FPC12PlayerStructP11_uiheroinfoUc", SN_NOWARN)
set_name(0x8005BB48, "SetupLocalPlayer__Fv", SN_NOWARN)
set_name(0x8005BB9C, "ismyplr__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005BBE0, "plrind__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005BC24, "InitPlayerGFX__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005BC44, "FreePlayerGFX__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005BC4C, "NewPlrAnim__FP12PlayerStructiii", SN_NOWARN)
set_name(0x8005BC68, "ClearPlrPVars__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005BC8C, "SetPlrAnims__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005BEC8, "CreatePlayer__FP12PlayerStructc", SN_NOWARN)
set_name(0x8005C2E4, "CalcStatDiff__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005C34C, "NextPlrLevel__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005C4BC, "AddPlrExperience__FP12PlayerStructil", SN_NOWARN)
set_name(0x8005C6C0, "AddPlrMonstExper__Filc", SN_NOWARN)
set_name(0x8005C744, "InitPlayer__FP12PlayerStructUc", SN_NOWARN)
set_name(0x8005CB2C, "InitMultiView__Fv", SN_NOWARN)
set_name(0x8005CB88, "SolidLoc__Fii", SN_NOWARN)
set_name(0x8005CBCC, "PlrClrTrans__Fii", SN_NOWARN)
set_name(0x8005CC60, "PlrDoTrans__Fii", SN_NOWARN)
set_name(0x8005CD54, "SetPlayerOld__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005CD68, "FixPlayerLocation__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005CDCC, "StartStand__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005CE58, "StartWalkStand__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005CEBC, "PM_ChangeLightOff__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005CEF8, "PM_ChangeOffset__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005CF24, "StartAttack__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005CFC0, "StartPlrBlock__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005D070, "StartSpell__FP12PlayerStructiii", SN_NOWARN)
set_name(0x8005D228, "RemovePlrFromMap__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005D348, "StartPlrHit__FP12PlayerStructiUc", SN_NOWARN)
set_name(0x8005D478, "RespawnDeadItem__FP10ItemStructii", SN_NOWARN)
set_name(0x8005D610, "PlrDeadItem__FP12PlayerStructP10ItemStructii", SN_NOWARN)
set_name(0x8005D7D4, "StartPlayerKill__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005DB88, "DropHalfPlayersGold__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005DFD0, "StartPlrKill__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005E114, "SyncPlrKill__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005E134, "RemovePlrMissiles__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005E41C, "InitLevelChange__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005E4D8, "StartNewLvl__FP12PlayerStructii", SN_NOWARN)
set_name(0x8005E684, "RestartTownLvl__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005E714, "StartWarpLvl__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005E7D0, "PM_DoStand__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005E7D8, "ChkPlrOffsets__Fiiii", SN_NOWARN)
set_name(0x8005E860, "PM_DoWalk__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005EBCC, "WeaponDur__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005ED6C, "PlrHitMonst__FP12PlayerStructi", SN_NOWARN)
set_name(0x8005F39C, "PlrHitPlr__FP12PlayerStructc", SN_NOWARN)
set_name(0x8005F74C, "PlrHitObj__FP12PlayerStructii", SN_NOWARN)
set_name(0x8005F7DC, "PM_DoAttack__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005FB68, "PM_DoRangeAttack__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005FC68, "ShieldDur__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005FD28, "PM_DoBlock__FP12PlayerStruct", SN_NOWARN)
set_name(0x8005FDC8, "do_spell_anim__FiiiP12PlayerStruct", SN_NOWARN)
set_name(0x80060D30, "PM_DoSpell__FP12PlayerStruct", SN_NOWARN)
set_name(0x800610A0, "ArmorDur__FP12PlayerStruct", SN_NOWARN)
set_name(0x8006119C, "PM_DoGotHit__FP12PlayerStruct", SN_NOWARN)
set_name(0x80061218, "PM_DoDeath__FP12PlayerStruct", SN_NOWARN)
set_name(0x8006132C, "PM_DoNewLvl__FP12PlayerStruct", SN_NOWARN)
set_name(0x80061334, "CheckNewPath__FP12PlayerStruct", SN_NOWARN)
set_name(0x8006174C, "PlrDeathModeOK__Fi", SN_NOWARN)
set_name(0x800617B4, "ValidatePlayer__Fv", SN_NOWARN)
set_name(0x80061C90, "CheckCheatStats__FP12PlayerStruct", SN_NOWARN)
set_name(0x80061D2C, "ProcessPlayers__Fv", SN_NOWARN)
set_name(0x80062160, "ClrPlrPath__FP12PlayerStruct", SN_NOWARN)
set_name(0x80062188, "PosOkPlayer__FP12PlayerStructii", SN_NOWARN)
set_name(0x8006239C, "MakePlrPath__FP12PlayerStructiiUc", SN_NOWARN)
set_name(0x800623AC, "CheckPlrSpell__Fv", SN_NOWARN)
set_name(0x80062A18, "SyncInitPlrPos__FP12PlayerStruct", SN_NOWARN)
set_name(0x80062B54, "SyncInitPlr__FP12PlayerStruct", SN_NOWARN)
set_name(0x80062B84, "CheckStats__Fi", SN_NOWARN)
set_name(0x80062DBC, "ModifyPlrStr__Fii", SN_NOWARN)
set_name(0x80062F3C, "ModifyPlrMag__Fii", SN_NOWARN)
set_name(0x8006309C, "ModifyPlrDex__Fii", SN_NOWARN)
set_name(0x800631CC, "ModifyPlrVit__Fii", SN_NOWARN)
set_name(0x80063314, "SetPlayerHitPoints__FP12PlayerStructi", SN_NOWARN)
set_name(0x80063358, "SetPlrStr__Fii", SN_NOWARN)
set_name(0x80063474, "SetPlrMag__Fii", SN_NOWARN)
set_name(0x800634F8, "SetPlrDex__Fii", SN_NOWARN)
set_name(0x80063614, "SetPlrVit__Fii", SN_NOWARN)
set_name(0x80063694, "InitDungMsgs__FP12PlayerStruct", SN_NOWARN)
set_name(0x8006369C, "PlayDungMsgs__Fv", SN_NOWARN)
set_name(0x80063C34, "CreatePlrItems__FP12PlayerStruct", SN_NOWARN)
set_name(0x80063C5C, "WorldToOffset__FP12PlayerStructii", SN_NOWARN)
set_name(0x80063CA0, "SetSpdbarGoldCurs__FP12PlayerStructi", SN_NOWARN)
set_name(0x80063CD4, "GetSpellLevel__FP12PlayerStructi", SN_NOWARN)
set_name(0x80063D08, "BreakObject__FP12PlayerStructi", SN_NOWARN)
set_name(0x80063D3C, "CalcPlrInv__FP12PlayerStructUc", SN_NOWARN)
set_name(0x80063D70, "RemoveSpdBarItem__FP12PlayerStructi", SN_NOWARN)
set_name(0x80063DA4, "M_StartKill__FiP12PlayerStruct", SN_NOWARN)
set_name(0x80063DDC, "SetGoldCurs__FP12PlayerStructi", SN_NOWARN)
set_name(0x80063E10, "HealStart__FP12PlayerStruct", SN_NOWARN)
set_name(0x80063E38, "HealotherStart__FP12PlayerStruct", SN_NOWARN)
set_name(0x80063E60, "CalculateGold__FP12PlayerStruct", SN_NOWARN)
set_name(0x80063E88, "M_StartHit__FiP12PlayerStructi", SN_NOWARN)
set_name(0x80063ED0, "TeleStart__FP12PlayerStruct", SN_NOWARN)
set_name(0x80063EF8, "PhaseStart__FP12PlayerStruct", SN_NOWARN)
set_name(0x80063F20, "RemoveInvItem__FP12PlayerStructi", SN_NOWARN)
set_name(0x80063F54, "InvisStart__FP12PlayerStruct", SN_NOWARN)
set_name(0x80063F7C, "PhaseEnd__FP12PlayerStruct", SN_NOWARN)
set_name(0x80063F9C, "OperateObject__FP12PlayerStructiUc", SN_NOWARN)
set_name(0x80063FE0, "TryDisarm__FP12PlayerStructi", SN_NOWARN)
set_name(0x80064014, "TalkToTowner__FP12PlayerStructi", SN_NOWARN)
set_name(0x80064048, "PosOkPlayer__Fiii", SN_NOWARN)
set_name(0x80064094, "CalcStatDiff__Fi", SN_NOWARN)
set_name(0x800640E0, "StartNewLvl__Fiii", SN_NOWARN)
set_name(0x8006412C, "CreatePlayer__Fic", SN_NOWARN)
set_name(0x80064180, "StartStand__Fii", SN_NOWARN)
set_name(0x800641CC, "SetPlayerHitPoints__Fii", SN_NOWARN)
set_name(0x80064218, "MakePlrPath__FiiiUc", SN_NOWARN)
set_name(0x80064268, "StartWarpLvl__Fii", SN_NOWARN)
set_name(0x800642B4, "SyncPlrKill__Fii", SN_NOWARN)
set_name(0x80064300, "StartPlrKill__Fii", SN_NOWARN)
set_name(0x8006434C, "NewPlrAnim__Fiiii", SN_NOWARN)
set_name(0x80064398, "AddPlrExperience__Fiil", SN_NOWARN)
set_name(0x800643E4, "StartPlrBlock__Fii", SN_NOWARN)
set_name(0x80064430, "StartPlrHit__FiiUc", SN_NOWARN)
set_name(0x80064480, "StartSpell__Fiiii", SN_NOWARN)
set_name(0x800644CC, "FixPlayerLocation__Fii", SN_NOWARN)
set_name(0x80064518, "InitPlayer__FiUc", SN_NOWARN)
set_name(0x80064568, "PM_ChangeLightOff__Fi", SN_NOWARN)
set_name(0x800645B4, "CheckNewPath__Fi", SN_NOWARN)
set_name(0x80064600, "FreePlayerGFX__Fi", SN_NOWARN)
set_name(0x8006464C, "InitDungMsgs__Fi", SN_NOWARN)
set_name(0x80064698, "InitPlayerGFX__Fi", SN_NOWARN)
set_name(0x800646E4, "SyncInitPlrPos__Fi", SN_NOWARN)
set_name(0x80064730, "SetPlrAnims__Fi", SN_NOWARN)
set_name(0x8006477C, "ClrPlrPath__Fi", SN_NOWARN)
set_name(0x800647C8, "SyncInitPlr__Fi", SN_NOWARN)
set_name(0x80064814, "RestartTownLvl__Fi", SN_NOWARN)
set_name(0x80064860, "SetPlayerOld__Fi", SN_NOWARN)
set_name(0x800648AC, "GetGoldSeed__FP12PlayerStructP10ItemStruct", SN_NOWARN)
set_name(0x800648E0, "PRIM_GetPrim__FPP8POLY_FT4_addr_800648E0", SN_NOWARN)
set_name(0x8006495C, "GetPlayer__7CPlayeri", SN_NOWARN)
set_name(0x800649AC, "GetLastOtPos__C7CPlayer", SN_NOWARN)
set_name(0x800649B8, "GetLastScrY__C7CPlayer", SN_NOWARN)
set_name(0x800649C4, "GetLastScrX__C7CPlayer", SN_NOWARN)
set_name(0x800649D0, "TSK_Lava2Water__FP4TASK", SN_NOWARN)
set_name(0x800649D8, "CheckQuests__Fv", SN_NOWARN)
set_name(0x80064E90, "ForceQuests__Fv", SN_NOWARN)
set_name(0x80065034, "QuestStatus__Fi", SN_NOWARN)
set_name(0x800650FC, "CheckQuestKill__FiUc", SN_NOWARN)
set_name(0x80065728, "SetReturnLvlPos__Fv", SN_NOWARN)
set_name(0x80065838, "GetReturnLvlPos__Fv", SN_NOWARN)
set_name(0x8006588C, "ResyncMPQuests__Fv", SN_NOWARN)
set_name(0x800659C8, "ResyncQuests__Fv", SN_NOWARN)
set_name(0x80065F28, "PrintQLString__FiiUcPcc", SN_NOWARN)
set_name(0x80066154, "DrawQuestLog__Fv", SN_NOWARN)
set_name(0x8006638C, "DrawQuestLogTSK__FP4TASK", SN_NOWARN)
set_name(0x8006640C, "StartQuestlog__Fv", SN_NOWARN)
set_name(0x8006651C, "QuestlogUp__Fv", SN_NOWARN)
set_name(0x80066574, "QuestlogDown__Fv", SN_NOWARN)
set_name(0x800665DC, "QuestlogEnter__Fv", SN_NOWARN)
set_name(0x80066698, "QuestlogESC__Fv", SN_NOWARN)
set_name(0x800666D8, "SetMultiQuest__FiiUci", SN_NOWARN)
set_name(0x800667DC, "_GLOBAL__D_questlog", SN_NOWARN)
set_name(0x80066804, "_GLOBAL__I_questlog", SN_NOWARN)
set_name(0x8006682C, "SetRGB__6DialogUcUcUc_addr_8006682C", SN_NOWARN)
set_name(0x8006684C, "SetBack__6Dialogi_addr_8006684C", SN_NOWARN)
set_name(0x80066854, "SetBorder__6Dialogi_addr_80066854", SN_NOWARN)
set_name(0x8006685C, "___6Dialog_addr_8006685C", SN_NOWARN)
set_name(0x80066884, "__6Dialog_addr_80066884", SN_NOWARN)
set_name(0x800668E0, "DrawView__Fii", SN_NOWARN)
set_name(0x80066B4C, "DrawAndBlit__Fv", SN_NOWARN)
set_name(0x80066C44, "FreeStoreMem__Fv", SN_NOWARN)
set_name(0x80066C4C, "DrawSTextBack__Fv", SN_NOWARN)
set_name(0x80066CBC, "PrintSString__FiiUcPcci", SN_NOWARN)
set_name(0x8006704C, "DrawSLine__Fi", SN_NOWARN)
set_name(0x800670E0, "ClearSText__Fii", SN_NOWARN)
set_name(0x80067178, "AddSLine__Fi", SN_NOWARN)
set_name(0x800671C8, "AddSTextVal__Fii", SN_NOWARN)
set_name(0x800671F0, "AddSText__FiiUcPccUc", SN_NOWARN)
set_name(0x800672A4, "PrintStoreItem__FPC10ItemStructic", SN_NOWARN)
set_name(0x800676E8, "StoreAutoPlace__Fv", SN_NOWARN)
set_name(0x80067D04, "S_StartSmith__Fv", SN_NOWARN)
set_name(0x80067E8C, "S_ScrollSBuy__Fi", SN_NOWARN)
set_name(0x80068038, "S_StartSBuy__Fv", SN_NOWARN)
set_name(0x80068168, "S_ScrollSPBuy__Fi", SN_NOWARN)
set_name(0x80068330, "S_StartSPBuy__Fv", SN_NOWARN)
set_name(0x80068480, "SmithSellOk__Fi", SN_NOWARN)
set_name(0x80068568, "S_ScrollSSell__Fi", SN_NOWARN)
set_name(0x80068754, "S_StartSSell__Fv", SN_NOWARN)
set_name(0x80068B7C, "SmithRepairOk__Fi", SN_NOWARN)
set_name(0x80068C24, "AddStoreHoldRepair__FP10ItemStructi", SN_NOWARN)
set_name(0x80068E00, "S_StartSRepair__Fv", SN_NOWARN)
set_name(0x800692CC, "S_StartWitch__Fv", SN_NOWARN)
set_name(0x8006940C, "S_ScrollWBuy__Fi", SN_NOWARN)
set_name(0x800695B8, "S_StartWBuy__Fv", SN_NOWARN)
set_name(0x800696E0, "WitchSellOk__Fi", SN_NOWARN)
set_name(0x80069804, "S_StartWSell__Fv", SN_NOWARN)
set_name(0x80069E50, "WitchRechargeOk__Fi", SN_NOWARN)
set_name(0x80069EDC, "AddStoreHoldRecharge__FG10ItemStructi", SN_NOWARN)
set_name(0x8006A058, "S_StartWRecharge__Fv", SN_NOWARN)
set_name(0x8006A46C, "S_StartNoMoney__Fv", SN_NOWARN)
set_name(0x8006A4D4, "S_StartNoRoom__Fv", SN_NOWARN)
set_name(0x8006A534, "S_StartConfirm__Fv", SN_NOWARN)
set_name(0x8006A868, "S_StartBoy__Fv", SN_NOWARN)
set_name(0x8006A9F8, "S_StartBBoy__Fv", SN_NOWARN)
set_name(0x8006AB44, "S_StartHealer__Fv", SN_NOWARN)
set_name(0x8006AD18, "S_ScrollHBuy__Fi", SN_NOWARN)
set_name(0x8006AE78, "S_StartHBuy__Fv", SN_NOWARN)
set_name(0x8006AF98, "S_StartStory__Fv", SN_NOWARN)
set_name(0x8006B088, "IdItemOk__FP10ItemStruct", SN_NOWARN)
set_name(0x8006B0BC, "AddStoreHoldId__FG10ItemStructi", SN_NOWARN)
set_name(0x8006B18C, "S_StartSIdentify__Fv", SN_NOWARN)
set_name(0x8006BBC8, "S_StartIdShow__Fv", SN_NOWARN)
set_name(0x8006BD58, "S_StartTalk__Fv", SN_NOWARN)
set_name(0x8006BF88, "S_StartTavern__Fv", SN_NOWARN)
set_name(0x8006C080, "S_StartBarMaid__Fv", SN_NOWARN)
set_name(0x8006C154, "S_StartDrunk__Fv", SN_NOWARN)
set_name(0x8006C228, "StartStore__Fc", SN_NOWARN)
set_name(0x8006C510, "DrawSText__Fv", SN_NOWARN)
set_name(0x8006C550, "DrawSTextTSK__FP4TASK", SN_NOWARN)
set_name(0x8006C618, "DoThatDrawSText__Fv", SN_NOWARN)
set_name(0x8006C7C4, "STextESC__Fv", SN_NOWARN)
set_name(0x8006C974, "STextUp__Fv", SN_NOWARN)
set_name(0x8006CAFC, "STextDown__Fv", SN_NOWARN)
set_name(0x8006CC94, "S_SmithEnter__Fv", SN_NOWARN)
set_name(0x8006CD68, "SetGoldCurs__Fii", SN_NOWARN)
set_name(0x8006CDE8, "SetSpdbarGoldCurs__Fii", SN_NOWARN)
set_name(0x8006CE68, "TakePlrsMoney__Fl", SN_NOWARN)
set_name(0x8006D2B4, "SmithBuyItem__Fv", SN_NOWARN)
set_name(0x8006D498, "S_SBuyEnter__Fv", SN_NOWARN)
set_name(0x8006D694, "SmithBuyPItem__Fv", SN_NOWARN)
set_name(0x8006D814, "S_SPBuyEnter__Fv", SN_NOWARN)
set_name(0x8006DA58, "StoreGoldFit__Fi", SN_NOWARN)
set_name(0x8006DD28, "PlaceStoreGold__Fl", SN_NOWARN)
set_name(0x8006DF8C, "StoreSellItem__Fv", SN_NOWARN)
set_name(0x8006E274, "S_SSellEnter__Fv", SN_NOWARN)
set_name(0x8006E368, "SmithRepairItem__Fv", SN_NOWARN)
set_name(0x8006E5D0, "S_SRepairEnter__Fv", SN_NOWARN)
set_name(0x8006E71C, "S_WitchEnter__Fv", SN_NOWARN)
set_name(0x8006E7CC, "WitchBuyItem__Fv", SN_NOWARN)
set_name(0x8006E9C0, "S_WBuyEnter__Fv", SN_NOWARN)
set_name(0x8006EBBC, "S_WSellEnter__Fv", SN_NOWARN)
set_name(0x8006ECB0, "WitchRechargeItem__Fv", SN_NOWARN)
set_name(0x8006EE20, "S_WRechargeEnter__Fv", SN_NOWARN)
set_name(0x8006EF6C, "S_BoyEnter__Fv", SN_NOWARN)
set_name(0x8006F0A4, "BoyBuyItem__Fv", SN_NOWARN)
set_name(0x8006F128, "HealerBuyItem__Fv", SN_NOWARN)
set_name(0x8006F3B4, "S_BBuyEnter__Fv", SN_NOWARN)
set_name(0x8006F5B0, "StoryIdItem__Fv", SN_NOWARN)
set_name(0x8006F8F8, "S_ConfirmEnter__Fv", SN_NOWARN)
set_name(0x8006FA14, "S_HealerEnter__Fv", SN_NOWARN)
set_name(0x8006FAAC, "S_HBuyEnter__Fv", SN_NOWARN)
set_name(0x8006FCC8, "S_StoryEnter__Fv", SN_NOWARN)
set_name(0x8006FD60, "S_SIDEnter__Fv", SN_NOWARN)
set_name(0x8006FECC, "S_TalkEnter__Fv", SN_NOWARN)
set_name(0x800700C4, "S_TavernEnter__Fv", SN_NOWARN)
set_name(0x80070134, "S_BarmaidEnter__Fv", SN_NOWARN)
set_name(0x800701A4, "S_DrunkEnter__Fv", SN_NOWARN)
set_name(0x80070214, "STextEnter__Fv", SN_NOWARN)
set_name(0x80070424, "CheckStoreBtn__Fv", SN_NOWARN)
set_name(0x8007053C, "ReleaseStoreBtn__Fv", SN_NOWARN)
set_name(0x80070550, "_GLOBAL__D_pSTextBoxCels", SN_NOWARN)
set_name(0x80070578, "_GLOBAL__I_pSTextBoxCels", SN_NOWARN)
set_name(0x800705A0, "GetDown__C4CPad_addr_800705A0", SN_NOWARN)
set_name(0x800705C8, "SetRGB__6DialogUcUcUc_addr_800705C8", SN_NOWARN)
set_name(0x800705E8, "SetBorder__6Dialogi_addr_800705E8", SN_NOWARN)
set_name(0x800705F0, "___6Dialog_addr_800705F0", SN_NOWARN)
set_name(0x80070618, "__6Dialog_addr_80070618", SN_NOWARN)
set_name(0x80070674, "sync_monster__FiPC12TSyncMonster", SN_NOWARN)
set_name(0x80070A50, "sync_update__FiPCUc", SN_NOWARN)
set_name(0x80070B88, "sync_init__Fv", SN_NOWARN)
set_name(0x80070BC4, "T_DrawView__Fii", SN_NOWARN)
set_name(0x80070D38, "T_FillSector__FPUcT0iiiib", SN_NOWARN)
set_name(0x80070F30, "T_FillTile__FPUciii", SN_NOWARN)
set_name(0x80071020, "T_Pass3__Fv", SN_NOWARN)
set_name(0x8007141C, "CreateTown__Fi", SN_NOWARN)
set_name(0x80071584, "GRL_LoadFileInMemSig__FPCcPUl", SN_NOWARN)
set_name(0x80071668, "GRL_StripDir__FPcPCc", SN_NOWARN)
set_name(0x80071700, "ForceTownTrig__Fv", SN_NOWARN)
set_name(0x80071A18, "ForceL1Trig__Fv", SN_NOWARN)
set_name(0x80071CC8, "ForceL2Trig__Fv", SN_NOWARN)
set_name(0x80072128, "ForceL3Trig__Fv", SN_NOWARN)
set_name(0x800725A4, "ForceL4Trig__Fv", SN_NOWARN)
set_name(0x80072AB0, "Freeupstairs__Fv", SN_NOWARN)
set_name(0x80072B70, "ForceSKingTrig__Fv", SN_NOWARN)
set_name(0x80072C64, "ForceSChambTrig__Fv", SN_NOWARN)
set_name(0x80072D58, "ForcePWaterTrig__Fv", SN_NOWARN)
set_name(0x80072E4C, "CheckTrigForce__Fv", SN_NOWARN)
set_name(0x80073168, "FadeGameOut__Fv", SN_NOWARN)
set_name(0x80073204, "CheckTriggers__Fi", SN_NOWARN)
set_name(0x80073780, "GetManaAmount__Fii", SN_NOWARN)
set_name(0x80073A48, "UseMana__Fii", SN_NOWARN)
set_name(0x80073B60, "CheckSpell__FiicUc", SN_NOWARN)
set_name(0x80073C00, "CastSpell__Fiiiiiiii", SN_NOWARN)
set_name(0x80073E64, "DoResurrect__Fii", SN_NOWARN)
set_name(0x80074118, "DoHealOther__Fii", SN_NOWARN)
set_name(0x8007437C, "snd_update__FUc", SN_NOWARN)
set_name(0x80074384, "snd_get_volume__FPCcPl", SN_NOWARN)
set_name(0x800743EC, "snd_stop_snd__FP4TSnd", SN_NOWARN)
set_name(0x8007440C, "snd_play_snd__FP4TSFXll", SN_NOWARN)
set_name(0x8007447C, "snd_play_msnd__FUsll", SN_NOWARN)
set_name(0x80074518, "snd_init__FUl", SN_NOWARN)
set_name(0x80074580, "music_stop__Fv", SN_NOWARN)
set_name(0x800745CC, "music_fade__Fv", SN_NOWARN)
set_name(0x8007460C, "music_start__Fi", SN_NOWARN)
set_name(0x800746AC, "flyabout__7GamePad", SN_NOWARN)
set_name(0x80074B68, "CloseInvChr__Fv", SN_NOWARN)
set_name(0x80074BD0, "WorldToOffset__Fiii", SN_NOWARN)
set_name(0x80074CA4, "pad_UpIsUp__Fi", SN_NOWARN)
set_name(0x80074D14, "pad_UpIsUpRight__Fi", SN_NOWARN)
set_name(0x80074D84, "__7GamePadic", SN_NOWARN)
set_name(0x80074EF0, "SetMoveStyle__7GamePadc", SN_NOWARN)
set_name(0x80074F10, "SetDownButton__7GamePadiPFi_v", SN_NOWARN)
set_name(0x80074F54, "SetComboDownButton__7GamePadiPFi_v", SN_NOWARN)
set_name(0x80074F98, "SetAllButtons__7GamePadP11KEY_ASSIGNS", SN_NOWARN)
set_name(0x800750E4, "GetAllButtons__7GamePadP11KEY_ASSIGNS", SN_NOWARN)
set_name(0x800751AC, "GetActionButton__7GamePadPFi_v", SN_NOWARN)
set_name(0x80075208, "SetUpAction__7GamePadPFi_vT1", SN_NOWARN)
set_name(0x80075244, "RunFunc__7GamePadi", SN_NOWARN)
set_name(0x800752C8, "ButtonDown__7GamePadi", SN_NOWARN)
set_name(0x80075694, "TestButtons__7GamePad", SN_NOWARN)
set_name(0x80075740, "CheckDirs__7GamePadi", SN_NOWARN)
set_name(0x80075858, "CheckSide__7GamePadi", SN_NOWARN)
set_name(0x8007589C, "CheckBodge__7GamePadi", SN_NOWARN)
set_name(0x80075BA0, "walk__7GamePadc", SN_NOWARN)
set_name(0x80075E74, "check_around_player__7GamePad", SN_NOWARN)
set_name(0x80076064, "show_combos__7GamePad", SN_NOWARN)
set_name(0x800761E8, "Handle__7GamePad", SN_NOWARN)
set_name(0x80076788, "GamePadTask__FP4TASK", SN_NOWARN)
set_name(0x800769A4, "PostGamePad__Fiiii", SN_NOWARN)
set_name(0x80076A54, "Init_GamePad__Fv", SN_NOWARN)
set_name(0x80076A84, "InitGamePadVars__Fv", SN_NOWARN)
set_name(0x80076AFC, "MoveToScrollTarget__7CBlocks_addr_80076AFC", SN_NOWARN)
set_name(0x80076B10, "GetDown__C4CPad_addr_80076B10", SN_NOWARN)
set_name(0x80076B38, "GetUp__C4CPad_addr_80076B38", SN_NOWARN)
set_name(0x80076B60, "GetCur__C4CPad_addr_80076B60", SN_NOWARN)
set_name(0x80076B88, "DoGameTestStuff__Fv", SN_NOWARN)
set_name(0x80076BB4, "DoInitGameStuff__Fv", SN_NOWARN)
set_name(0x80076BE8, "SMemAlloc", SN_NOWARN)
set_name(0x80076C08, "SMemFree", SN_NOWARN)
set_name(0x80076C28, "GRL_InitGwin__Fv", SN_NOWARN)
set_name(0x80076C34, "GRL_SetWindowProc__FPFUlUilUl_Ul", SN_NOWARN)
set_name(0x80076C44, "GRL_CallWindowProc__FUlUilUl", SN_NOWARN)
set_name(0x80076C6C, "GRL_PostMessage__FUlUilUl", SN_NOWARN)
set_name(0x80076D10, "Msg2Txt__Fi", SN_NOWARN)
set_name(0x80076D58, "LANG_GetLang__Fv", SN_NOWARN)
set_name(0x80076D64, "LANG_SetDb__F10LANG_DB_NO", SN_NOWARN)
set_name(0x80076E68, "GetStr__Fi", SN_NOWARN)
set_name(0x80076ED0, "LANG_SetLang__F9LANG_TYPE", SN_NOWARN)
set_name(0x80076FD4, "DumpCurrentText__Fv", SN_NOWARN)
set_name(0x8007702C, "CalcNumOfStrings__FPPc", SN_NOWARN)
set_name(0x80077038, "GetLangFileName__F9LANG_TYPEPc", SN_NOWARN)
set_name(0x80077140, "GetLangFileNameExt__F9LANG_TYPE", SN_NOWARN)
set_name(0x800771C0, "TempPrintMissile__FiiiiiiiiccUcUcUcc", SN_NOWARN)
set_name(0x800776F8, "FuncTOWN__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077878, "FuncRPORTAL__FP13MissileStructiii", SN_NOWARN)
set_name(0x800779D8, "FuncFIREBOLT__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077A70, "FuncHBOLT__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077B20, "FuncLIGHTNING__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077B84, "FuncGUARDIAN__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077C9C, "FuncFIREWALL__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077D34, "FuncFIREMOVE__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077DCC, "FuncFLAME__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077E34, "FuncARROW__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077EC8, "FuncFARROW__FP13MissileStructiii", SN_NOWARN)
set_name(0x80077FA8, "FuncLARROW__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078080, "FuncMAGMABALL__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078110, "FuncBONESPIRIT__FP13MissileStructiii", SN_NOWARN)
set_name(0x8007822C, "FuncACID__FP13MissileStructiii", SN_NOWARN)
set_name(0x800782C8, "FuncACIDSPLAT__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078330, "FuncACIDPUD__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078398, "FuncFLARE__FP13MissileStructiii", SN_NOWARN)
set_name(0x800784CC, "FuncFLAREXP__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078610, "FuncCBOLT__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078678, "FuncBOOM__FP13MissileStructiii", SN_NOWARN)
set_name(0x800786D0, "FuncELEMENT__FP13MissileStructiii", SN_NOWARN)
set_name(0x8007879C, "FuncMISEXP__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078800, "FuncRHINO__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078808, "FuncFLASH__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078D30, "FuncMANASHIELD__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078DD8, "FuncFLASH2__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078DE0, "FuncRESURRECTBEAM__FP13MissileStructiii", SN_NOWARN)
set_name(0x80078E14, "PRIM_GetPrim__FPP8POLY_FT4_addr_80078E14", SN_NOWARN)
set_name(0x80078E90, "GetPlayer__7CPlayeri_addr_80078E90", SN_NOWARN)
set_name(0x80078EE0, "GetLastOtPos__C7CPlayer_addr_80078EE0", SN_NOWARN)
set_name(0x80078EEC, "GetLastScrY__C7CPlayer_addr_80078EEC", SN_NOWARN)
set_name(0x80078EF8, "GetLastScrX__C7CPlayer_addr_80078EF8", SN_NOWARN)
set_name(0x80078F04, "GetNumOfFrames__7TextDat_addr_80078F04", SN_NOWARN)
set_name(0x80078F18, "GetFr__7TextDati_addr_80078F18", SN_NOWARN)
set_name(0x80078F34, "ML_Init__Fv", SN_NOWARN)
set_name(0x80078F6C, "ML_GetList__Fi", SN_NOWARN)
set_name(0x80078FEC, "ML_SetRandomList__Fi", SN_NOWARN)
set_name(0x80079084, "ML_SetList__Fii", SN_NOWARN)
set_name(0x80079134, "ML_GetPresetMonsters__FiPiUl", SN_NOWARN)
set_name(0x800792F0, "DefaultObjPrint__FP12ObjectStructiiP7TextDatiii", SN_NOWARN)
set_name(0x80079484, "LightObjPrint__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007953C, "DoorObjPrint__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079764, "DrawLightSpark__Fiii", SN_NOWARN)
set_name(0x8007983C, "PrintOBJ_L1LIGHT__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x800798C4, "PrintOBJ_SKFIRE__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x800798F0, "PrintOBJ_LEVER__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007991C, "PrintOBJ_CHEST1__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079948, "PrintOBJ_CHEST2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079974, "PrintOBJ_CHEST3__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x800799A0, "PrintOBJ_CANDLE1__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x800799C4, "PrintOBJ_CANDLE2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x800799E8, "PrintOBJ_CANDLEO__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079A14, "PrintOBJ_BANNERL__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079A40, "PrintOBJ_BANNERM__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079A6C, "PrintOBJ_BANNERR__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079A98, "PrintOBJ_SKPILE__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079AC4, "PrintOBJ_SKSTICK1__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079AF0, "PrintOBJ_SKSTICK2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079B1C, "PrintOBJ_SKSTICK3__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079B48, "PrintOBJ_SKSTICK4__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079B74, "PrintOBJ_SKSTICK5__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079BA0, "PrintOBJ_CRUX1__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079BCC, "PrintOBJ_CRUX2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079BF8, "PrintOBJ_CRUX3__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079C24, "PrintOBJ_STAND__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079C50, "PrintOBJ_ANGEL__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079C7C, "PrintOBJ_BOOK2L__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079CA8, "PrintOBJ_BCROSS__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079CD4, "PrintOBJ_NUDEW2R__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079D00, "PrintOBJ_SWITCHSKL__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079D2C, "PrintOBJ_TNUDEM1__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079D58, "PrintOBJ_TNUDEM2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079D84, "PrintOBJ_TNUDEM3__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079DB0, "PrintOBJ_TNUDEM4__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079DDC, "PrintOBJ_TNUDEW1__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079E08, "PrintOBJ_TNUDEW2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079E34, "PrintOBJ_TNUDEW3__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079E60, "PrintOBJ_TORTURE1__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079E8C, "PrintOBJ_TORTURE2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079EB8, "PrintOBJ_TORTURE3__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079EE4, "PrintOBJ_TORTURE4__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079F10, "PrintOBJ_TORTURE5__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079F3C, "PrintOBJ_BOOK2R__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x80079F68, "PrintTorchStick__Fiiii", SN_NOWARN)
set_name(0x80079FFC, "PrintOBJ_TORCHL__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A08C, "PrintOBJ_TORCHR__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A11C, "PrintOBJ_TORCHL2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A1AC, "PrintOBJ_TORCHR2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A23C, "PrintOBJ_SARC__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A268, "PrintOBJ_FLAMEHOLE__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A294, "PrintOBJ_FLAMELVR__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A2C0, "PrintOBJ_WATER__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A2EC, "PrintOBJ_BOOKLVR__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A318, "PrintOBJ_TRAPL__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A344, "PrintOBJ_TRAPR__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A370, "PrintOBJ_BOOKSHELF__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A39C, "PrintOBJ_WEAPRACK__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A3C8, "PrintOBJ_BARREL__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A3F4, "PrintOBJ_BARRELEX__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A54C, "PrintOBJ_SHRINEL__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A618, "PrintOBJ_SHRINER__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A6E4, "PrintOBJ_SKELBOOK__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A710, "PrintOBJ_BOOKCASEL__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A73C, "PrintOBJ_BOOKCASER__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A768, "PrintOBJ_BOOKSTAND__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A794, "PrintOBJ_BOOKCANDLE__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A7B8, "PrintOBJ_BLOODFTN__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A7E4, "PrintOBJ_DECAP__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A810, "PrintOBJ_TCHEST1__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A83C, "PrintOBJ_TCHEST2__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A868, "PrintOBJ_TCHEST3__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A894, "PrintOBJ_BLINDBOOK__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A8C0, "PrintOBJ_BLOODBOOK__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A8EC, "PrintOBJ_PEDISTAL__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A918, "PrintOBJ_PURIFYINGFTN__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A944, "PrintOBJ_ARMORSTAND__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A970, "PrintOBJ_ARMORSTANDN__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A99C, "PrintOBJ_GOATSHRINE__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A9C8, "PrintOBJ_CAULDRON__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007A9F4, "PrintOBJ_MURKYFTN__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AA20, "PrintOBJ_TEARFTN__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AA4C, "PrintOBJ_ALTBOY__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AA78, "PrintOBJ_MCIRCLE1__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AC0C, "PrintOBJ_STORYBOOK__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AC38, "PrintOBJ_STORYCANDLE__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AC5C, "PrintOBJ_STEELTOME__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AC88, "PrintOBJ_WARARMOR__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007ACB4, "PrintOBJ_WARWEAP__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007ACE0, "PrintOBJ_TBCROSS__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AD0C, "PrintOBJ_WEAPONRACK__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AD38, "PrintOBJ_WEAPONRACKN__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AD64, "PrintOBJ_MUSHPATCH__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AD90, "PrintOBJ_LAZSTAND__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007ADBC, "PrintOBJ_SLAINHERO__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007ADE8, "PrintOBJ_SIGNCHEST__FP12ObjectStructiiP7TextDati", SN_NOWARN)
set_name(0x8007AE14, "PRIM_GetCopy__FP8POLY_FT4_addr_8007AE14", SN_NOWARN)
set_name(0x8007AE50, "PRIM_CopyPrim__FP8POLY_FT4T0_addr_8007AE50", SN_NOWARN)
set_name(0x8007AE78, "PRIM_GetPrim__FPP8POLY_FT4_addr_8007AE78", SN_NOWARN)
set_name(0x8007AEF4, "GetNumOfFrames__7TextDatii_addr_8007AEF4", SN_NOWARN)
set_name(0x8007AF2C, "GetCreature__7TextDati_addr_8007AF2C", SN_NOWARN)
set_name(0x8007AFA4, "GetNumOfCreatures__7TextDat_addr_8007AFA4", SN_NOWARN)
set_name(0x8007AFB8, "GetFr__7TextDati_addr_8007AFB8", SN_NOWARN)
set_name(0x8007AFD4, "gamemenu_on__Fv", SN_NOWARN)
set_name(0x8007AFDC, "gamemenu_off__Fv", SN_NOWARN)
set_name(0x8007AFE4, "LoadPalette__FPCc", SN_NOWARN)
set_name(0x8007AFEC, "LoadRndLvlPal__Fi", SN_NOWARN)
set_name(0x8007AFF4, "ResetPal__Fv", SN_NOWARN)
set_name(0x8007AFFC, "SetFadeLevel__Fi", SN_NOWARN)
set_name(0x8007B02C, "GetFadeState__Fv", SN_NOWARN)
set_name(0x8007B038, "DrawFadedScreen__Fv", SN_NOWARN)
set_name(0x8007B104, "BlackPalette__Fv", SN_NOWARN)
set_name(0x8007B1C0, "PaletteFadeInTask__FP4TASK", SN_NOWARN)
set_name(0x8007B244, "PaletteFadeIn__Fi", SN_NOWARN)
set_name(0x8007B29C, "PaletteFadeOutTask__FP4TASK", SN_NOWARN)
set_name(0x8007B334, "PaletteFadeOut__Fi", SN_NOWARN)
set_name(0x8007B388, "M_CheckEFlag__Fi", SN_NOWARN)
set_name(0x8007B3A8, "M_ClearSquares__Fi", SN_NOWARN)
set_name(0x8007B54C, "IsSkel__Fi", SN_NOWARN)
set_name(0x8007B588, "NewMonsterAnim__FiR10AnimStructii", SN_NOWARN)
set_name(0x8007B654, "M_Ranged__Fi", SN_NOWARN)
set_name(0x8007B6D8, "M_Talker__Fi", SN_NOWARN)
set_name(0x8007B770, "M_Enemy__Fi", SN_NOWARN)
set_name(0x8007BD74, "ClearMVars__Fi", SN_NOWARN)
set_name(0x8007BE20, "InitMonster__Fiiiii", SN_NOWARN)
set_name(0x8007C2F4, "AddMonster__FiiiiUc", SN_NOWARN)
set_name(0x8007C3A4, "M_StartStand__Fii", SN_NOWARN)
set_name(0x8007C538, "M_UpdateLeader__Fi", SN_NOWARN)
set_name(0x8007C6D8, "ActivateSpawn__Fiiii", SN_NOWARN)
set_name(0x8007C780, "SpawnSkeleton__Fiii", SN_NOWARN)
set_name(0x8007C970, "M_StartSpStand__Fii", SN_NOWARN)
set_name(0x8007CA9C, "PosOkMonst__Fiii", SN_NOWARN)
set_name(0x8007CD18, "CanPut__Fii", SN_NOWARN)
set_name(0x8007D020, "GetAutomapType__FiiUc", SN_NOWARN)
set_name(0x8007D32C, "SetAutomapView__Fii", SN_NOWARN)
set_name(0x8001F458, "TICK_InitModule", SN_NOWARN)
set_name(0x8001F478, "TICK_Set", SN_NOWARN)
set_name(0x8001F488, "TICK_Get", SN_NOWARN)
set_name(0x8001F498, "TICK_Update", SN_NOWARN)
set_name(0x8001F4B8, "TICK_GetAge", SN_NOWARN)
set_name(0x8001F4E4, "TICK_GetDateString", SN_NOWARN)
set_name(0x8001F4F4, "TICK_GetTimeString", SN_NOWARN)
set_name(0x8001F504, "GU_InitModule", SN_NOWARN)
set_name(0x8001F530, "GU_SetRndSeed", SN_NOWARN)
set_name(0x8001F560, "GU_GetRnd", SN_NOWARN)
set_name(0x8001F5F0, "GU_GetSRnd", SN_NOWARN)
set_name(0x8001F610, "GU_GetRndRange", SN_NOWARN)
set_name(0x8001F64C, "GU_AlignVal", SN_NOWARN)
set_name(0x8001F670, "main", SN_NOWARN)
set_name(0x8001F6C0, "DBG_OpenModule", SN_NOWARN)
set_name(0x8001F6C8, "DBG_PollHost", SN_NOWARN)
set_name(0x8001F6D0, "DBG_Halt", SN_NOWARN)
set_name(0x8001F6D8, "DBG_SendMessage", SN_NOWARN)
set_name(0x8001F6F0, "DBG_SetMessageHandler", SN_NOWARN)
set_name(0x8001F700, "DBG_Error", SN_NOWARN)
set_name(0x8001F72C, "DBG_SetErrorFunc", SN_NOWARN)
set_name(0x8001F73C, "SendPsyqString", SN_NOWARN)
set_name(0x8001F744, "DBG_SetPollRoutine", SN_NOWARN)
set_name(0x8001F754, "GTIMSYS_GetTimer", SN_NOWARN)
set_name(0x8001F778, "GTIMSYS_ResetTimer", SN_NOWARN)
set_name(0x8001F79C, "GTIMSYS_InitTimer", SN_NOWARN)
set_name(0x8001F9D0, "GSYS_GetWorkMemInfo", SN_NOWARN)
set_name(0x8001F9E0, "GSYS_SetStackAndJump", SN_NOWARN)
set_name(0x8001FA1C, "GSYS_MarkStack", SN_NOWARN)
set_name(0x8001FA2C, "GSYS_IsStackCorrupted", SN_NOWARN)
set_name(0x8001FA44, "GSYS_InitMachine", SN_NOWARN)
set_name(0x8001FA7C, "GSYS_CheckPtr", SN_NOWARN)
set_name(0x8001FAB0, "GSYS_IsStackOutOfBounds", SN_NOWARN)
set_name(0x8001FB2C, "GAL_SetErrorChecking", SN_NOWARN)
set_name(0x8001FB3C, "GAL_SplitBlock", SN_NOWARN)
set_name(0x8001FC70, "GAL_InitModule", SN_NOWARN)
set_name(0x8001FD28, "GAL_AddMemType", SN_NOWARN)
set_name(0x8001FE48, "GAL_Alloc", SN_NOWARN)
set_name(0x8001FFE0, "GAL_Lock", SN_NOWARN)
set_name(0x80020040, "GAL_Unlock", SN_NOWARN)
set_name(0x800200BC, "GAL_Free", SN_NOWARN)
set_name(0x8002015C, "GAL_GetFreeMem", SN_NOWARN)
set_name(0x800201D0, "GAL_GetUsedMem", SN_NOWARN)
set_name(0x80020244, "GAL_LargestFreeBlock", SN_NOWARN)
set_name(0x800202C0, "AttachHdrToList", SN_NOWARN)
set_name(0x800202E0, "DetachHdrFromList", SN_NOWARN)
set_name(0x8002032C, "IsActiveValidHandle", SN_NOWARN)
set_name(0x8002035C, "AlignPtr", SN_NOWARN)
set_name(0x8002038C, "AlignSize", SN_NOWARN)
set_name(0x800203BC, "FindClosestSizedBlock", SN_NOWARN)
set_name(0x80020414, "FindHighestMemBlock", SN_NOWARN)
set_name(0x8002047C, "FindLowestMemBlock", SN_NOWARN)
set_name(0x800204E4, "GetMemInitInfoBlockFromType", SN_NOWARN)
set_name(0x80020520, "MergeToEmptyList", SN_NOWARN)
set_name(0x800205F4, "GAL_AllocAt", SN_NOWARN)
set_name(0x800206D0, "LoAlloc", SN_NOWARN)
set_name(0x80020868, "FindBlockInTheseBounds", SN_NOWARN)
set_name(0x800208D4, "GetFreeMemHdrBlock", SN_NOWARN)
set_name(0x8002095C, "ReleaseMemHdrBlock", SN_NOWARN)
set_name(0x8002099C, "GAL_IterateEmptyMem", SN_NOWARN)
set_name(0x80020A20, "GAL_IterateUsedMem", SN_NOWARN)
set_name(0x80020ABC, "GAL_SetMemName", SN_NOWARN)
set_name(0x80020B24, "GAL_TotalMem", SN_NOWARN)
set_name(0x80020B78, "GAL_MemBase", SN_NOWARN)
set_name(0x80020BCC, "GAL_DefragMem", SN_NOWARN)
set_name(0x80020C50, "GSetError", SN_NOWARN)
set_name(0x80020CAC, "GAL_CheckMem", SN_NOWARN)
set_name(0x80020DA8, "CheckCollisions", SN_NOWARN)
set_name(0x80020E54, "AreBlocksColliding", SN_NOWARN)
set_name(0x80020EAC, "GAL_GetErrorText", SN_NOWARN)
set_name(0x80020EDC, "GAL_GetLastErrorCode", SN_NOWARN)
set_name(0x80020EEC, "GAL_GetLastErrorText", SN_NOWARN)
set_name(0x80020F14, "GAL_HowManyEmptyRegions", SN_NOWARN)
set_name(0x80020F7C, "GAL_HowManyUsedRegions", SN_NOWARN)
set_name(0x80020FE4, "GAL_SetTimeStamp", SN_NOWARN)
set_name(0x80020FF4, "GAL_IncTimeStamp", SN_NOWARN)
set_name(0x80021014, "GAL_GetTimeStamp", SN_NOWARN)
set_name(0x80021024, "GAL_AlignSizeToType", SN_NOWARN)
set_name(0x80021074, "GAL_AllocMultiStruct", SN_NOWARN)
set_name(0x800210C4, "GAL_ProcessMultiStruct", SN_NOWARN)
set_name(0x80021170, "GAL_GetSize", SN_NOWARN)
set_name(0x800211C4, "GazDefragMem", SN_NOWARN)
set_name(0x8002132C, "PutBlocksInRegionIntoList", SN_NOWARN)
set_name(0x800213D0, "CollideRegions", SN_NOWARN)
set_name(0x80021404, "DeleteEmptyBlocks", SN_NOWARN)
set_name(0x80021470, "GetRegion", SN_NOWARN)
set_name(0x80021568, "FindNextBlock", SN_NOWARN)
set_name(0x800215A4, "ShuffleBlocks", SN_NOWARN)
set_name(0x80021634, "PutAllLockedBlocksOntoList", SN_NOWARN)
set_name(0x800216B0, "SortMemHdrListByAddr", SN_NOWARN)
set_name(0x80021764, "GraftMemHdrList", SN_NOWARN)
set_name(0x800217C0, "GAL_MemDump", SN_NOWARN)
set_name(0x80021834, "GAL_SetVerbosity", SN_NOWARN)
set_name(0x80021844, "CountFreeBlocks", SN_NOWARN)
set_name(0x80021870, "SetBlockName", SN_NOWARN)
set_name(0x800218B8, "GAL_GetNumFreeHeaders", SN_NOWARN)
set_name(0x800218C8, "GAL_GetLastTypeAlloced", SN_NOWARN)
set_name(0x800218D8, "GAL_SetAllocFilter", SN_NOWARN)
set_name(0x800218F0, "GAL_SortUsedRegionsBySize", SN_NOWARN)
set_name(0x80021944, "SortSize", SN_NOWARN)
set_name(0x80021954, "SortMemHdrList", SN_NOWARN)
set_name(0x80021A44, "DoEpi", SN_NOWARN)
set_name(0x80021A94, "DoPro", SN_NOWARN)
set_name(0x80021AE4, "TSK_OpenModule", SN_NOWARN)
set_name(0x80021B58, "TSK_AddTask", SN_NOWARN)
set_name(0x80021D40, "TSK_DoTasks", SN_NOWARN)
set_name(0x80021F00, "TSK_Sleep", SN_NOWARN)
set_name(0x80021FDC, "ReturnToSchedulerIfCurrentTask", SN_NOWARN)
set_name(0x80022064, "TSK_Die", SN_NOWARN)
set_name(0x80022090, "TSK_Kill", SN_NOWARN)
set_name(0x800220E0, "TSK_GetFirstActive", SN_NOWARN)
set_name(0x800220F0, "TSK_IsStackCorrupted", SN_NOWARN)
set_name(0x8002216C, "TSK_JumpAndResetStack", SN_NOWARN)
set_name(0x800221B4, "TSK_RepointProc", SN_NOWARN)
set_name(0x800221F8, "TSK_GetCurrentTask", SN_NOWARN)
set_name(0x80022208, "TSK_IsCurrentTask", SN_NOWARN)
set_name(0x80022220, "TSK_Exist", SN_NOWARN)
set_name(0x80022278, "TSK_SetExecFilter", SN_NOWARN)
set_name(0x80022290, "TSK_ClearExecFilter", SN_NOWARN)
set_name(0x800222B4, "TSK_KillTasks", SN_NOWARN)
set_name(0x800223B4, "TSK_IterateTasks", SN_NOWARN)
set_name(0x8002242C, "TSK_MakeTaskInactive", SN_NOWARN)
set_name(0x80022440, "TSK_MakeTaskActive", SN_NOWARN)
set_name(0x80022454, "TSK_MakeTaskImmortal", SN_NOWARN)
set_name(0x80022468, "TSK_MakeTaskMortal", SN_NOWARN)
set_name(0x8002247C, "TSK_IsTaskActive", SN_NOWARN)
set_name(0x80022490, "TSK_IsTaskMortal", SN_NOWARN)
set_name(0x800224A4, "DetachFromList", SN_NOWARN)
set_name(0x800224F0, "AddToList", SN_NOWARN)
set_name(0x80022510, "LoTskKill", SN_NOWARN)
set_name(0x80022580, "ExecuteTask", SN_NOWARN)
set_name(0x800225D0, "TSK_SetDoTasksPrologue", SN_NOWARN)
set_name(0x800225E8, "TSK_SetDoTasksEpilogue", SN_NOWARN)
set_name(0x80022600, "TSK_SetTaskPrologue", SN_NOWARN)
set_name(0x80022618, "TSK_SetTaskEpilogue", SN_NOWARN)
set_name(0x80022630, "TSK_SetEpiProFilter", SN_NOWARN)
set_name(0x80022648, "TSK_ClearEpiProFilter", SN_NOWARN)
set_name(0x8002267C, "TSK_SetExtraStackProtection", SN_NOWARN)
set_name(0x8002268C, "TSK_SetStackFloodCallback", SN_NOWARN)
set_name(0x800226A4, "TSK_SetExtraStackSize", SN_NOWARN)
set_name(0x800226CC, "ExtraMarkStack", SN_NOWARN)
set_name(0x800226F8, "CheckExtraStack", SN_NOWARN)
set_name(0x80024A00, "vsprintf", SN_NOWARN)
set_name(0x80024A4C, "_doprnt", SN_NOWARN)
set_name(0x80120028, "NumOfMonsterListLevels", SN_NOWARN)
set_name(0x800A6B40, "AllLevels", SN_NOWARN)
set_name(0x8011FD50, "NumsLEV1M1A", SN_NOWARN)
set_name(0x8011FD54, "NumsLEV1M1B", SN_NOWARN)
set_name(0x8011FD58, "NumsLEV1M1C", SN_NOWARN)
set_name(0x8011FD60, "NumsLEV2M2A", SN_NOWARN)
set_name(0x8011FD64, "NumsLEV2M2B", SN_NOWARN)
set_name(0x8011FD68, "NumsLEV2M2C", SN_NOWARN)
set_name(0x8011FD6C, "NumsLEV2M2D", SN_NOWARN)
set_name(0x8011FD70, "NumsLEV2M2QA", SN_NOWARN)
set_name(0x8011FD74, "NumsLEV3M3A", SN_NOWARN)
set_name(0x8011FD78, "NumsLEV3M3QA", SN_NOWARN)
set_name(0x8011FD7C, "NumsLEV3M3B", SN_NOWARN)
set_name(0x8011FD80, "NumsLEV3M3C", SN_NOWARN)
set_name(0x8011FD84, "NumsLEV4M4A", SN_NOWARN)
set_name(0x8011FD88, "NumsLEV4M4QA", SN_NOWARN)
set_name(0x8011FD8C, "NumsLEV4M4B", SN_NOWARN)
set_name(0x8011FD90, "NumsLEV4M4QB", SN_NOWARN)
set_name(0x8011FD94, "NumsLEV4M4C", SN_NOWARN)
set_name(0x8011FD98, "NumsLEV4M4QC", SN_NOWARN)
set_name(0x8011FD9C, "NumsLEV4M4D", SN_NOWARN)
set_name(0x8011FDA0, "NumsLEV5M5A", SN_NOWARN)
set_name(0x8011FDA4, "NumsLEV5M5B", SN_NOWARN)
set_name(0x8011FDA8, "NumsLEV5M5C", SN_NOWARN)
set_name(0x8011FDAC, "NumsLEV5M5D", SN_NOWARN)
set_name(0x8011FDB0, "NumsLEV5M5E", SN_NOWARN)
set_name(0x8011FDB4, "NumsLEV5M5F", SN_NOWARN)
set_name(0x8011FDB8, "NumsLEV6M6A", SN_NOWARN)
set_name(0x8011FDC0, "NumsLEV6M6B", SN_NOWARN)
set_name(0x8011FDC4, "NumsLEV6M6C", SN_NOWARN)
set_name(0x8011FDC8, "NumsLEV6M6D", SN_NOWARN)
set_name(0x8011FDCC, "NumsLEV6M6E", SN_NOWARN)
set_name(0x8011FDD0, "NumsLEV7M7A", SN_NOWARN)
set_name(0x8011FDD4, "NumsLEV7M7B", SN_NOWARN)
set_name(0x8011FDD8, "NumsLEV7M7C", SN_NOWARN)
set_name(0x8011FDDC, "NumsLEV7M7D", SN_NOWARN)
set_name(0x8011FDE0, "NumsLEV7M7E", SN_NOWARN)
set_name(0x8011FDE4, "NumsLEV8M8QA", SN_NOWARN)
set_name(0x8011FDE8, "NumsLEV8M8A", SN_NOWARN)
set_name(0x8011FDEC, "NumsLEV8M8B", SN_NOWARN)
set_name(0x8011FDF0, "NumsLEV8M8C", SN_NOWARN)
set_name(0x8011FDF4, "NumsLEV8M8D", SN_NOWARN)
set_name(0x8011FDF8, "NumsLEV8M8E", SN_NOWARN)
set_name(0x8011FDFC, "NumsLEV9M9A", SN_NOWARN)
set_name(0x8011FE00, "NumsLEV9M9B", SN_NOWARN)
set_name(0x8011FE04, "NumsLEV9M9C", SN_NOWARN)
set_name(0x8011FE08, "NumsLEV9M9D", SN_NOWARN)
set_name(0x8011FE0C, "NumsLEV10M10A", SN_NOWARN)
set_name(0x8011FE10, "NumsLEV10M10B", SN_NOWARN)
set_name(0x8011FE14, "NumsLEV10M10C", SN_NOWARN)
set_name(0x8011FE18, "NumsLEV10M10D", SN_NOWARN)
set_name(0x8011FE1C, "NumsLEV11M11A", SN_NOWARN)
set_name(0x8011FE20, "NumsLEV11M11B", SN_NOWARN)
set_name(0x8011FE24, "NumsLEV11M11C", SN_NOWARN)
set_name(0x8011FE28, "NumsLEV11M11D", SN_NOWARN)
set_name(0x8011FE2C, "NumsLEV11M11E", SN_NOWARN)
set_name(0x8011FE30, "NumsLEV12M12A", SN_NOWARN)
set_name(0x8011FE34, "NumsLEV12M12B", SN_NOWARN)
set_name(0x8011FE38, "NumsLEV12M12C", SN_NOWARN)
set_name(0x8011FE3C, "NumsLEV12M12D", SN_NOWARN)
set_name(0x8011FE40, "NumsLEV13M13A", SN_NOWARN)
set_name(0x8011FE44, "NumsLEV13M13B", SN_NOWARN)
set_name(0x8011FE48, "NumsLEV13M13QB", SN_NOWARN)
set_name(0x8011FE4C, "NumsLEV13M13C", SN_NOWARN)
set_name(0x8011FE50, "NumsLEV13M13D", SN_NOWARN)
set_name(0x8011FE54, "NumsLEV14M14A", SN_NOWARN)
set_name(0x8011FE58, "NumsLEV14M14B", SN_NOWARN)
set_name(0x8011FE5C, "NumsLEV14M14QB", SN_NOWARN)
set_name(0x8011FE60, "NumsLEV14M14C", SN_NOWARN)
set_name(0x8011FE64, "NumsLEV14M14D", SN_NOWARN)
set_name(0x8011FE68, "NumsLEV14M14E", SN_NOWARN)
set_name(0x8011FE6C, "NumsLEV15M15A", SN_NOWARN)
set_name(0x8011FE70, "NumsLEV15M15B", SN_NOWARN)
set_name(0x8011FE74, "NumsLEV15M15C", SN_NOWARN)
set_name(0x8011FE78, "NumsLEV16M16D", SN_NOWARN)
set_name(0x800A66B0, "ChoiceListLEV1", SN_NOWARN)
set_name(0x800A66E0, "ChoiceListLEV2", SN_NOWARN)
set_name(0x800A6730, "ChoiceListLEV3", SN_NOWARN)
set_name(0x800A6770, "ChoiceListLEV4", SN_NOWARN)
set_name(0x800A67E0, "ChoiceListLEV5", SN_NOWARN)
set_name(0x800A6840, "ChoiceListLEV6", SN_NOWARN)
set_name(0x800A6890, "ChoiceListLEV7", SN_NOWARN)
set_name(0x800A68E0, "ChoiceListLEV8", SN_NOWARN)
set_name(0x800A6940, "ChoiceListLEV9", SN_NOWARN)
set_name(0x800A6980, "ChoiceListLEV10", SN_NOWARN)
set_name(0x800A69C0, "ChoiceListLEV11", SN_NOWARN)
set_name(0x800A6A10, "ChoiceListLEV12", SN_NOWARN)
set_name(0x800A6A50, "ChoiceListLEV13", SN_NOWARN)
set_name(0x800A6AA0, "ChoiceListLEV14", SN_NOWARN)
set_name(0x800A6B00, "ChoiceListLEV15", SN_NOWARN)
set_name(0x800A6B30, "ChoiceListLEV16", SN_NOWARN)
set_name(0x801216E0, "GameTaskPtr", SN_NOWARN)
set_name(0x80120038, "time_in_frames", SN_NOWARN)
set_name(0x800A6BC0, "AllArgs", SN_NOWARN)
set_name(0x8012003C, "ArgsSoFar", SN_NOWARN)
set_name(0x80120040, "ThisOt", SN_NOWARN)
set_name(0x80120044, "ThisPrimAddr", SN_NOWARN)
set_name(0x801216E4, "hndPrimBuffers", SN_NOWARN)
set_name(0x801216E8, "PrimBuffers", SN_NOWARN)
set_name(0x801216EC, "BufferDepth", SN_NOWARN)
set_name(0x801216ED, "WorkRamId", SN_NOWARN)
set_name(0x801216EE, "ScrNum", SN_NOWARN)
set_name(0x801216F0, "Screens", SN_NOWARN)
set_name(0x801216F4, "PbToClear", SN_NOWARN)
set_name(0x801216F8, "BufferNum", SN_NOWARN)
set_name(0x80120048, "AddrToAvoid", SN_NOWARN)
set_name(0x801216F9, "LastBuffer", SN_NOWARN)
set_name(0x801216FC, "DispEnvToPut", SN_NOWARN)
set_name(0x80121700, "ThisOtSize", SN_NOWARN)
set_name(0x8012004C, "ScrRect", SN_NOWARN)
set_name(0x80121704, "VidWait", SN_NOWARN)
set_name(0x80121B98, "screen", SN_NOWARN)
set_name(0x80121708, "VbFunc", SN_NOWARN)
set_name(0x8012170C, "VidTick", SN_NOWARN)
set_name(0x80121710, "VXOff", SN_NOWARN)
set_name(0x80121714, "VYOff", SN_NOWARN)
set_name(0x80120060, "Gaz", SN_NOWARN)
set_name(0x80120064, "LastFmem", SN_NOWARN)
set_name(0x80120054, "GSYS_MemStart", SN_NOWARN)
set_name(0x80120058, "GSYS_MemEnd", SN_NOWARN)
set_name(0x800A6F08, "PsxMem", SN_NOWARN)
set_name(0x800A6F30, "PsxFastMem", SN_NOWARN)
set_name(0x8012005C, "LowestFmem", SN_NOWARN)
set_name(0x80120074, "FileSYS", SN_NOWARN)
set_name(0x80121718, "FileSystem", SN_NOWARN)
set_name(0x8012171C, "OverlayFileSystem", SN_NOWARN)
set_name(0x8012008E, "DavesPad", SN_NOWARN)
set_name(0x80120090, "DavesPadDeb", SN_NOWARN)
set_name(0x800A6F58, "_6FileIO_FileToLoad", SN_NOWARN)
set_name(0x80121C78, "MyFT4", SN_NOWARN)
set_name(0x801200E0, "TpW", SN_NOWARN)
set_name(0x801200E4, "TpH", SN_NOWARN)
set_name(0x801200E8, "TpXDest", SN_NOWARN)
set_name(0x801200EC, "TpYDest", SN_NOWARN)
set_name(0x801200F0, "R", SN_NOWARN)
set_name(0x800AE21C, "MyGT4", SN_NOWARN)
set_name(0x800AE250, "MyGT3", SN_NOWARN)
set_name(0x800A6F8C, "AllDats", SN_NOWARN)
set_name(0x80120104, "ChunkGot", SN_NOWARN)
set_name(0x800AE278, "STREAM_DIR", SN_NOWARN)
set_name(0x800AE288, "STREAM_BIN", SN_NOWARN)
set_name(0x800AE298, "EAC_DirectoryCache", SN_NOWARN)
set_name(0x80120118, "BL_NoLumpFiles", SN_NOWARN)
set_name(0x8012011C, "BL_NoStreamFiles", SN_NOWARN)
set_name(0x80120120, "LFileTab", SN_NOWARN)
set_name(0x80120124, "SFileTab", SN_NOWARN)
set_name(0x80120128, "FileLoaded", SN_NOWARN)
set_name(0x80120158, "NoTAllocs", SN_NOWARN)
set_name(0x800AE3C4, "MemBlock", SN_NOWARN)
set_name(0x80121728, "CanPause", SN_NOWARN)
set_name(0x8012172C, "Paused", SN_NOWARN)
set_name(0x80121730, "PRect", SN_NOWARN)
set_name(0x80121CA0, "PBack", SN_NOWARN)
set_name(0x800AE62C, "RawPadData0", SN_NOWARN)
set_name(0x800AE650, "RawPadData1", SN_NOWARN)
set_name(0x800AE674, "demo_buffer", SN_NOWARN)
set_name(0x80120184, "demo_pad_time", SN_NOWARN)
set_name(0x80120188, "demo_pad_count", SN_NOWARN)
set_name(0x800AE554, "Pad0", SN_NOWARN)
set_name(0x800AE5C0, "Pad1", SN_NOWARN)
set_name(0x8012018C, "demo_finish", SN_NOWARN)
set_name(0x80120190, "cac_pad", SN_NOWARN)
set_name(0x801201AC, "CharFt4", SN_NOWARN)
set_name(0x801201B0, "CharGt4", SN_NOWARN)
set_name(0x801201B4, "CharFrm", SN_NOWARN)
set_name(0x8012019D, "WHITER", SN_NOWARN)
set_name(0x8012019E, "WHITEG", SN_NOWARN)
set_name(0x8012019F, "WHITEB", SN_NOWARN)
set_name(0x801201A0, "BLUER", SN_NOWARN)
set_name(0x801201A1, "BLUEG", SN_NOWARN)
set_name(0x801201A2, "BLUEB", SN_NOWARN)
set_name(0x801201A3, "REDR", SN_NOWARN)
set_name(0x801201A4, "REDG", SN_NOWARN)
set_name(0x801201A5, "REDB", SN_NOWARN)
set_name(0x801201A6, "GOLDR", SN_NOWARN)
set_name(0x801201A7, "GOLDG", SN_NOWARN)
set_name(0x801201A8, "GOLDB", SN_NOWARN)
set_name(0x800AED7C, "MediumFont", SN_NOWARN)
set_name(0x800AEF94, "LargeFont", SN_NOWARN)
set_name(0x800AF1AC, "LFontTab", SN_NOWARN)
set_name(0x800AF260, "LFont", SN_NOWARN)
set_name(0x800AF270, "MFontTab", SN_NOWARN)
set_name(0x800AF3A0, "MFont", SN_NOWARN)
set_name(0x801201C9, "DialogRed", SN_NOWARN)
set_name(0x801201CA, "DialogGreen", SN_NOWARN)
set_name(0x801201CB, "DialogBlue", SN_NOWARN)
set_name(0x801201CC, "DialogTRed", SN_NOWARN)
set_name(0x801201CD, "DialogTGreen", SN_NOWARN)
set_name(0x801201CE, "DialogTBlue", SN_NOWARN)
set_name(0x801201D0, "DialogTData", SN_NOWARN)
set_name(0x801201D4, "DialogBackGfx", SN_NOWARN)
set_name(0x801201D8, "DialogBackW", SN_NOWARN)
set_name(0x801201DC, "DialogBackH", SN_NOWARN)
set_name(0x801201E0, "DialogBorderGfx", SN_NOWARN)
set_name(0x801201E4, "DialogBorderTLW", SN_NOWARN)
set_name(0x801201E8, "DialogBorderTLH", SN_NOWARN)
set_name(0x801201EC, "DialogBorderTRW", SN_NOWARN)
set_name(0x801201F0, "DialogBorderTRH", SN_NOWARN)
set_name(0x801201F4, "DialogBorderBLW", SN_NOWARN)
set_name(0x801201F8, "DialogBorderBLH", SN_NOWARN)
set_name(0x801201FC, "DialogBorderBRW", SN_NOWARN)
set_name(0x80120200, "DialogBorderBRH", SN_NOWARN)
set_name(0x80120204, "DialogBorderTW", SN_NOWARN)
set_name(0x80120208, "DialogBorderTH", SN_NOWARN)
set_name(0x8012020C, "DialogBorderBW", SN_NOWARN)
set_name(0x80120210, "DialogBorderBH", SN_NOWARN)
set_name(0x80120214, "DialogBorderLW", SN_NOWARN)
set_name(0x80120218, "DialogBorderLH", SN_NOWARN)
set_name(0x8012021C, "DialogBorderRW", SN_NOWARN)
set_name(0x80120220, "DialogBorderRH", SN_NOWARN)
set_name(0x80120224, "DialogBevelGfx", SN_NOWARN)
set_name(0x80120228, "DialogBevelCW", SN_NOWARN)
set_name(0x8012022C, "DialogBevelCH", SN_NOWARN)
set_name(0x80120230, "DialogBevelLRW", SN_NOWARN)
set_name(0x80120234, "DialogBevelLRH", SN_NOWARN)
set_name(0x80120238, "DialogBevelUDW", SN_NOWARN)
set_name(0x8012023C, "DialogBevelUDH", SN_NOWARN)
set_name(0x80120240, "MY_DialogOTpos", SN_NOWARN)
set_name(0x80121738, "DialogGBack", SN_NOWARN)
set_name(0x80121739, "GShadeX", SN_NOWARN)
set_name(0x8012173A, "GShadeY", SN_NOWARN)
set_name(0x80121740, "RandBTab", SN_NOWARN)
set_name(0x800AF3F0, "Cxy", SN_NOWARN)
set_name(0x801201C3, "BORDERR", SN_NOWARN)
set_name(0x801201C4, "BORDERG", SN_NOWARN)
set_name(0x801201C5, "BORDERB", SN_NOWARN)
set_name(0x801201C6, "BACKR", SN_NOWARN)
set_name(0x801201C7, "BACKG", SN_NOWARN)
set_name(0x801201C8, "BACKB", SN_NOWARN)
set_name(0x800AF3B0, "GShadeTab", SN_NOWARN)
set_name(0x801201C1, "GShadePX", SN_NOWARN)
set_name(0x801201C2, "GShadePY", SN_NOWARN)
set_name(0x8012024D, "PlayDemoFlag", SN_NOWARN)
set_name(0x80121CB0, "rgbb", SN_NOWARN)
set_name(0x80121CE0, "rgbt", SN_NOWARN)
set_name(0x80121748, "blockr", SN_NOWARN)
set_name(0x8012174C, "blockg", SN_NOWARN)
set_name(0x80121750, "blockb", SN_NOWARN)
set_name(0x80121754, "InfraFlag", SN_NOWARN)
set_name(0x80120259, "P1ObjSelCount", SN_NOWARN)
set_name(0x8012025A, "P2ObjSelCount", SN_NOWARN)
set_name(0x8012025B, "P12ObjSelCount", SN_NOWARN)
set_name(0x8012025C, "P1ItemSelCount", SN_NOWARN)
set_name(0x8012025D, "P2ItemSelCount", SN_NOWARN)
set_name(0x8012025E, "P12ItemSelCount", SN_NOWARN)
set_name(0x8012025F, "P1MonstSelCount", SN_NOWARN)
set_name(0x80120260, "P2MonstSelCount", SN_NOWARN)
set_name(0x80120261, "P12MonstSelCount", SN_NOWARN)
set_name(0x80120262, "P1ObjSelCol", SN_NOWARN)
set_name(0x80120264, "P2ObjSelCol", SN_NOWARN)
set_name(0x80120266, "P12ObjSelCol", SN_NOWARN)
set_name(0x80120268, "P1ItemSelCol", SN_NOWARN)
set_name(0x8012026A, "P2ItemSelCol", SN_NOWARN)
set_name(0x8012026C, "P12ItemSelCol", SN_NOWARN)
set_name(0x8012026E, "P1MonstSelCol", SN_NOWARN)
set_name(0x80120270, "P2MonstSelCol", SN_NOWARN)
set_name(0x80120272, "P12MonstSelCol", SN_NOWARN)
set_name(0x80120274, "CurrentBlocks", SN_NOWARN)
set_name(0x80115E40, "SinTab", SN_NOWARN)
set_name(0x800AF460, "TownConv", SN_NOWARN)
set_name(0x80120288, "mypaloff", SN_NOWARN)
set_name(0x80115ECC, "HaltTab", SN_NOWARN)
set_name(0x80121D10, "FrontEndOver", SN_NOWARN)
set_name(0x80121D20, "PregameOver", SN_NOWARN)
set_name(0x80121D30, "GameOver", SN_NOWARN)
set_name(0x80121758, "OWorldX", SN_NOWARN)
set_name(0x8012175C, "OWorldY", SN_NOWARN)
set_name(0x80121760, "WWorldX", SN_NOWARN)
set_name(0x80121764, "WWorldY", SN_NOWARN)
set_name(0x80115F48, "TxyAdd", SN_NOWARN)
set_name(0x801202AC, "GXAdj2", SN_NOWARN)
set_name(0x80121768, "TimePerFrame", SN_NOWARN)
set_name(0x8012176C, "CpuStart", SN_NOWARN)
set_name(0x80121770, "CpuTime", SN_NOWARN)
set_name(0x80121774, "DrawTime", SN_NOWARN)
set_name(0x80121778, "DrawStart", SN_NOWARN)
set_name(0x8012177C, "LastCpuTime", SN_NOWARN)
set_name(0x80121780, "LastDrawTime", SN_NOWARN)
set_name(0x80121784, "DrawArea", SN_NOWARN)
set_name(0x801202B4, "ProfOn", SN_NOWARN)
set_name(0x800AF474, "LevPals", SN_NOWARN)
set_name(0x8011608C, "Level2Bgdata", SN_NOWARN)
set_name(0x800AF488, "DefP1PanelXY", SN_NOWARN)
set_name(0x800AF4DC, "DefP1PanelXY2", SN_NOWARN)
set_name(0x800AF530, "DefP2PanelXY", SN_NOWARN)
set_name(0x800AF584, "DefP2PanelXY2", SN_NOWARN)
set_name(0x800AF5D8, "SpeedBarGfxTable", SN_NOWARN)
set_name(0x801202DC, "hof", SN_NOWARN)
set_name(0x801202E0, "mof", SN_NOWARN)
set_name(0x800AF6A0, "SFXTab", SN_NOWARN)
set_name(0x80120314, "Time", SN_NOWARN)
set_name(0x800AF7A0, "voice_attr", SN_NOWARN)
set_name(0x801202F0, "STR_Buffer", SN_NOWARN)
set_name(0x801202F4, "NoActiveStreams", SN_NOWARN)
set_name(0x801202F8, "STRInit", SN_NOWARN)
set_name(0x80120338, "SFXNotPlayed", SN_NOWARN)
set_name(0x80120339, "SFXNotInBank", SN_NOWARN)
set_name(0x80121D40, "spu_management", SN_NOWARN)
set_name(0x80121E50, "rev_attr", SN_NOWARN)
set_name(0x8012178C, "NoSfx", SN_NOWARN)
set_name(0x80120324, "BankOffsets", SN_NOWARN)
set_name(0x80120328, "OffsetHandle", SN_NOWARN)
set_name(0x8012032C, "BankBase", SN_NOWARN)
set_name(0x80120330, "SPU_Done", SN_NOWARN)
set_name(0x80116450, "SFXRemapTab", SN_NOWARN)
set_name(0x80120334, "NoSNDRemaps", SN_NOWARN)
set_name(0x800AF7E0, "ThePals", SN_NOWARN)
set_name(0x80116534, "InitialPositions", SN_NOWARN)
set_name(0x80120380, "demo_level", SN_NOWARN)
set_name(0x80120384, "DemoTask", SN_NOWARN)
set_name(0x80120388, "DemoGameTask", SN_NOWARN)
set_name(0x8012038C, "tonys", SN_NOWARN)
set_name(0x80120364, "demo_load", SN_NOWARN)
set_name(0x80120368, "demo_record_load", SN_NOWARN)
set_name(0x8012036C, "level_record", SN_NOWARN)
set_name(0x80120360, "moo_moo", SN_NOWARN)
set_name(0x80120370, "demo_flash", SN_NOWARN)
set_name(0x80120374, "tonys_Task", SN_NOWARN)
set_name(0x801204E8, "DoShowPanel", SN_NOWARN)
set_name(0x801204EC, "DoDrawBg", SN_NOWARN)
set_name(0x80121790, "GlueFinished", SN_NOWARN)
set_name(0x80121794, "DoHomingScroll", SN_NOWARN)
set_name(0x80121798, "TownerGfx", SN_NOWARN)
set_name(0x8012179C, "CurrentMonsterList", SN_NOWARN)
set_name(0x80120399, "started_grtask", SN_NOWARN)
set_name(0x800AF96C, "PlayerInfo", SN_NOWARN)
set_name(0x801204F0, "ArmourChar", SN_NOWARN)
set_name(0x80116618, "WepChar", SN_NOWARN)
set_name(0x801204F4, "CharChar", SN_NOWARN)
set_name(0x801217A0, "ctrl_select_line", SN_NOWARN)
set_name(0x801217A1, "ctrl_select_side", SN_NOWARN)
set_name(0x801217A2, "ckeyheld", SN_NOWARN)
set_name(0x801217A4, "old_options_pad", SN_NOWARN)
set_name(0x801217A8, "CtrlRect", SN_NOWARN)
set_name(0x80120508, "ctrlflag", SN_NOWARN)
set_name(0x800AFC9C, "txt_actions", SN_NOWARN)
set_name(0x800AFBF4, "pad_txt", SN_NOWARN)
set_name(0x80120504, "CtrlBorder", SN_NOWARN)
set_name(0x80121E68, "CtrlScreen", SN_NOWARN)
set_name(0x80121EE8, "CtrlBack", SN_NOWARN)
set_name(0x800AFDDC, "controller_defaults", SN_NOWARN)
set_name(0x8012056C, "gr_scrxoff", SN_NOWARN)
set_name(0x80120570, "gr_scryoff", SN_NOWARN)
set_name(0x80120578, "water_clut", SN_NOWARN)
set_name(0x8012057C, "visible_level", SN_NOWARN)
set_name(0x80120569, "last_type", SN_NOWARN)
set_name(0x8012057E, "daylight", SN_NOWARN)
set_name(0x8012057A, "cow_in_sight", SN_NOWARN)
set_name(0x8012057B, "inn_in_sight", SN_NOWARN)
set_name(0x80120574, "water_count", SN_NOWARN)
set_name(0x8012057D, "lastrnd", SN_NOWARN)
set_name(0x80120580, "call_clock", SN_NOWARN)
set_name(0x80120590, "TitleAnimCount", SN_NOWARN)
set_name(0x801166E0, "light_tile", SN_NOWARN)
set_name(0x801205F4, "p1scrnx", SN_NOWARN)
set_name(0x801205F8, "p1scrny", SN_NOWARN)
set_name(0x801205FC, "p1wrldx", SN_NOWARN)
set_name(0x80120600, "p1wrldy", SN_NOWARN)
set_name(0x80120604, "p2scrnx", SN_NOWARN)
set_name(0x80120608, "p2scrny", SN_NOWARN)
set_name(0x8012060C, "p2wrldx", SN_NOWARN)
set_name(0x80120610, "p2wrldy", SN_NOWARN)
set_name(0x801217B0, "p1spiny1", SN_NOWARN)
set_name(0x801217B4, "p1spiny2", SN_NOWARN)
set_name(0x801217B8, "p1scale", SN_NOWARN)
set_name(0x801217BC, "p1apocaflag", SN_NOWARN)
set_name(0x801217C0, "p1apocaxpos", SN_NOWARN)
set_name(0x801217C4, "p1apocaypos", SN_NOWARN)
set_name(0x801217C8, "p2spiny1", SN_NOWARN)
set_name(0x801217CC, "p2spiny2", SN_NOWARN)
set_name(0x801217D0, "p2scale", SN_NOWARN)
set_name(0x801217D4, "p2apocaflag", SN_NOWARN)
set_name(0x801217D8, "p2apocaxpos", SN_NOWARN)
set_name(0x801217DC, "p2apocaypos", SN_NOWARN)
set_name(0x80121EF8, "PartArray", SN_NOWARN)
set_name(0x801217E0, "partOtPos", SN_NOWARN)
set_name(0x801205AC, "p1teleflag", SN_NOWARN)
set_name(0x801205B0, "p1phaseflag", SN_NOWARN)
set_name(0x801205B4, "p1inviscount", SN_NOWARN)
set_name(0x801205B8, "p2teleflag", SN_NOWARN)
set_name(0x801205BC, "p2phaseflag", SN_NOWARN)
set_name(0x801205C0, "p2inviscount", SN_NOWARN)
set_name(0x801205C4, "SetParticle", SN_NOWARN)
set_name(0x801205C8, "p1partexecnum", SN_NOWARN)
set_name(0x801205CC, "p2partexecnum", SN_NOWARN)
set_name(0x800AFE7C, "JumpArray", SN_NOWARN)
set_name(0x801205D0, "partjumpflag", SN_NOWARN)
set_name(0x801205D4, "partglowflag", SN_NOWARN)
set_name(0x801205D8, "partcolour", SN_NOWARN)
set_name(0x801205DC, "healflag", SN_NOWARN)
set_name(0x801205E0, "healtime", SN_NOWARN)
set_name(0x801205E4, "healplyr", SN_NOWARN)
set_name(0x8012064D, "select_flag", SN_NOWARN)
set_name(0x801217E4, "SelectRect", SN_NOWARN)
set_name(0x801217EC, "item_select", SN_NOWARN)
set_name(0x800AFE9C, "_psplxpos", SN_NOWARN)
set_name(0x800AFEA8, "_psplypos", SN_NOWARN)
set_name(0x80120650, "_psplpos", SN_NOWARN)
set_name(0x80120654, "spl_maxrad", SN_NOWARN)
set_name(0x80120658, "splangle", SN_NOWARN)
set_name(0x80120620, "gplayer", SN_NOWARN)
set_name(0x80120624, "_pSplTargetX", SN_NOWARN)
set_name(0x80120628, "_pSplTargetY", SN_NOWARN)
set_name(0x8012062C, "_pTargetSpell", SN_NOWARN)
set_name(0x80122138, "SelectBack", SN_NOWARN)
set_name(0x80120630, "_pspotid", SN_NOWARN)
set_name(0x80120638, "QSpell", SN_NOWARN)
set_name(0x80120640, "_spltotype", SN_NOWARN)
set_name(0x80120644, "mana_order", SN_NOWARN)
set_name(0x80120648, "health_order", SN_NOWARN)
set_name(0x8012064C, "birdcheck", SN_NOWARN)
set_name(0x80122148, "DecRequestors", SN_NOWARN)
set_name(0x801217F0, "progress", SN_NOWARN)
set_name(0x801167F0, "Level2CutScreen", SN_NOWARN)
set_name(0x80120678, "CutString", SN_NOWARN)
set_name(0x80122170, "Scr", SN_NOWARN)
set_name(0x8012067C, "CutScreenTSK", SN_NOWARN)
set_name(0x80120680, "GameLoading", SN_NOWARN)
set_name(0x801221F0, "LBack", SN_NOWARN)
set_name(0x80120690, "card_ev0", SN_NOWARN)
set_name(0x80120694, "card_ev1", SN_NOWARN)
set_name(0x80120698, "card_ev2", SN_NOWARN)
set_name(0x8012069C, "card_ev3", SN_NOWARN)
set_name(0x801206A0, "card_ev10", SN_NOWARN)
set_name(0x801206A4, "card_ev11", SN_NOWARN)
set_name(0x801206A8, "card_ev12", SN_NOWARN)
set_name(0x801206AC, "card_ev13", SN_NOWARN)
set_name(0x801206B0, "card_dirty", SN_NOWARN)
set_name(0x801206B8, "MemcardTask", SN_NOWARN)
set_name(0x801206BC, "card_event", SN_NOWARN)
set_name(0x8012068C, "mem_card_event_handler", SN_NOWARN)
set_name(0x80120684, "MemCardActive", SN_NOWARN)
set_name(0x80120688, "never_hooked_events", SN_NOWARN)
set_name(0x801217F4, "MasterVol", SN_NOWARN)
set_name(0x801217F8, "MusicVol", SN_NOWARN)
set_name(0x801217FC, "SoundVol", SN_NOWARN)
set_name(0x80121800, "VideoVol", SN_NOWARN)
set_name(0x80121804, "SpeechVol", SN_NOWARN)
set_name(0x80121808, "Slider", SN_NOWARN)
set_name(0x8012180C, "sw", SN_NOWARN)
set_name(0x80121810, "sx", SN_NOWARN)
set_name(0x80121814, "sy", SN_NOWARN)
set_name(0x80121818, "Adjust", SN_NOWARN)
set_name(0x80121819, "qspin", SN_NOWARN)
set_name(0x8012181A, "lqspin", SN_NOWARN)
set_name(0x8012181C, "OrigLang", SN_NOWARN)
set_name(0x80121820, "OldLang", SN_NOWARN)
set_name(0x80121824, "NewLang", SN_NOWARN)
set_name(0x80120768, "ReturnMenu", SN_NOWARN)
set_name(0x8012182C, "ORect", SN_NOWARN)
set_name(0x801206E4, "optionsflag", SN_NOWARN)
set_name(0x801206D8, "cmenu", SN_NOWARN)
set_name(0x801206EC, "options_pad", SN_NOWARN)
set_name(0x801206F0, "PrevTxt", SN_NOWARN)
set_name(0x801206E0, "allspellsflag", SN_NOWARN)
set_name(0x800B0580, "Circle", SN_NOWARN)
set_name(0x801206CC, "Spacing", SN_NOWARN)
set_name(0x801206D0, "cs", SN_NOWARN)
set_name(0x801206D4, "lastcs", SN_NOWARN)
set_name(0x801206DC, "MemcardOverlay", SN_NOWARN)
set_name(0x801206E8, "saveflag", SN_NOWARN)
set_name(0x80121834, "McState", SN_NOWARN)
set_name(0x801206F4, "BlankEntry", SN_NOWARN)
set_name(0x800AFEB4, "MainMenu", SN_NOWARN)
set_name(0x800AFF5C, "GameMenu", SN_NOWARN)
set_name(0x800B001C, "SoundMenu", SN_NOWARN)
set_name(0x800B00AC, "CentreMenu", SN_NOWARN)
set_name(0x800B0154, "LangMenu", SN_NOWARN)
set_name(0x800B01FC, "MemcardMenu", SN_NOWARN)
set_name(0x800B025C, "MemcardGameMenu", SN_NOWARN)
set_name(0x800B02EC, "MemcardCharacterMenu", SN_NOWARN)
set_name(0x800B034C, "MemcardSelectCard1", SN_NOWARN)
set_name(0x800B03F4, "MemcardSelectCard2", SN_NOWARN)
set_name(0x800B049C, "MemcardFormatMenu", SN_NOWARN)
set_name(0x800B04FC, "MenuList", SN_NOWARN)
set_name(0x8012074C, "debounce", SN_NOWARN)
set_name(0x80120750, "pu", SN_NOWARN)
set_name(0x80120754, "pd", SN_NOWARN)
set_name(0x80120758, "pl", SN_NOWARN)
set_name(0x8012075C, "pr", SN_NOWARN)
set_name(0x80120760, "uc", SN_NOWARN)
set_name(0x80120761, "dc", SN_NOWARN)
set_name(0x80120762, "lc", SN_NOWARN)
set_name(0x80120763, "rc", SN_NOWARN)
set_name(0x80120764, "centrestep", SN_NOWARN)
set_name(0x800B0600, "BirdList", SN_NOWARN)
set_name(0x80120775, "hop_height", SN_NOWARN)
set_name(0x80120778, "perches", SN_NOWARN)
set_name(0x80120870, "FeBackX", SN_NOWARN)
set_name(0x80120874, "FeBackY", SN_NOWARN)
set_name(0x80120878, "FeBackW", SN_NOWARN)
set_name(0x8012087C, "FeBackH", SN_NOWARN)
set_name(0x80120880, "FeFlag", SN_NOWARN)
set_name(0x800B09E8, "FeBuffer", SN_NOWARN)
set_name(0x8012183C, "CStruct", SN_NOWARN)
set_name(0x80120884, "FeBufferCount", SN_NOWARN)
set_name(0x80120888, "FeNoOfPlayers", SN_NOWARN)
set_name(0x8012088C, "FePlayerNo", SN_NOWARN)
set_name(0x80120890, "FeChrClass", SN_NOWARN)
set_name(0x800B0DA8, "FePlayerName", SN_NOWARN)
set_name(0x80120898, "FeCurMenu", SN_NOWARN)
set_name(0x8012089C, "FeBackScreen", SN_NOWARN)
set_name(0x801208A0, "FePlayerNameFlag", SN_NOWARN)
set_name(0x801208A4, "FeCount", SN_NOWARN)
set_name(0x801208A8, "fileselect", SN_NOWARN)
set_name(0x801208AC, "BookMenu", SN_NOWARN)
set_name(0x801208B0, "FeAttractMode", SN_NOWARN)
set_name(0x801208B4, "FMVPress", SN_NOWARN)
set_name(0x8012078C, "FeTData", SN_NOWARN)
set_name(0x800B0780, "LogoFmv", SN_NOWARN)
set_name(0x800B07A0, "EndFmv", SN_NOWARN)
set_name(0x800B07C0, "IntroFmv", SN_NOWARN)
set_name(0x800B07E0, "LazFmv", SN_NOWARN)
set_name(0x800B0800, "Vic1Fmv", SN_NOWARN)
set_name(0x800B0820, "Vic2Fmv", SN_NOWARN)
set_name(0x800B0840, "Vic3Fmv", SN_NOWARN)
set_name(0x80120790, "FlameTData", SN_NOWARN)
set_name(0x80120794, "FeIsAVirgin", SN_NOWARN)
set_name(0x80120798, "FeMenuDelay", SN_NOWARN)
set_name(0x800B0860, "DummyMenu", SN_NOWARN)
set_name(0x800B087C, "FeMainMenu", SN_NOWARN)
set_name(0x800B0898, "FeNewGameMenu", SN_NOWARN)
set_name(0x800B08B4, "FeNewP1ClassMenu", SN_NOWARN)
set_name(0x800B08D0, "FeNewP1NameMenu", SN_NOWARN)
set_name(0x800B08EC, "FeNewP2ClassMenu", SN_NOWARN)
set_name(0x800B0908, "FeNewP2NameMenu", SN_NOWARN)
set_name(0x800B0924, "FeDifficultyMenu", SN_NOWARN)
set_name(0x800B0940, "FeBackgroundMenu", SN_NOWARN)
set_name(0x800B095C, "FeBook1Menu", SN_NOWARN)
set_name(0x800B0978, "FeBook2Menu", SN_NOWARN)
set_name(0x800B0994, "FeLoadCharMenu", SN_NOWARN)
set_name(0x800B09B0, "FeLoadChar1Menu", SN_NOWARN)
set_name(0x800B09CC, "FeLoadChar2Menu", SN_NOWARN)
set_name(0x8012079C, "LoadErrorText", SN_NOWARN)
set_name(0x80120864, "AttractTitleDelay", SN_NOWARN)
set_name(0x80120868, "AttractMainDelay", SN_NOWARN)
set_name(0x8012086C, "FMVEndPad", SN_NOWARN)
set_name(0x801208E8, "InCredits", SN_NOWARN)
set_name(0x801208EC, "CreditTitleNo", SN_NOWARN)
set_name(0x801208F0, "CreditSubTitleNo", SN_NOWARN)
set_name(0x80121840, "t1", SN_NOWARN)
set_name(0x80121844, "t2", SN_NOWARN)
set_name(0x80122200, "draw", SN_NOWARN)
set_name(0x801222C0, "dec", SN_NOWARN)
set_name(0x80121848, "oldHeapbase", SN_NOWARN)
set_name(0x8012184C, "oldVolume", SN_NOWARN)
set_name(0x80121850, "ringName", SN_NOWARN)
set_name(0x80120920, "ringSH", SN_NOWARN)
set_name(0x80120924, "FMVStream", SN_NOWARN)
set_name(0x80121854, "DCTTab", SN_NOWARN)
set_name(0x801208FE, "firstFrame", SN_NOWARN)
set_name(0x80120900, "numSkipped", SN_NOWARN)
set_name(0x80120902, "prevFrameNum", SN_NOWARN)
set_name(0x80120904, "maxRunLevel", SN_NOWARN)
set_name(0x80120908, "ringBuf", SN_NOWARN)
set_name(0x8012090C, "ringcount", SN_NOWARN)
set_name(0x80120910, "ringpos", SN_NOWARN)
set_name(0x80120914, "ringsec", SN_NOWARN)
set_name(0x80120918, "ringHnd", SN_NOWARN)
set_name(0x8012091C, "SecGot", SN_NOWARN)
set_name(0x80120938, "card_status", SN_NOWARN)
set_name(0x80120940, "card_usable", SN_NOWARN)
set_name(0x80120948, "card_files", SN_NOWARN)
set_name(0x80120950, "card_changed", SN_NOWARN)
set_name(0x801209C8, "AlertTxt", SN_NOWARN)
set_name(0x801209CC, "current_card", SN_NOWARN)
set_name(0x801209D0, "LoadType", SN_NOWARN)
set_name(0x801209D4, "McMenuPos", SN_NOWARN)
set_name(0x801209D8, "McCurMenu", SN_NOWARN)
set_name(0x80120984, "OText3", SN_NOWARN)
set_name(0x801209C4, "fileinfoflag", SN_NOWARN)
set_name(0x801209A0, "DiabloGameFile", SN_NOWARN)
set_name(0x80120968, "Text3", SN_NOWARN)
set_name(0x80120980, "OText2", SN_NOWARN)
set_name(0x80120988, "OText4", SN_NOWARN)
set_name(0x8012098C, "OText5", SN_NOWARN)
set_name(0x80120990, "OText7", SN_NOWARN)
set_name(0x80120994, "OText8", SN_NOWARN)
set_name(0x80120998, "SaveError", SN_NOWARN)
set_name(0x80120964, "Text1", SN_NOWARN)
set_name(0x8012096C, "Text5", SN_NOWARN)
set_name(0x80120970, "Text6", SN_NOWARN)
set_name(0x80120974, "Text7", SN_NOWARN)
set_name(0x80120978, "Text8", SN_NOWARN)
set_name(0x8012097C, "Text9", SN_NOWARN)
set_name(0x8012099C, "ContText", SN_NOWARN)
set_name(0x801209BC, "McState_addr_801209BC", SN_NOWARN)
set_name(0x80120A78, "pStatusPanel", SN_NOWARN)
set_name(0x80120A7C, "pGBoxBuff", SN_NOWARN)
set_name(0x80120A80, "dropGoldFlag", SN_NOWARN)
set_name(0x80120A84, "_pinfoflag", SN_NOWARN)
set_name(0x800B13A0, "_infostr", SN_NOWARN)
set_name(0x80120A88, "_infoclr", SN_NOWARN)
set_name(0x800B15A0, "tempstr", SN_NOWARN)
set_name(0x80120A8A, "drawhpflag", SN_NOWARN)
set_name(0x80120A8B, "drawmanaflag", SN_NOWARN)
set_name(0x80120A8C, "chrflag", SN_NOWARN)
set_name(0x80120A8D, "drawbtnflag", SN_NOWARN)
set_name(0x80120A8E, "panbtndown", SN_NOWARN)
set_name(0x80120A8F, "panelflag", SN_NOWARN)
set_name(0x80120A90, "chrbtndown", SN_NOWARN)
set_name(0x80120A91, "lvlbtndown", SN_NOWARN)
set_name(0x80120A92, "sbookflag", SN_NOWARN)
set_name(0x80120A93, "talkflag", SN_NOWARN)
set_name(0x80120A94, "dropGoldValue", SN_NOWARN)
set_name(0x80120A98, "initialDropGoldValue", SN_NOWARN)
set_name(0x80120A9C, "initialDropGoldIndex", SN_NOWARN)
set_name(0x80120AA0, "pPanelButtons", SN_NOWARN)
set_name(0x80120AA4, "pPanelText", SN_NOWARN)
set_name(0x80120AA8, "pManaBuff", SN_NOWARN)
set_name(0x80120AAC, "pLifeBuff", SN_NOWARN)
set_name(0x80120AB0, "pChrPanel", SN_NOWARN)
set_name(0x80120AB4, "pChrButtons", SN_NOWARN)
set_name(0x80120AB8, "pSpellCels", SN_NOWARN)
set_name(0x80122338, "_panelstr", SN_NOWARN)
set_name(0x80122738, "_pstrjust", SN_NOWARN)
set_name(0x80121858, "_pnumlines", SN_NOWARN)
set_name(0x80120ABC, "InfoBoxRect", SN_NOWARN)
set_name(0x80120AC0, "CSRect", SN_NOWARN)
set_name(0x80121868, "_pSpell", SN_NOWARN)
set_name(0x80121870, "_pSplType", SN_NOWARN)
set_name(0x80121878, "panbtn", SN_NOWARN)
set_name(0x80120AC8, "numpanbtns", SN_NOWARN)
set_name(0x80120ACC, "pDurIcons", SN_NOWARN)
set_name(0x80120AD0, "drawdurflag", SN_NOWARN)
set_name(0x80121880, "chrbtn", SN_NOWARN)
set_name(0x80120AD1, "chrbtnactive", SN_NOWARN)
set_name(0x80120AD4, "pSpellBkCel", SN_NOWARN)
set_name(0x80120AD8, "pSBkBtnCel", SN_NOWARN)
set_name(0x80120ADC, "pSBkIconCels", SN_NOWARN)
set_name(0x80120AE0, "sbooktab", SN_NOWARN)
set_name(0x80120AE4, "cur_spel", SN_NOWARN)
set_name(0x80121884, "talkofs", SN_NOWARN)
set_name(0x80122788, "sgszTalkMsg", SN_NOWARN)
set_name(0x80121888, "sgbTalkSavePos", SN_NOWARN)
set_name(0x80121889, "sgbNextTalkSave", SN_NOWARN)
set_name(0x8012188A, "sgbPlrTalkTbl", SN_NOWARN)
set_name(0x8012188C, "pTalkPanel", SN_NOWARN)
set_name(0x80121890, "pMultiBtns", SN_NOWARN)
set_name(0x80121894, "pTalkBtns", SN_NOWARN)
set_name(0x80121898, "talkbtndown", SN_NOWARN)
set_name(0x80116F68, "gbFontTransTbl", SN_NOWARN)
set_name(0x80116EA8, "fontkern", SN_NOWARN)
set_name(0x800B0DD4, "SpellITbl", SN_NOWARN)
set_name(0x801209E5, "DrawLevelUpFlag", SN_NOWARN)
set_name(0x80120A0C, "_spselflag", SN_NOWARN)
set_name(0x80120A08, "spspelstate", SN_NOWARN)
set_name(0x80120A48, "initchr", SN_NOWARN)
set_name(0x801209E8, "SPLICONNO", SN_NOWARN)
set_name(0x801209EC, "SPLICONY", SN_NOWARN)
set_name(0x80121860, "SPLICONRIGHT", SN_NOWARN)
set_name(0x801209F0, "scx", SN_NOWARN)
set_name(0x801209F4, "scy", SN_NOWARN)
set_name(0x801209F8, "scx1", SN_NOWARN)
set_name(0x801209FC, "scy1", SN_NOWARN)
set_name(0x80120A00, "scx2", SN_NOWARN)
set_name(0x80120A04, "scy2", SN_NOWARN)
set_name(0x80120A14, "SpellCol", SN_NOWARN)
set_name(0x800B0DC0, "SpellColors", SN_NOWARN)
set_name(0x800B0DFC, "PanBtnPos", SN_NOWARN)
set_name(0x800B0E9C, "PanBtnHotKey", SN_NOWARN)
set_name(0x800B0EBC, "PanBtnStr", SN_NOWARN)
set_name(0x800B0EDC, "SpellPages", SN_NOWARN)
set_name(0x80120A38, "lus", SN_NOWARN)
set_name(0x80120A3C, "CsNo", SN_NOWARN)
set_name(0x80120A40, "plusanim", SN_NOWARN)
set_name(0x80122778, "CSBack", SN_NOWARN)
set_name(0x80120A44, "CS_XOFF", SN_NOWARN)
set_name(0x800B0F40, "CS_Tab", SN_NOWARN)
set_name(0x80120A4C, "NoCSEntries", SN_NOWARN)
set_name(0x80120A50, "SPALOFF", SN_NOWARN)
set_name(0x80120A54, "paloffset1", SN_NOWARN)
set_name(0x80120A58, "paloffset2", SN_NOWARN)
set_name(0x80120A5C, "paloffset3", SN_NOWARN)
set_name(0x80120A60, "paloffset4", SN_NOWARN)
set_name(0x80120A64, "pinc1", SN_NOWARN)
set_name(0x80120A68, "pinc2", SN_NOWARN)
set_name(0x80120A6C, "pinc3", SN_NOWARN)
set_name(0x80120A70, "pinc4", SN_NOWARN)
set_name(0x80120AF8, "_pcurs", SN_NOWARN)
set_name(0x80120B00, "cursW", SN_NOWARN)
set_name(0x80120B04, "cursH", SN_NOWARN)
set_name(0x80120B08, "icursW", SN_NOWARN)
set_name(0x80120B0C, "icursH", SN_NOWARN)
set_name(0x80120B10, "icursW28", SN_NOWARN)
set_name(0x80120B14, "icursH28", SN_NOWARN)
set_name(0x80120B18, "cursmx", SN_NOWARN)
set_name(0x80120B1C, "cursmy", SN_NOWARN)
set_name(0x80120B20, "_pcursmonst", SN_NOWARN)
set_name(0x80120B28, "_pcursobj", SN_NOWARN)
set_name(0x80120B2C, "_pcursitem", SN_NOWARN)
set_name(0x80120B30, "_pcursinvitem", SN_NOWARN)
set_name(0x80120B34, "_pcursplr", SN_NOWARN)
set_name(0x80120AF4, "sel_data", SN_NOWARN)
set_name(0x800B16A0, "dead", SN_NOWARN)
set_name(0x80120B38, "spurtndx", SN_NOWARN)
set_name(0x80120B3C, "stonendx", SN_NOWARN)
set_name(0x80120B40, "pSquareCel", SN_NOWARN)
set_name(0x80120B88, "ghInst", SN_NOWARN)
set_name(0x80120B8C, "svgamode", SN_NOWARN)
set_name(0x80120B90, "MouseX", SN_NOWARN)
set_name(0x80120B94, "MouseY", SN_NOWARN)
set_name(0x80120B98, "gv1", SN_NOWARN)
set_name(0x80120B9C, "gv2", SN_NOWARN)
set_name(0x80120BA0, "gv3", SN_NOWARN)
set_name(0x80120BA4, "gv4", SN_NOWARN)
set_name(0x80120BA8, "gv5", SN_NOWARN)
set_name(0x80120BAC, "gbProcessPlayers", SN_NOWARN)
set_name(0x800B1814, "DebugMonsters", SN_NOWARN)
set_name(0x800B183C, "glSeedTbl", SN_NOWARN)
set_name(0x800B1880, "gnLevelTypeTbl", SN_NOWARN)
set_name(0x80120BAD, "gbDoEnding", SN_NOWARN)
set_name(0x80120BAE, "gbRunGame", SN_NOWARN)
set_name(0x80120BAF, "gbRunGameResult", SN_NOWARN)
set_name(0x80120BB0, "gbGameLoopStartup", SN_NOWARN)
set_name(0x801227D8, "glEndSeed", SN_NOWARN)
set_name(0x80122828, "glMid1Seed", SN_NOWARN)
set_name(0x80122878, "glMid2Seed", SN_NOWARN)
set_name(0x801228C8, "glMid3Seed", SN_NOWARN)
set_name(0x8012189C, "sg_previousFilter", SN_NOWARN)
set_name(0x800B18C4, "CreateEnv", SN_NOWARN)
set_name(0x80120BB4, "Passedlvldir", SN_NOWARN)
set_name(0x80120BB8, "TempStack", SN_NOWARN)
set_name(0x80120B50, "ghMainWnd", SN_NOWARN)
set_name(0x80120B54, "fullscreen", SN_NOWARN)
set_name(0x80120B58, "force_redraw", SN_NOWARN)
set_name(0x80120B6C, "PauseMode", SN_NOWARN)
set_name(0x80120B6D, "FriendlyMode", SN_NOWARN)
set_name(0x80120B5D, "visiondebug", SN_NOWARN)
set_name(0x80120B5F, "light4flag", SN_NOWARN)
set_name(0x80120B60, "leveldebug", SN_NOWARN)
set_name(0x80120B61, "monstdebug", SN_NOWARN)
set_name(0x80120B68, "debugmonsttypes", SN_NOWARN)
set_name(0x80120B5C, "cineflag", SN_NOWARN)
set_name(0x80120B5E, "scrollflag", SN_NOWARN)
set_name(0x80120B62, "trigdebug", SN_NOWARN)
set_name(0x80120B64, "setseed", SN_NOWARN)
set_name(0x80120B70, "sgnTimeoutCurs", SN_NOWARN)
set_name(0x80120B74, "sgbMouseDown", SN_NOWARN)
set_name(0x800B1F90, "towner", SN_NOWARN)
set_name(0x80120BD0, "numtowners", SN_NOWARN)
set_name(0x80120BD4, "storeflag", SN_NOWARN)
set_name(0x80120BD5, "boyloadflag", SN_NOWARN)
set_name(0x80120BD6, "bannerflag", SN_NOWARN)
set_name(0x80120BD8, "pCowCels", SN_NOWARN)
set_name(0x801218A0, "sgdwCowClicks", SN_NOWARN)
set_name(0x801218A4, "sgnCowMsg", SN_NOWARN)
set_name(0x800B1CD0, "Qtalklist", SN_NOWARN)
set_name(0x80120BC8, "CowPlaying", SN_NOWARN)
set_name(0x800B18F4, "AnimOrder", SN_NOWARN)
set_name(0x800B1C6C, "TownCowX", SN_NOWARN)
set_name(0x800B1C78, "TownCowY", SN_NOWARN)
set_name(0x800B1C84, "TownCowDir", SN_NOWARN)
set_name(0x800B1C90, "cowoffx", SN_NOWARN)
set_name(0x800B1CB0, "cowoffy", SN_NOWARN)
set_name(0x80120BDC, "gpBuffer", SN_NOWARN)
set_name(0x80120BF8, "sfxdelay", SN_NOWARN)
set_name(0x80120BFC, "sfxdnum", SN_NOWARN)
set_name(0x80120BEC, "sghStream", SN_NOWARN)
set_name(0x800B2D90, "sgSFX", SN_NOWARN)
set_name(0x80120BF0, "sgpStreamSFX", SN_NOWARN)
set_name(0x80120C00, "orgseed", SN_NOWARN)
set_name(0x801218A8, "sglGameSeed", SN_NOWARN)
set_name(0x80120C04, "SeedCount", SN_NOWARN)
set_name(0x801218AC, "sgMemCrit", SN_NOWARN)
set_name(0x801218B0, "sgnWidth", SN_NOWARN)
set_name(0x80120C12, "msgflag", SN_NOWARN)
set_name(0x80120C13, "msgdelay", SN_NOWARN)
set_name(0x800B3D8C, "msgtable", SN_NOWARN)
set_name(0x800B3CDC, "MsgStrings", SN_NOWARN)
set_name(0x80120C11, "msgcnt", SN_NOWARN)
set_name(0x801218B4, "sgdwProgress", SN_NOWARN)
set_name(0x801218B8, "sgdwXY", SN_NOWARN)
set_name(0x800B3DDC, "AllItemsUseable", SN_NOWARN)
set_name(0x801173D4, "AllItemsList", SN_NOWARN)
set_name(0x80118774, "PL_Prefix", SN_NOWARN)
set_name(0x80119494, "PL_Suffix", SN_NOWARN)
set_name(0x8011A394, "UniqueItemList", SN_NOWARN)
set_name(0x800B3FF0, "item", SN_NOWARN)
set_name(0x800B89F0, "itemactive", SN_NOWARN)
set_name(0x800B8A70, "itemavail", SN_NOWARN)
set_name(0x800B8AF0, "UniqueItemFlag", SN_NOWARN)
set_name(0x80120C54, "uitemflag", SN_NOWARN)
set_name(0x801218BC, "tem", SN_NOWARN)
set_name(0x80122910, "curruitem", SN_NOWARN)
set_name(0x801229B0, "itemhold", SN_NOWARN)
set_name(0x80120C58, "ScrollType", SN_NOWARN)
set_name(0x800B8B70, "ItemStr", SN_NOWARN)
set_name(0x80120C2C, "numitems", SN_NOWARN)
set_name(0x80120C30, "gnNumGetRecords", SN_NOWARN)
set_name(0x800B3F4C, "ItemInvSnds", SN_NOWARN)
set_name(0x800B3E7C, "ItemCAnimTbl", SN_NOWARN)
set_name(0x8011C1D8, "Item2Frm", SN_NOWARN)
set_name(0x800B3F28, "ItemAnimLs", SN_NOWARN)
set_name(0x80120C34, "ItemAnimSnds", SN_NOWARN)
set_name(0x80120C38, "idoppely", SN_NOWARN)
set_name(0x80120C3C, "ScrollFlag", SN_NOWARN)
set_name(0x800B3FD8, "premiumlvladd", SN_NOWARN)
set_name(0x800B999C, "LightList", SN_NOWARN)
set_name(0x800B9ADC, "lightactive", SN_NOWARN)
set_name(0x80120C6C, "numlights", SN_NOWARN)
set_name(0x80120C70, "lightmax", SN_NOWARN)
set_name(0x800B9B04, "VisionList", SN_NOWARN)
set_name(0x80120C74, "numvision", SN_NOWARN)
set_name(0x80120C78, "dovision", SN_NOWARN)
set_name(0x80120C7C, "visionid", SN_NOWARN)
set_name(0x801218C0, "disp_mask", SN_NOWARN)
set_name(0x801218C4, "weird", SN_NOWARN)
set_name(0x801218C8, "disp_tab_r", SN_NOWARN)
set_name(0x801218CC, "dispy_r", SN_NOWARN)
set_name(0x801218D0, "disp_tab_g", SN_NOWARN)
set_name(0x801218D4, "dispy_g", SN_NOWARN)
set_name(0x801218D8, "disp_tab_b", SN_NOWARN)
set_name(0x801218DC, "dispy_b", SN_NOWARN)
set_name(0x801218E0, "radius", SN_NOWARN)
set_name(0x801218E4, "bright", SN_NOWARN)
set_name(0x801229C0, "mult_tab", SN_NOWARN)
set_name(0x80120C5C, "lightflag", SN_NOWARN)
set_name(0x800B96B0, "vCrawlTable", SN_NOWARN)
set_name(0x800B9964, "RadiusAdj", SN_NOWARN)
set_name(0x800B8BF0, "CrawlTable", SN_NOWARN)
set_name(0x80120C60, "restore_r", SN_NOWARN)
set_name(0x80120C64, "restore_g", SN_NOWARN)
set_name(0x80120C68, "restore_b", SN_NOWARN)
set_name(0x800B997C, "radius_tab", SN_NOWARN)
set_name(0x800B998C, "bright_tab", SN_NOWARN)
set_name(0x800B9CC4, "gszHero", SN_NOWARN)
set_name(0x80120C9E, "qtextflag", SN_NOWARN)
set_name(0x80120CA0, "qtextSpd", SN_NOWARN)
set_name(0x801218E8, "pMedTextCels", SN_NOWARN)
set_name(0x801218EC, "pTextBoxCels", SN_NOWARN)
set_name(0x801218F0, "qtextptr", SN_NOWARN)
set_name(0x801218F4, "qtexty", SN_NOWARN)
set_name(0x801218F8, "qtextDelay", SN_NOWARN)
set_name(0x801218FC, "sgLastScroll", SN_NOWARN)
set_name(0x80121900, "scrolltexty", SN_NOWARN)
set_name(0x80121904, "sglMusicVolumeSave", SN_NOWARN)
set_name(0x80120C8C, "qtbodge", SN_NOWARN)
set_name(0x800B9CD4, "QBack", SN_NOWARN)
set_name(0x80120C9D, "CDFlip", SN_NOWARN)
set_name(0x800B9CE4, "missiledata", SN_NOWARN)
set_name(0x800BA454, "misfiledata", SN_NOWARN)
set_name(0x800BA344, "MissPrintRoutines", SN_NOWARN)
set_name(0x800BAAC4, "sgLevels", SN_NOWARN)
set_name(0x800D1D0C, "sgLocals", SN_NOWARN)
set_name(0x80122A40, "sgJunk", SN_NOWARN)
set_name(0x80121909, "sgbRecvCmd", SN_NOWARN)
set_name(0x8012190C, "sgdwRecvOffset", SN_NOWARN)
set_name(0x80121910, "sgbDeltaChunks", SN_NOWARN)
set_name(0x80121911, "sgbDeltaChanged", SN_NOWARN)
set_name(0x80121914, "sgdwOwnerWait", SN_NOWARN)
set_name(0x80121918, "sgpMegaPkt", SN_NOWARN)
set_name(0x8012191C, "sgpCurrPkt", SN_NOWARN)
set_name(0x80121920, "sgnCurrMegaPlayer", SN_NOWARN)
set_name(0x80120CB9, "deltaload", SN_NOWARN)
set_name(0x80120CBA, "gbBufferMsgs", SN_NOWARN)
set_name(0x80120CBC, "dwRecCount", SN_NOWARN)
set_name(0x80120CD2, "gbMaxPlayers", SN_NOWARN)
set_name(0x80120CD3, "gbActivePlayers", SN_NOWARN)
set_name(0x80120CD4, "gbGameDestroyed", SN_NOWARN)
set_name(0x80120CD5, "gbDeltaSender", SN_NOWARN)
set_name(0x80120CD6, "gbSelectProvider", SN_NOWARN)
set_name(0x80120CD7, "gbSomebodyWonGameKludge", SN_NOWARN)
set_name(0x80121924, "sgbSentThisCycle", SN_NOWARN)
set_name(0x80121928, "sgdwGameLoops", SN_NOWARN)
set_name(0x8012192C, "sgwPackPlrOffsetTbl", SN_NOWARN)
set_name(0x80121930, "sgbPlayerLeftGameTbl", SN_NOWARN)
set_name(0x80121934, "sgdwPlayerLeftReasonTbl", SN_NOWARN)
set_name(0x8012193C, "sgbSendDeltaTbl", SN_NOWARN)
set_name(0x80121944, "sgGameInitInfo", SN_NOWARN)
set_name(0x8012194C, "sgbGameJoiner", SN_NOWARN)
set_name(0x8012194E, "sgbTimeout", SN_NOWARN)
set_name(0x80121950, "sglTimeoutStart", SN_NOWARN)
set_name(0x80122A60, "sgLoPriBuf", SN_NOWARN)
set_name(0x80123A70, "sgHiPriBuf", SN_NOWARN)
set_name(0x80120CCC, "gszVersionNumber", SN_NOWARN)
set_name(0x80120CD1, "sgbNetInited", SN_NOWARN)
set_name(0x800D2A54, "ObjTypeConv", SN_NOWARN)
set_name(0x800D2C18, "AllObjects", SN_NOWARN)
set_name(0x8011C8E4, "ObjMasterLoadList", SN_NOWARN)
set_name(0x800D33F8, "object", SN_NOWARN)
set_name(0x80120CF8, "numobjects", SN_NOWARN)
set_name(0x800D49CC, "objectactive", SN_NOWARN)
set_name(0x800D4A4C, "objectavail", SN_NOWARN)
set_name(0x80120CFC, "InitObjFlag", SN_NOWARN)
set_name(0x80120D00, "trapid", SN_NOWARN)
set_name(0x800D4ACC, "ObjFileList", SN_NOWARN)
set_name(0x80120D04, "trapdir", SN_NOWARN)
set_name(0x80120D08, "leverid", SN_NOWARN)
set_name(0x80120CF0, "numobjfiles", SN_NOWARN)
set_name(0x800D3310, "bxadd", SN_NOWARN)
set_name(0x800D3330, "byadd", SN_NOWARN)
set_name(0x800D33B8, "shrineavail", SN_NOWARN)
set_name(0x800D3350, "shrinestrs", SN_NOWARN)
set_name(0x800D33D4, "StoryBookName", SN_NOWARN)
set_name(0x80120CF4, "myscale", SN_NOWARN)
set_name(0x80120D1C, "gbValidSaveFile", SN_NOWARN)
set_name(0x80120D18, "DoLoadedChar", SN_NOWARN)
set_name(0x800D4CEC, "plr", SN_NOWARN)
set_name(0x80120D3C, "myplr", SN_NOWARN)
set_name(0x80120D40, "deathdelay", SN_NOWARN)
set_name(0x80120D44, "deathflag", SN_NOWARN)
set_name(0x80120D45, "light_rad", SN_NOWARN)
set_name(0x80120D34, "light_level", SN_NOWARN)
set_name(0x800D4BE4, "MaxStats", SN_NOWARN)
set_name(0x80120D2C, "PlrStructSize", SN_NOWARN)
set_name(0x80120D30, "ItemStructSize", SN_NOWARN)
set_name(0x800D4AF4, "plrxoff", SN_NOWARN)
set_name(0x800D4B18, "plryoff", SN_NOWARN)
set_name(0x800D4B3C, "plrxoff2", SN_NOWARN)
set_name(0x800D4B60, "plryoff2", SN_NOWARN)
set_name(0x800D4B84, "PlrGFXAnimLens", SN_NOWARN)
set_name(0x800D4BA8, "StrengthTbl", SN_NOWARN)
set_name(0x800D4BB4, "MagicTbl", SN_NOWARN)
set_name(0x800D4BC0, "DexterityTbl", SN_NOWARN)
set_name(0x800D4BCC, "VitalityTbl", SN_NOWARN)
set_name(0x800D4BD8, "ToBlkTbl", SN_NOWARN)
set_name(0x800D4C14, "ExpLvlsTbl", SN_NOWARN)
set_name(0x800D93C4, "quests", SN_NOWARN)
set_name(0x80120D80, "pQLogCel", SN_NOWARN)
set_name(0x80120D84, "ReturnLvlX", SN_NOWARN)
set_name(0x80120D88, "ReturnLvlY", SN_NOWARN)
set_name(0x80120D8C, "ReturnLvl", SN_NOWARN)
set_name(0x80120D90, "ReturnLvlT", SN_NOWARN)
set_name(0x80120D94, "qfade", SN_NOWARN)
set_name(0x80120D98, "rporttest", SN_NOWARN)
set_name(0x80120D9C, "qline", SN_NOWARN)
set_name(0x80120DA0, "numqlines", SN_NOWARN)
set_name(0x80120DA4, "qtopline", SN_NOWARN)
set_name(0x80124A78, "qlist", SN_NOWARN)
set_name(0x80121954, "QSRect", SN_NOWARN)
set_name(0x80120D51, "questlog", SN_NOWARN)
set_name(0x800D928C, "questlist", SN_NOWARN)
set_name(0x80120D54, "ALLQUESTS", SN_NOWARN)
set_name(0x800D93A0, "QuestGroup1", SN_NOWARN)
set_name(0x800D93AC, "QuestGroup2", SN_NOWARN)
set_name(0x800D93B8, "QuestGroup3", SN_NOWARN)
set_name(0x80120D68, "QuestGroup4", SN_NOWARN)
set_name(0x80120D58, "questxoff", SN_NOWARN)
set_name(0x80120D60, "questyoff", SN_NOWARN)
set_name(0x800D938C, "questtrigstr", SN_NOWARN)
set_name(0x80120D70, "QS_PX", SN_NOWARN)
set_name(0x80120D74, "QS_PY", SN_NOWARN)
set_name(0x80120D78, "QS_PW", SN_NOWARN)
set_name(0x80120D7C, "QS_PH", SN_NOWARN)
set_name(0x80124AB8, "QSBack", SN_NOWARN)
set_name(0x800D9504, "spelldata", SN_NOWARN)
set_name(0x80120DE3, "stextflag", SN_NOWARN)
set_name(0x800D9D5C, "smithitem", SN_NOWARN)
set_name(0x800DA8EC, "premiumitem", SN_NOWARN)
set_name(0x80120DE4, "numpremium", SN_NOWARN)
set_name(0x80120DE8, "premiumlevel", SN_NOWARN)
set_name(0x800DAC64, "witchitem", SN_NOWARN)
set_name(0x800DB7F4, "boyitem", SN_NOWARN)
set_name(0x80120DEC, "boylevel", SN_NOWARN)
set_name(0x800DB888, "golditem", SN_NOWARN)
set_name(0x800DB91C, "healitem", SN_NOWARN)
set_name(0x80120DF0, "stextsize", SN_NOWARN)
set_name(0x80120DF1, "stextscrl", SN_NOWARN)
set_name(0x8012195C, "stextsel", SN_NOWARN)
set_name(0x80121960, "stextlhold", SN_NOWARN)
set_name(0x80121964, "stextshold", SN_NOWARN)
set_name(0x80121968, "stextvhold", SN_NOWARN)
set_name(0x8012196C, "stextsval", SN_NOWARN)
set_name(0x80121970, "stextsmax", SN_NOWARN)
set_name(0x80121974, "stextup", SN_NOWARN)
set_name(0x80121978, "stextdown", SN_NOWARN)
set_name(0x8012197C, "stextscrlubtn", SN_NOWARN)
set_name(0x8012197D, "stextscrldbtn", SN_NOWARN)
set_name(0x8012197E, "SItemListFlag", SN_NOWARN)
set_name(0x80124AC8, "stext", SN_NOWARN)
set_name(0x800DC4AC, "storehold", SN_NOWARN)
set_name(0x800DE06C, "storehidx", SN_NOWARN)
set_name(0x80121980, "storenumh", SN_NOWARN)
set_name(0x80121984, "gossipstart", SN_NOWARN)
set_name(0x80121988, "gossipend", SN_NOWARN)
set_name(0x8012198C, "StoreBackRect", SN_NOWARN)
set_name(0x80121994, "talker", SN_NOWARN)
set_name(0x80120DCC, "pSTextBoxCels", SN_NOWARN)
set_name(0x80120DD0, "pSTextSlidCels", SN_NOWARN)
set_name(0x80120DD4, "SStringY", SN_NOWARN)
set_name(0x800D9C88, "SBack", SN_NOWARN)
set_name(0x800D9C98, "SStringYNorm", SN_NOWARN)
set_name(0x800D9CE8, "SStringYBuy", SN_NOWARN)
set_name(0x800D9D38, "talkname", SN_NOWARN)
set_name(0x80120DE2, "InStoreFlag", SN_NOWARN)
set_name(0x80121998, "sgnMonsters", SN_NOWARN)
set_name(0x801257E8, "sgwLRU", SN_NOWARN)
set_name(0x8012199C, "sgnLRUScan", SN_NOWARN)
set_name(0x80120E00, "sgnSyncItem", SN_NOWARN)
set_name(0x80120E04, "sgnSyncObj", SN_NOWARN)
set_name(0x80120E08, "sgnSyncPInv", SN_NOWARN)
set_name(0x8011D9A8, "alltext", SN_NOWARN)
set_name(0x80120E18, "gdwAllTextEntries", SN_NOWARN)
set_name(0x801219A0, "P3Tiles", SN_NOWARN)
set_name(0x80120E28, "tile", SN_NOWARN)
set_name(0x80120E38, "_trigflag", SN_NOWARN)
set_name(0x800DE2D4, "trigs", SN_NOWARN)
set_name(0x80120E3C, "numtrigs", SN_NOWARN)
set_name(0x80120E40, "townwarps", SN_NOWARN)
set_name(0x80120E44, "TWarpFrom", SN_NOWARN)
set_name(0x800DE09C, "TownDownList", SN_NOWARN)
set_name(0x800DE0C8, "TownWarp1List", SN_NOWARN)
set_name(0x800DE0FC, "L1UpList", SN_NOWARN)
set_name(0x800DE12C, "L1DownList", SN_NOWARN)
set_name(0x800DE154, "L2UpList", SN_NOWARN)
set_name(0x800DE160, "L2DownList", SN_NOWARN)
set_name(0x800DE174, "L2TWarpUpList", SN_NOWARN)
set_name(0x800DE180, "L3UpList", SN_NOWARN)
set_name(0x800DE1BC, "L3DownList", SN_NOWARN)
set_name(0x800DE1E0, "L3TWarpUpList", SN_NOWARN)
set_name(0x800DE218, "L4UpList", SN_NOWARN)
set_name(0x800DE228, "L4DownList", SN_NOWARN)
set_name(0x800DE240, "L4TWarpUpList", SN_NOWARN)
set_name(0x800DE250, "L4PentaList", SN_NOWARN)
set_name(0x8011E760, "cursoff", SN_NOWARN)
set_name(0x80120E5E, "gbMusicOn", SN_NOWARN)
set_name(0x80120E5F, "gbSoundOn", SN_NOWARN)
set_name(0x80120E5D, "gbSndInited", SN_NOWARN)
set_name(0x80120E64, "sglMasterVolume", SN_NOWARN)
set_name(0x80120E68, "sglMusicVolume", SN_NOWARN)
set_name(0x80120E6C, "sglSoundVolume", SN_NOWARN)
set_name(0x80120E70, "sglSpeechVolume", SN_NOWARN)
set_name(0x80120E60, "gbDupSounds", SN_NOWARN)
set_name(0x80120E74, "sgnMusicTrack", SN_NOWARN)
set_name(0x80120E78, "sghMusic", SN_NOWARN)
set_name(0x8011E820, "sgszMusicTracks", SN_NOWARN)
set_name(0x80120EA0, "_pcurr_inv", SN_NOWARN)
set_name(0x800DE324, "_pfind_list", SN_NOWARN)
set_name(0x80120EA8, "_pfind_index", SN_NOWARN)
set_name(0x80120EAC, "_pfindx", SN_NOWARN)
set_name(0x80120EB0, "_pfindy", SN_NOWARN)
set_name(0x80120EB2, "automapmoved", SN_NOWARN)
set_name(0x80120E90, "flyflag", SN_NOWARN)
set_name(0x80120E88, "pad_styles", SN_NOWARN)
set_name(0x80120E91, "speed_type", SN_NOWARN)
set_name(0x80120E92, "sel_speed", SN_NOWARN)
set_name(0x80120E9C, "whatmon", SN_NOWARN)
set_name(0x801219A4, "CurrentProc", SN_NOWARN)
set_name(0x8011E9B4, "AllMsgs", SN_NOWARN)
set_name(0x80120EE0, "NumOfStrings", SN_NOWARN)
set_name(0x80120EB4, "LanguageType", SN_NOWARN)
set_name(0x80120EB8, "hndText", SN_NOWARN)
set_name(0x80120EBC, "TextPtr", SN_NOWARN)
set_name(0x80120EC0, "LangDbNo", SN_NOWARN)
set_name(0x80120EF0, "MissDat", SN_NOWARN)
set_name(0x80120EF4, "CharFade", SN_NOWARN)
set_name(0x80120EF8, "rotateness", SN_NOWARN)
set_name(0x80120EFC, "spiralling_shape", SN_NOWARN)
set_name(0x80120F00, "down", SN_NOWARN)
set_name(0x800DE374, "MlTab", SN_NOWARN)
set_name(0x800DE384, "QlTab", SN_NOWARN)
set_name(0x800DE394, "ObjPrintFuncs", SN_NOWARN)
set_name(0x80120F1C, "MyXoff1", SN_NOWARN)
set_name(0x80120F20, "MyYoff1", SN_NOWARN)
set_name(0x80120F24, "MyXoff2", SN_NOWARN)
set_name(0x80120F28, "MyYoff2", SN_NOWARN)
set_name(0x80120F38, "iscflag", SN_NOWARN)
set_name(0x80120F45, "sgbFadedIn", SN_NOWARN)
set_name(0x80120F46, "screenbright", SN_NOWARN)
set_name(0x80120F48, "faderate", SN_NOWARN)
set_name(0x80120F4C, "fading", SN_NOWARN)
set_name(0x80120F68, "AmShiftTab", SN_NOWARN)
set_name(0x801219A8, "tbuff", SN_NOWARN)
set_name(0x801219AC, "HR1", SN_NOWARN)
set_name(0x801219AD, "HR2", SN_NOWARN)
set_name(0x801219AE, "HR3", SN_NOWARN)
set_name(0x801219AF, "VR1", SN_NOWARN)
set_name(0x801219B0, "VR2", SN_NOWARN)
set_name(0x801219B1, "VR3", SN_NOWARN)
set_name(0x80120FDC, "pHallList", SN_NOWARN)
set_name(0x80120FE0, "nRoomCnt", SN_NOWARN)
set_name(0x80120FE4, "nSx1", SN_NOWARN)
set_name(0x80120FE8, "nSy1", SN_NOWARN)
set_name(0x80120FEC, "nSx2", SN_NOWARN)
set_name(0x80120FF0, "nSy2", SN_NOWARN)
set_name(0x80120F94, "Area_Min", SN_NOWARN)
set_name(0x80120F98, "Room_Max", SN_NOWARN)
set_name(0x80120F9C, "Room_Min", SN_NOWARN)
set_name(0x80120FA0, "BIG3", SN_NOWARN)
set_name(0x80120FA8, "BIG4", SN_NOWARN)
set_name(0x80120FB0, "BIG6", SN_NOWARN)
set_name(0x80120FB8, "BIG7", SN_NOWARN)
set_name(0x80120FC0, "RUINS1", SN_NOWARN)
set_name(0x80120FC4, "RUINS2", SN_NOWARN)
set_name(0x80120FC8, "RUINS3", SN_NOWARN)
set_name(0x80120FCC, "RUINS4", SN_NOWARN)
set_name(0x80120FD0, "RUINS5", SN_NOWARN)
set_name(0x80120FD4, "RUINS6", SN_NOWARN)
set_name(0x80120FD8, "RUINS7", SN_NOWARN)
set_name(0x801219B4, "abyssx", SN_NOWARN)
set_name(0x801219B8, "lavapool", SN_NOWARN)
set_name(0x8012107C, "lockoutcnt", SN_NOWARN)
set_name(0x80121000, "L3TITE12", SN_NOWARN)
set_name(0x80121008, "L3TITE13", SN_NOWARN)
set_name(0x80121010, "L3CREV1", SN_NOWARN)
set_name(0x80121018, "L3CREV2", SN_NOWARN)
set_name(0x80121020, "L3CREV3", SN_NOWARN)
set_name(0x80121028, "L3CREV4", SN_NOWARN)
set_name(0x80121030, "L3CREV5", SN_NOWARN)
set_name(0x80121038, "L3CREV6", SN_NOWARN)
set_name(0x80121040, "L3CREV7", SN_NOWARN)
set_name(0x80121048, "L3CREV8", SN_NOWARN)
set_name(0x80121050, "L3CREV9", SN_NOWARN)
set_name(0x80121058, "L3CREV10", SN_NOWARN)
set_name(0x80121060, "L3CREV11", SN_NOWARN)
set_name(0x80121068, "L3XTRA1", SN_NOWARN)
set_name(0x8012106C, "L3XTRA2", SN_NOWARN)
set_name(0x80121070, "L3XTRA3", SN_NOWARN)
set_name(0x80121074, "L3XTRA4", SN_NOWARN)
set_name(0x80121078, "L3XTRA5", SN_NOWARN)
set_name(0x80121080, "diabquad1x", SN_NOWARN)
set_name(0x80121084, "diabquad2x", SN_NOWARN)
set_name(0x80121088, "diabquad3x", SN_NOWARN)
set_name(0x8012108C, "diabquad4x", SN_NOWARN)
set_name(0x80121090, "diabquad1y", SN_NOWARN)
set_name(0x80121094, "diabquad2y", SN_NOWARN)
set_name(0x80121098, "diabquad3y", SN_NOWARN)
set_name(0x8012109C, "diabquad4y", SN_NOWARN)
set_name(0x801210A0, "SP4x1", SN_NOWARN)
set_name(0x801210A4, "SP4y1", SN_NOWARN)
set_name(0x801210A8, "SP4x2", SN_NOWARN)
set_name(0x801210AC, "SP4y2", SN_NOWARN)
set_name(0x801210B0, "l4holdx", SN_NOWARN)
set_name(0x801210B4, "l4holdy", SN_NOWARN)
set_name(0x801210C4, "SkelKingTrans1", SN_NOWARN)
set_name(0x801210CC, "SkelKingTrans2", SN_NOWARN)
set_name(0x800DE51C, "SkelKingTrans3", SN_NOWARN)
set_name(0x800DE530, "SkelKingTrans4", SN_NOWARN)
set_name(0x800DE54C, "SkelChamTrans1", SN_NOWARN)
set_name(0x801210D4, "SkelChamTrans2", SN_NOWARN)
set_name(0x800DE560, "SkelChamTrans3", SN_NOWARN)
set_name(0x801211C8, "DoUiForChooseMonster", SN_NOWARN)
set_name(0x800DE584, "MgToText", SN_NOWARN)
set_name(0x800DE60C, "StoryText", SN_NOWARN)
set_name(0x800DE630, "dungeon", SN_NOWARN)
set_name(0x800DF830, "pdungeon", SN_NOWARN)
set_name(0x800DFE70, "dflags", SN_NOWARN)
set_name(0x801211F4, "setpc_x", SN_NOWARN)
set_name(0x801211F8, "setpc_y", SN_NOWARN)
set_name(0x801211FC, "setpc_w", SN_NOWARN)
set_name(0x80121200, "setpc_h", SN_NOWARN)
set_name(0x80121204, "setloadflag", SN_NOWARN)
set_name(0x80121208, "pMegaTiles", SN_NOWARN)
set_name(0x800E04B0, "nBlockTable", SN_NOWARN)
set_name(0x800E0CB4, "nSolidTable", SN_NOWARN)
set_name(0x800E14B8, "nTransTable", SN_NOWARN)
set_name(0x800E1CBC, "nMissileTable", SN_NOWARN)
set_name(0x800E24C0, "nTrapTable", SN_NOWARN)
set_name(0x8012120C, "dminx", SN_NOWARN)
set_name(0x80121210, "dminy", SN_NOWARN)
set_name(0x80121214, "dmaxx", SN_NOWARN)
set_name(0x80121218, "dmaxy", SN_NOWARN)
set_name(0x8012121C, "gnDifficulty", SN_NOWARN)
set_name(0x80121220, "currlevel", SN_NOWARN)
set_name(0x80121221, "leveltype", SN_NOWARN)
set_name(0x80121222, "setlevel", SN_NOWARN)
set_name(0x80121223, "setlvlnum", SN_NOWARN)
set_name(0x80121224, "setlvltype", SN_NOWARN)
set_name(0x80121228, "ViewX", SN_NOWARN)
set_name(0x8012122C, "ViewY", SN_NOWARN)
set_name(0x80121230, "ViewDX", SN_NOWARN)
set_name(0x80121234, "ViewDY", SN_NOWARN)
set_name(0x80121238, "ViewBX", SN_NOWARN)
set_name(0x8012123C, "ViewBY", SN_NOWARN)
set_name(0x800E2CC4, "ScrollInfo", SN_NOWARN)
set_name(0x80121240, "LvlViewX", SN_NOWARN)
set_name(0x80121244, "LvlViewY", SN_NOWARN)
set_name(0x80121248, "btmbx", SN_NOWARN)
set_name(0x8012124C, "btmby", SN_NOWARN)
set_name(0x80121250, "btmdx", SN_NOWARN)
set_name(0x80121254, "btmdy", SN_NOWARN)
set_name(0x80121258, "MicroTileLen", SN_NOWARN)
set_name(0x8012125C, "TransVal", SN_NOWARN)
set_name(0x800E2CD8, "TransList", SN_NOWARN)
set_name(0x80121260, "themeCount", SN_NOWARN)
set_name(0x800E2CF8, "dung_map", SN_NOWARN)
set_name(0x80104FB8, "dung_map_r", SN_NOWARN)
set_name(0x80105B1C, "dung_map_g", SN_NOWARN)
set_name(0x80106680, "dung_map_b", SN_NOWARN)
set_name(0x801071E4, "MinisetXY", SN_NOWARN)
set_name(0x801211E4, "pSetPiece", SN_NOWARN)
set_name(0x801211E8, "DungSize", SN_NOWARN)
set_name(0x801073B0, "theme", SN_NOWARN)
set_name(0x801212A0, "numthemes", SN_NOWARN)
set_name(0x801212A4, "zharlib", SN_NOWARN)
set_name(0x801212A8, "armorFlag", SN_NOWARN)
set_name(0x801212A9, "bCrossFlag", SN_NOWARN)
set_name(0x801212AA, "weaponFlag", SN_NOWARN)
set_name(0x801212AC, "themex", SN_NOWARN)
set_name(0x801212B0, "themey", SN_NOWARN)
set_name(0x801212B4, "themeVar1", SN_NOWARN)
set_name(0x801212B8, "bFountainFlag", SN_NOWARN)
set_name(0x801212B9, "cauldronFlag", SN_NOWARN)
set_name(0x801212BA, "mFountainFlag", SN_NOWARN)
set_name(0x801212BB, "pFountainFlag", SN_NOWARN)
set_name(0x801212BC, "tFountainFlag", SN_NOWARN)
set_name(0x801212BD, "treasureFlag", SN_NOWARN)
set_name(0x801212C0, "ThemeGoodIn", SN_NOWARN)
set_name(0x80107290, "ThemeGood", SN_NOWARN)
set_name(0x801072A0, "trm5x", SN_NOWARN)
set_name(0x80107304, "trm5y", SN_NOWARN)
set_name(0x80107368, "trm3x", SN_NOWARN)
set_name(0x8010738C, "trm3y", SN_NOWARN)
set_name(0x80121378, "nummissiles", SN_NOWARN)
set_name(0x80107580, "missileactive", SN_NOWARN)
set_name(0x80107774, "missileavail", SN_NOWARN)
set_name(0x8012137C, "MissilePreFlag", SN_NOWARN)
set_name(0x80107968, "missile", SN_NOWARN)
set_name(0x8012137D, "ManashieldFlag", SN_NOWARN)
set_name(0x8012137E, "ManashieldFlag2", SN_NOWARN)
set_name(0x80107540, "XDirAdd", SN_NOWARN)
set_name(0x80107560, "YDirAdd", SN_NOWARN)
set_name(0x80121365, "fadetor", SN_NOWARN)
set_name(0x80121366, "fadetog", SN_NOWARN)
set_name(0x80121367, "fadetob", SN_NOWARN)
set_name(0x8010A218, "monster", SN_NOWARN)
set_name(0x801213DC, "nummonsters", SN_NOWARN)
set_name(0x8010F998, "monstactive", SN_NOWARN)
set_name(0x8010FB28, "monstkills", SN_NOWARN)
set_name(0x8010FCB8, "Monsters", SN_NOWARN)
set_name(0x801213E0, "monstimgtot", SN_NOWARN)
set_name(0x801213E4, "totalmonsters", SN_NOWARN)
set_name(0x801213E8, "uniquetrans", SN_NOWARN)
set_name(0x801219BC, "sgbSaveSoundOn", SN_NOWARN)
set_name(0x801213B0, "offset_x", SN_NOWARN)
set_name(0x801213B8, "offset_y", SN_NOWARN)
set_name(0x80121398, "left", SN_NOWARN)
set_name(0x801213A0, "right", SN_NOWARN)
set_name(0x801213A8, "opposite", SN_NOWARN)
set_name(0x8012138C, "nummtypes", SN_NOWARN)
set_name(0x80121390, "animletter", SN_NOWARN)
set_name(0x8010A078, "MWVel", SN_NOWARN)
set_name(0x801213C0, "rnd5", SN_NOWARN)
set_name(0x801213C4, "rnd10", SN_NOWARN)
set_name(0x801213C8, "rnd20", SN_NOWARN)
set_name(0x801213CC, "rnd60", SN_NOWARN)
set_name(0x8010A198, "AiProc", SN_NOWARN)
set_name(0x80110190, "monsterdata", SN_NOWARN)
set_name(0x80111BD0, "MonstConvTbl", SN_NOWARN)
set_name(0x80111C50, "MonstAvailTbl", SN_NOWARN)
set_name(0x80111CC0, "UniqMonst", SN_NOWARN)
set_name(0x8010FF78, "TransPals", SN_NOWARN)
set_name(0x8010FE78, "StonePals", SN_NOWARN)
set_name(0x80112610, "portal", SN_NOWARN)
set_name(0x80121404, "portalindex", SN_NOWARN)
set_name(0x801125F0, "WarpDropX", SN_NOWARN)
set_name(0x80112600, "WarpDropY", SN_NOWARN)
set_name(0x8012141C, "invflag", SN_NOWARN)
set_name(0x8012141D, "drawsbarflag", SN_NOWARN)
set_name(0x80121420, "InvBackY", SN_NOWARN)
set_name(0x80121424, "InvPanelTData", SN_NOWARN)
set_name(0x80121428, "InvGfxTData", SN_NOWARN)
set_name(0x8012142C, "InvCursPos", SN_NOWARN)
set_name(0x80112CF0, "InvSpareSlot", SN_NOWARN)
set_name(0x80112D84, "InvSlotTable", SN_NOWARN)
set_name(0x80121430, "InvBackAY", SN_NOWARN)
set_name(0x80121434, "InvSel", SN_NOWARN)
set_name(0x80121438, "ItemW", SN_NOWARN)
set_name(0x8012143C, "ItemH", SN_NOWARN)
set_name(0x80121440, "ItemNo", SN_NOWARN)
set_name(0x80121444, "InvSpareFlag", SN_NOWARN)
set_name(0x80121448, "BRect", SN_NOWARN)
set_name(0x80112670, "AP2x2Tbl", SN_NOWARN)
set_name(0x80112698, "InvRect", SN_NOWARN)
set_name(0x801128E8, "InvGfxTable", SN_NOWARN)
set_name(0x80112B88, "InvItemWidth", SN_NOWARN)
set_name(0x80112C3C, "InvItemHeight", SN_NOWARN)
set_name(0x80121414, "sgdwLastTime", SN_NOWARN)
set_name(0x80121418, "InvSpareSel", SN_NOWARN)
set_name(0x80121459, "automapflag", SN_NOWARN)
set_name(0x80112DD0, "automapview", SN_NOWARN)
set_name(0x80112E98, "automaptype", SN_NOWARN)
set_name(0x8012145A, "AMLWallFlag", SN_NOWARN)
set_name(0x8012145B, "AMRWallFlag", SN_NOWARN)
set_name(0x8012145C, "AMLLWallFlag", SN_NOWARN)
set_name(0x8012145D, "AMLRWallFlag", SN_NOWARN)
set_name(0x8012145E, "AMDirtFlag", SN_NOWARN)
set_name(0x8012145F, "AMColumnFlag", SN_NOWARN)
set_name(0x80121460, "AMStairFlag", SN_NOWARN)
set_name(0x80121461, "AMLDoorFlag", SN_NOWARN)
set_name(0x80121462, "AMLGrateFlag", SN_NOWARN)
set_name(0x80121463, "AMLArchFlag", SN_NOWARN)
set_name(0x80121464, "AMRDoorFlag", SN_NOWARN)
set_name(0x80121465, "AMRGrateFlag", SN_NOWARN)
set_name(0x80121466, "AMRArchFlag", SN_NOWARN)
set_name(0x80121468, "AutoMapX", SN_NOWARN)
set_name(0x8012146C, "AutoMapY", SN_NOWARN)
set_name(0x80121470, "AutoMapXOfs", SN_NOWARN)
set_name(0x80121474, "AutoMapYOfs", SN_NOWARN)
set_name(0x80121478, "AMPlayerX", SN_NOWARN)
set_name(0x8012147C, "AMPlayerY", SN_NOWARN)
set_name(0x80121B18, "GazTick", SN_NOWARN)
set_name(0x8012A000, "RndTabs", SN_NOWARN)
set_name(0x800A5984, "DefaultRnd", SN_NOWARN)
set_name(0x80121B40, "PollFunc", SN_NOWARN)
set_name(0x80121B24, "MsgFunc", SN_NOWARN)
set_name(0x80121B70, "ErrorFunc", SN_NOWARN)
set_name(0x80121B2C, "LastPtr", SN_NOWARN)
set_name(0x800A59BC, "WorkMemInfo", SN_NOWARN)
set_name(0x80121A44, "MemInitBlocks", SN_NOWARN)
set_name(0x80127F98, "MemHdrBlocks", SN_NOWARN)
set_name(0x80121A48, "FreeBlocks", SN_NOWARN)
set_name(0x80121A4C, "LastError", SN_NOWARN)
set_name(0x80121A50, "TimeStamp", SN_NOWARN)
set_name(0x80121A54, "FullErrorChecking", SN_NOWARN)
set_name(0x80121A58, "LastAttemptedAlloc", SN_NOWARN)
set_name(0x80121A5C, "LastDeallocedBlock", SN_NOWARN)
set_name(0x80121A60, "VerbLev", SN_NOWARN)
set_name(0x80121A64, "NumOfFreeHdrs", SN_NOWARN)
set_name(0x80121A68, "LastTypeAlloced", SN_NOWARN)
set_name(0x80121A6C, "AllocFilter", SN_NOWARN)
set_name(0x800A59C4, "GalErrors", SN_NOWARN)
set_name(0x800A59EC, "PhantomMem", SN_NOWARN)
set_name(0x80121A70, "ActiveTasks", SN_NOWARN)
set_name(0x80121A74, "CurrentTask", SN_NOWARN)
set_name(0x80121A78, "T", SN_NOWARN)
set_name(0x80121A7C, "MemTypeForTasker", SN_NOWARN)
set_name(0x80128998, "SchEnv", SN_NOWARN)
set_name(0x80121A80, "ExecId", SN_NOWARN)
set_name(0x80121A84, "ExecMask", SN_NOWARN)
set_name(0x80121A88, "TasksActive", SN_NOWARN)
set_name(0x80121A8C, "EpiFunc", SN_NOWARN)
set_name(0x80121A90, "ProFunc", SN_NOWARN)
set_name(0x80121A94, "EpiProId", SN_NOWARN)
set_name(0x80121A98, "EpiProMask", SN_NOWARN)
set_name(0x80121A9C, "DoTasksPrologue", SN_NOWARN)
set_name(0x80121AA0, "DoTasksEpilogue", SN_NOWARN)
set_name(0x80121AA4, "StackFloodCallback", SN_NOWARN)
set_name(0x80121AA8, "ExtraStackProtection", SN_NOWARN)
set_name(0x80121AAC, "ExtraStackSizeLongs", SN_NOWARN)
set_name(0x801289C8, "buf", SN_NOWARN)
set_name(0x800A5A14, "NULL_REP", SN_NOWARN)
|
438043
|
from typing import AnyStr
from bunq.sdk.http.api_client import ApiClient
from bunq.sdk.model.generated.endpoint import AttachmentPublicContent, AttachmentPublic
from tests.bunq_test import BunqSdkTestCase
class TestAttachmentPublic(BunqSdkTestCase):
"""
Tests:
AttachmentPublic
AttachmentPublicContent
"""
def test_file_upload_and_retrieval(self):
"""
Tests uploading an attachment, retrieves it and compare them to see
if the uploaded attachment is indeed the attachment we are getting
back.
"""
custom_headers = {
ApiClient.HEADER_CONTENT_TYPE: self._CONTENT_TYPE,
ApiClient.HEADER_ATTACHMENT_DESCRIPTION:
self._ATTACHMENT_DESCRIPTION,
}
attachment_uuid = AttachmentPublic.create(self.attachment_contents, custom_headers).value
contents_from_response = AttachmentPublicContent.list(attachment_uuid).value
self.assertEqual(self.attachment_contents, contents_from_response)
@property
def attachment_contents(self) -> AnyStr:
with open(self._PATH_ATTACHMENT + self._ATTACHMENT_PATH_IN, self._READ_BYTES) as f:
return f.read()
|
438053
|
import argparse
import os
import zipfile
from base64 import b64decode
from io import BytesIO, TextIOWrapper, StringIO
from os.path import join, dirname, abspath
from datetime import datetime, timedelta, timezone
from zeep import Client
from zeep.wsse.username import UsernameToken
import psycopg2 as pg
url = {
'prod': join(dirname(abspath(__file__)), 'terytws1.wsdl'),
'test': join(dirname(abspath(__file__)), 'terytws1test.wsdl')
}
sql_prepare_tables = '''
CREATE SCHEMA IF NOT EXISTS teryt;
DROP TABLE IF EXISTS teryt.terc;
CREATE TABLE teryt.terc (
woj text,
pow text,
gmi text,
rodz text,
nazwa text,
nazdod text,
stan_na text
);
DROP TABLE IF EXISTS teryt.simc;
CREATE TABLE teryt.simc (
woj text,
pow text,
gmi text,
rodz_gmi text,
rm text,
mz text,
nazwa text,
sym text,
sympod text,
stan_na text
);
DROP TABLE IF EXISTS teryt.ulic;
CREATE TABLE teryt.ulic (
woj text,
pow text,
gmi text,
rodz_gmi text,
sym text,
sym_ul text,
cecha text,
nazwa_1 text,
nazwa_2 text,
stan_na text
);
DROP TABLE IF EXISTS teryt.wmrodz;
CREATE TABLE teryt.wmrodz (
rm text,
nazwa_rm text,
stan_na text
);
'''
teryt = {
'terc': {
'table': 'teryt.terc',
'api_method': 'PobierzKatalogTERC',
'copy': "COPY teryt.terc FROM stdin DELIMITER ';' CSV HEADER;"
},
'simc': {
'table': 'teryt.simc',
'api_method': 'PobierzKatalogSIMC',
'copy': "COPY teryt.simc FROM stdin DELIMITER ';' CSV HEADER;"
},
'ulic': {
'table': 'teryt.ulic',
'api_method': 'PobierzKatalogULIC',
'copy': "COPY teryt.ulic FROM stdin DELIMITER ';' CSV HEADER;"
},
'wmrodz': {
'table': 'teryt.wmrodz',
'api_method': 'PobierzKatalogWMRODZ',
'copy': "COPY teryt.wmrodz FROM stdin DELIMITER ';' CSV HEADER;"
}
}
def readfile(f: BytesIO) -> StringIO:
with zipfile.ZipFile(f, 'r') as zf:
for filename in zf.namelist():
if filename.endswith('.csv'):
return StringIO(TextIOWrapper(zf.open(filename, 'r'), encoding='utf-8-sig', newline=None).read().rstrip())
def load2pg(conn, file: StringIO, key: str, prepare_tables: bool = False) -> None:
cur = conn.cursor()
if prepare_tables:
cur.execute(sql_prepare_tables)
cur.copy_expert(sql=teryt[key]['copy'], file=file)
conn.commit()
def main(env: str, dsn: str, api_user: str, api_password: str, date: str = None) -> None:
date = date if date else datetime.strftime(datetime.now() - timedelta(1), '%Y-%m-%d')
final_status: str = 'SUCCESS'
conn = pg.connect(dsn)
cur = conn.cursor()
cur.execute('SELECT in_progress FROM process_locks WHERE process_name = %s', ('teryt_update',))
teryt_update_in_progress = cur.fetchone()[0]
if not teryt_update_in_progress:
print(datetime.now(timezone.utc).astimezone().isoformat(), '- starting TERYT update process.')
cur.execute('UPDATE process_locks SET (in_progress, start_time, end_time) = (true, \'now\', null) ' +
'WHERE process_name = %s',
('teryt_update',))
conn.commit()
try:
for i, key in enumerate(teryt.keys()):
client = Client(url[env], wsse=UsernameToken(api_user, api_password))
r = client.service[teryt[key]['api_method']](DataStanu=date)
f = BytesIO(b64decode(r['plik_zawartosc']))
load2pg(conn, readfile(f), key, prepare_tables=i == 0)
except Exception as e:
conn.rollback()
final_status = 'FAIL'
print(datetime.now(timezone.utc).astimezone().isoformat(), '- error during TERYT update process.')
print(e)
raise e
finally:
cur.execute(
'UPDATE process_locks SET (in_progress, end_time, last_status) = (false, \'now\', %s) ' +
'WHERE process_name = %s',
(final_status, 'teryt_update',))
conn.commit()
print(datetime.now(timezone.utc).astimezone().isoformat(), '- finished TERYT update process.')
conn.close()
else:
print(datetime.now(timezone.utc).astimezone().isoformat(),
'- TERYT update in progress already. Not starting another one.')
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--api_env', help='TERYT API environment.', nargs=1, choices=['prod', 'test'])
parser.add_argument('--api_user', help='TERYT API user.', nargs='?')
parser.add_argument('--api_password', help='<PASSWORD> API password.', nargs='?')
parser.add_argument('--dsn', help='Connection string for PostgreSQL DB.', nargs='?')
parser.add_argument('--dotenv', help='Path to .env file with credentials for PostgreSQL DB.', nargs='?')
args = vars(parser.parse_args())
if args.get('dotenv'):
from dotenv import load_dotenv
dotenv_path = args['dotenv']
load_dotenv(dotenv_path, verbose=True)
PGHOSTADDR = os.environ['PGHOSTADDR']
PGPORT = os.environ['PGPORT']
PGDATABASE = os.environ['PGDATABASE']
PGUSER = os.environ['PGUSER']
PGPASSWORD = os.environ['PGPASSWORD']
dsn = f'host={PGHOSTADDR} port={PGPORT} dbname={PGDATABASE} user={PGUSER} password={<PASSWORD>}'
api_user = os.environ['TERYTUSER']
api_password = os.environ['<PASSWORD>']
else:
dsn = args['dsn']
api_user = args['api_user']
api_password = args['<PASSWORD>']
api_env = args['api_env'][0]
main(api_env, dsn, api_user, api_password)
|
438068
|
import json
from confidant.app import create_app
from confidant.services import certificatemanager
def test_get_certificate(mocker):
app = create_app()
mocker.patch('confidant.settings.USE_AUTH', False)
mocker.patch(
'confidant.authnz.get_logged_in_user',
return_value='badservice',
)
mocker.patch(
'confidant.routes.certificates.authnz.user_is_user_type',
return_value=True,
)
mocker.patch(
'confidant.routes.certificates.authnz.user_is_service',
return_value=False,
)
ret = app.test_client().get(
'/v1/certificates/development/test.example.com',
follow_redirects=False,
)
assert ret.status_code == 403
mocker.patch(
'confidant.routes.certificates.authnz.user_is_user_type',
return_value=False,
)
mocker.patch(
'confidant.routes.certificates.authnz.get_logged_in_user',
return_value='<EMAIL>',
)
mocker.patch(
'confidant.routes.certificates.acl_module_check',
return_value=False,
)
ret = app.test_client().get(
'/v1/certificates/development/test.example.com',
follow_redirects=False,
)
assert ret.status_code == 403
mocker.patch(
'confidant.routes.certificates.acl_module_check',
return_value=True,
)
mocker.patch('confidant.authnz.get_logged_in_user', return_value='test')
ca_object = certificatemanager.CertificateAuthority('development')
mocker.patch(
('confidant.routes.certificates.certificatemanager.get_ca'),
return_value=ca_object,
)
ca_object.issue_certificate_with_key = mocker.Mock(
return_value={
'certificate': 'test_certificate',
'certificate_chain': 'test_certificate_chain',
'key': 'test_key',
},
)
ret = app.test_client().get(
'/v1/certificates/development/test.example.com',
follow_redirects=False,
)
json_data = json.loads(ret.data)
assert ret.status_code == 200
assert json_data == {
'certificate': 'test_certificate',
'certificate_chain': 'test_certificate_chain',
'key': 'test_key',
}
ca_object.issue_certificate_with_key = mocker.Mock(
side_effect=certificatemanager.CertificateNotReadyError(),
)
ret = app.test_client().get(
'/v1/certificates/development/test.example.com',
follow_redirects=False,
)
assert ret.status_code == 429
assert ret.headers['Retry-After'] == '2'
def test_get_certificate_from_csr(mocker):
ca_object = certificatemanager.CertificateAuthority('development')
key = ca_object.generate_key()
csr = ca_object.generate_csr(key, 'test.example.com')
pem_csr = ca_object.encode_csr(csr)
app = create_app()
mocker.patch('confidant.settings.USE_AUTH', False)
ret = app.test_client().post(
'/v1/certificates/development',
data=json.dumps({}),
content_type='application/json',
follow_redirects=False,
)
assert ret.status_code == 400
ret = app.test_client().post(
'/v1/certificates/development',
data=json.dumps({'validity': 7}),
content_type='application/json',
follow_redirects=False,
)
assert ret.status_code == 400
ret = app.test_client().post(
'/v1/certificates/development',
data=json.dumps({'csr': 'invalid_csr'}),
content_type='application/json',
follow_redirects=False,
)
assert ret.status_code == 400
mocker.patch(
'confidant.routes.certificates.authnz.user_is_user_type',
return_value=True,
)
mocker.patch(
'confidant.routes.certificates.authnz.user_is_service',
return_value=False,
)
mocker.patch(
'confidant.routes.certificates.authnz.get_logged_in_user',
return_value='badservice',
)
ret = app.test_client().post(
'/v1/certificates/development',
data=json.dumps({
'csr': pem_csr,
'validity': 7,
}),
content_type='application/json',
follow_redirects=False,
)
assert ret.status_code == 403
mocker.patch(
'confidant.routes.certificates.authnz.user_is_user_type',
return_value=False,
)
mocker.patch(
'confidant.routes.certificates.authnz.get_logged_in_user',
return_value='<EMAIL>',
)
mocker.patch(
'confidant.routes.certificates.acl_module_check',
return_value=False,
)
ret = app.test_client().post(
'/v1/certificates/development',
data=json.dumps({
'csr': pem_csr,
'validity': 7,
}),
content_type='application/json',
follow_redirects=False,
)
assert ret.status_code == 403
mocker.patch(
'confidant.routes.certificates.acl_module_check',
return_value=True,
)
mocker.patch(
('confidant.routes.certificates.certificatemanager.get_ca'),
return_value=ca_object,
)
ca_object.issue_certificate = mocker.Mock(
return_value='test-certificate-arn',
)
ca_object.get_certificate_from_arn = mocker.Mock(
return_value={
'certificate': 'test_certificate',
'certificate_chain': 'test_certificate_chain',
},
)
ret = app.test_client().post(
'/v1/certificates/development',
data=json.dumps({
'csr': pem_csr,
'validity': 7,
}),
content_type='application/json',
follow_redirects=False,
)
json_data = json.loads(ret.data)
assert ret.status_code == 200
assert json_data == {
'certificate': 'test_certificate',
'certificate_chain': 'test_certificate_chain',
}
def test_list_cas(mocker):
app = create_app()
mocker.patch('confidant.settings.USE_AUTH', False)
mocker.patch(
'confidant.routes.certificates.authnz.get_logged_in_user',
return_value='<EMAIL>',
)
mocker.patch(
'confidant.routes.certificates.acl_module_check',
return_value=False,
)
ret = app.test_client().get(
'/v1/cas',
follow_redirects=False,
)
assert ret.status_code == 403
mocker.patch(
'confidant.routes.certificates.acl_module_check',
return_value=True,
)
mocker.patch('confidant.authnz.get_logged_in_user', return_value='test')
cas = [{
'ca': 'development',
'certificate': 'test_certificate',
'certificate_chain': 'test_certificate_chain',
'tags': {'environment': 'development'},
}]
mocker.patch(
('confidant.routes.certificates.certificatemanager.list_cas'),
return_value=cas,
)
ret = app.test_client().get('/v1/cas', follow_redirects=False)
json_data = json.loads(ret.data)
assert ret.status_code == 200
assert json_data == {
'cas': [{
'ca': 'development',
'certificate': 'test_certificate',
'certificate_chain': 'test_certificate_chain',
'tags': {'environment': 'development'},
}],
}
def test_get_ca(mocker):
app = create_app()
mocker.patch('confidant.settings.USE_AUTH', False)
mocker.patch(
'confidant.routes.certificates.authnz.get_logged_in_user',
return_value='<EMAIL>',
)
mocker.patch(
'confidant.routes.certificates.acl_module_check',
return_value=False,
)
ret = app.test_client().get(
'/v1/cas',
follow_redirects=False,
)
assert ret.status_code == 403
mocker.patch(
'confidant.routes.certificates.acl_module_check',
return_value=True,
)
mocker.patch('confidant.authnz.get_logged_in_user', return_value='test')
ca_object = certificatemanager.CertificateAuthority('development')
mocker.patch(
('confidant.routes.certificates.certificatemanager.get_ca'),
return_value=ca_object,
)
ca_object.get_certificate_authority_certificate = mocker.Mock(
return_value={
'ca': 'development',
'certificate': 'test_certificate',
'certificate_chain': 'test_certificate_chain',
'tags': {'environment': 'development'},
},
)
ret = app.test_client().get('/v1/cas/development', follow_redirects=False)
json_data = json.loads(ret.data)
assert ret.status_code == 200
assert json_data == {
'ca': 'development',
'certificate': 'test_certificate',
'certificate_chain': 'test_certificate_chain',
'tags': {'environment': 'development'},
}
|
438070
|
import django
if django.VERSION >= (3, 1, 0):
from django.urls import re_path as url, include
else:
from django.conf.urls import url, include
from .views import home
urlpatterns = [url(r"^$", home), url(r"^captcha/", include("captcha.urls"))]
|
438127
|
from networkx.linalg.attrmatrix import *
from networkx.linalg import attrmatrix
from networkx.linalg.spectrum import *
from networkx.linalg import spectrum
from networkx.linalg.graphmatrix import *
from networkx.linalg import graphmatrix
from networkx.linalg.laplacianmatrix import *
from networkx.linalg import laplacianmatrix
from networkx.linalg.algebraicconnectivity import *
from networkx.linalg.modularitymatrix import *
from networkx.linalg import modularitymatrix
from networkx.linalg.bethehessianmatrix import *
from networkx.linalg import bethehessianmatrix
|
438156
|
from copy import deepcopy
from sqlite3 import Connection
from os.path import join, realpath
from warnings import warn
import shapely.wkb
from shapely.ops import unary_union
from shapely.geometry import Polygon
from aequilibrae.project.field_editor import FieldEditor
from aequilibrae.project.table_loader import TableLoader
from aequilibrae.project.project_creation import run_queries_from_sql_file
from .zone import Zone
from aequilibrae import logger
from aequilibrae.project.database_connection import database_connection
class Zoning:
"""
Access to the API resources to manipulate the zones table in the project
::
from aequilibrae import Project
p = Project()
p.open('path/to/project/folder')
zones = p.zoning
# We edit the fields for a particular zone
zone_downtown = zones.get(1)
zone_downtown.population = 637
zone_downtown.employment = 10039
zone_downtown.save()
fields = zones.fields()
# We can also add one more field to the table
fields.add('parking_spots', 'Total licensed parking spots', 'INTEGER')
"""
__items = {}
def __init__(self, network):
self.network = network
self.__all_types = []
self.conn = database_connection()
self.__curr = self.conn.cursor()
self.__fields = []
if self.__has_zoning():
self.__load()
def new(self, zone_id: int) -> Zone:
"""Creates a new zone
Returns:
*zone* (:obj:`Zone`): A new zone object populated only with zone_id (but not saved in the model yet)
"""
if zone_id in self.__items:
raise Exception(f"Zone ID {zone_id} already exists")
data = {key: None for key in self.__fields}
data["zone_id"] = zone_id
logger.info(f"Zone with id {zone_id} was created")
return self.__create_return_zone(data)
def create_zoning_layer(self):
"""Creates the 'zones' table for project files that did not previously contain it"""
if not self.__has_zoning():
qry_file = join(realpath(__file__), "database_specification", "tables", "zones.sql")
run_queries_from_sql_file(self.conn, qry_file)
self.__load()
else:
warn("zones table already exists. Nothing was done", Warning)
def extent(self) -> Polygon:
"""Queries the extent of the zoning system included in the model
Returns:
*model extent* (:obj:`Polygon`): Shapely polygon with the bounding box of the zoning system.
"""
self.__curr.execute('Select ST_asBinary(GetLayerExtent("Links"))')
poly = shapely.wkb.loads(self.__curr.fetchone()[0])
return poly
def coverage(self) -> Polygon:
""" Returns a single polygon for the entire zoning coverage
Returns:
*model coverage* (:obj:`Polygon`): Shapely (Multi)polygon of the zoning system.
"""
self.__curr.execute('Select ST_asBinary("geometry") from zones;')
polygons = [shapely.wkb.loads(x[0]) for x in self.__curr.fetchall()]
return unary_union(polygons)
def get(self, zone_id: str) -> Zone:
"""Get a zone from the model by its **zone_id**"""
if zone_id not in self.__items:
raise ValueError(f"Zone {zone_id} does not exist in the model")
return self.__items[zone_id]
def fields(self) -> FieldEditor:
"""Returns a FieldEditor class instance to edit the zones table fields and their metadata"""
return FieldEditor("zones")
def all_zones(self) -> dict:
"""Returns a dictionary with all Zone objects available in the model. zone_id as key"""
return self.__items
def save(self):
for zn in self.__items.values(): # type: Zone
zn.save()
def __copy__(self):
raise Exception("Zones object cannot be copied")
def __deepcopy__(self, memodict=None):
raise Exception("Zones object cannot be copied")
def __has_zoning(self):
curr = self.conn.cursor()
curr.execute("SELECT name FROM sqlite_master WHERE type='table';")
return any(["zone" in x[0].lower() for x in curr.fetchall()])
def __load(self):
tl = TableLoader()
zones_list = tl.load_table(self.__curr, "zones")
self.__fields = deepcopy(tl.fields)
existing_list = [zn["zone_id"] for zn in zones_list]
if zones_list:
self.__properties = list(zones_list[0].keys())
for zn in zones_list:
if zn["zone_id"] not in self.__items:
self.__items[zn["zone_id"]] = Zone(zn, self)
to_del = [key for key in self.__items.keys() if key not in existing_list]
for key in to_del:
del self.__items[key]
def _remove_zone(self, zone_id: int):
del self.__items[zone_id]
def __create_return_zone(self, data):
zone = Zone(data, self)
self.__items[zone.zone_id] = zone
return zone
|
438157
|
import datetime
import numpy as np
import pandas as pd
from scipy import stats
from collections import Counter
from tqdm import tqdm
tqdm.pandas(desc="progress")
#================================================================================
#Don't change the code below!!! 以下代码请勿轻易改动。
#================================================================================
def printlog(info):
nowtime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
print('\n================================================================================ %s'%nowtime)
print(info+'\n')
# 相关性ks检验
def relativity_ks(labels,features):
assert len(labels) == len(features)
labels = np.array(labels)
features = np.array(features)
# 非数值特征将字符转换成对应序号
if features.dtype is np.dtype('O'):
features_notnan = set(features[~pd.isna(features)])
features_notnan = [str(x) for x in features_notnan]
dic = dict(zip(range(0,len(features_notnan)),sorted(list(features_notnan))))
features = np.array([dic.get(x,x) for x in features])
else:
features = features
if set(labels) == {0,1}: #二分类问题
data_1 = features[labels > 0.5]
data_0 = features[labels < 0.5]
elif "int" in str(labels.dtype): #多分类问题
most_label = Counter(labels).most_common(1)[0][0]
data_0 = features[labels == most_label]
data_1 = features[labels != most_label]
else: #回归问题
mid = np.median(labels)
data_1 = features[labels > mid]
data_0 = features[labels <= mid ]
result = stats.ks_2samp(data_1,data_0)
return result[0]
# 同分布性ks检验
def stability_ks(data1,data2):
data1 = np.array(data1)
data2 = np.array(data2)
features = np.concatenate((data1,data2))
# 非数值特征将字符转换成对应序号
if features.dtype is np.dtype('O'):
features_notnan = set(features[~pd.isna(features)])
features_notnan = [str(x) for x in features_notnan]
dic = dict(zip(range(0,len(features_notnan)),sorted(list(features_notnan))))
data1 = np.array([dic.get(x,x) for x in data1])
data2 = np.array([dic.get(x,x) for x in data2])
result = stats.ks_2samp(data1,data2)
return result[0]
def eda(dftrain,dftest=pd.DataFrame(),language="Chinese"):
"""
Examples:
---------
>> from sklearn import datasets
>> from sklearn.model_selection import train_test_split
>> boston = datasets.load_boston()
>> df = pd.DataFrame(boston.data,columns = boston.feature_names)
>> df["label"] = boston.target
>> dftrain,dftest = train_test_split(df,test_size = 0.3)
>> dfeda = eda(dftrain,dftest,"English")
"""
print("start exploration data analysis...")
printlog('step1: count features & samples...')
if len(dftest)==0:
dftest = pd.DataFrame(columns = dftrain.columns)
assert 'label' in dftrain.columns, 'train data should with label column!'
assert all(dftrain.columns == dftest.columns), 'train data and test data should with the same columns!'
print('train samples number : %d'%len(dftrain))
print('test samples number : %d'%len(dftest))
print('features number : %d\n'%(len(dftrain.columns) - 1))
n_samples = len(dftrain)
n_features = len(dftrain.T)
dfeda = pd.DataFrame( np.zeros((n_features,8)),
columns = ['not_nan_ratio','not_nan_zero_ratio','not_nan_zero_minus1_ratio',
'classes_count','most','relativity','stability','distribution'])
dfeda.index = dftrain.columns
printlog('step2: evaluate not nan ratio...\n')
dfeda['not_nan_ratio'] = dftrain.count()/n_samples
printlog('step3: evaluate not zero ratio...\n')
dfeda['not_nan_zero_ratio'] = ((~dftrain.isna())&(~dftrain.isin([0,'0','0.0','0.00']))).sum()/n_samples
printlog('step4: evaluate not negative ratio...\n')
dfeda['not_nan_zero_minus1_ratio'] = ((~dftrain.isna())&(~dftrain.isin(
[0,'0','0.0','0.00',-1,-1.0,'-1','-1.0']))).sum()/n_samples
printlog('step5: evaluate classes count...\n')
dfeda['classes_count'] = dftrain.progress_apply(lambda x:len(x.drop_duplicates()))
printlog('step6: evaluate most value...\n')
try:
dfeda['most'] = dftrain.mode(dropna = False).iloc[0,:].T
except:
dfeda['most'] = dftrain.mode().iloc[0,:].T
printlog('step7: evaluate relativity...\n')
dfeda['relativity'] = dftrain.progress_apply(lambda x: relativity_ks(dftrain['label'],x))
printlog('step8: evaluate stability...\n')
if len(dftest)==0:
dfeda['stability'] = np.nan
else:
dfeda['stability'] = dftrain.progress_apply(lambda x: 1-stability_ks(x,dftest[x.name]))
printlog('step9: evaluate value distribution...\n')
dfeda['distribution'] = dftrain.progress_apply(lambda x:Counter(x).most_common(10))
dfeda_zh = dfeda.copy()
dfeda_zh.columns = [u'非空率',u'非空非零率',u'非空非零非负1率',u'取值类别数',u'众数',u'相关性',u'同分布性',u'取值分布']
printlog('tast end...\n\n')
if language=="Chinese":
return dfeda_zh
else:
return dfeda
#================================================================================
# You can change the code here below! 可以改动以下配置代码。
#================================================================================
if __name__ == "__main__":
import pandas as pd
from sklearn import datasets
from sklearn.model_selection import train_test_split
#二分类问题范例
breast = datasets.load_breast_cancer()
df = pd.DataFrame(breast.data,
columns = breast.feature_names)
df["label"] = breast.target
dfdata = df.copy()
dftrain,dftest = train_test_split(df,test_size = 0.3)
# 多分类问题范例
# iris = datasets.load_iris()
# df = pd.DataFrame(iris.data,
# columns = [x.replace(" (cm)","").replace(" ","_") for x in iris.feature_names])
# df["label"] = iris.target
# dfdata = df.copy()
# dftrain,dftest = train_test_split(df,test_size = 0.3)
# # 回归问题范例
# boston = datasets.load_boston()
# df = pd.DataFrame(boston.data,
# columns = boston.feature_names)
# df["label"] = boston.target
# dfdata = df.copy()
# dftrain,dftest = train_test_split(df,test_size = 0.3)
dfeda = eda(dftrain,dftest,"English")
print(dfeda)
######
#####
####
###
##
#
|
438171
|
from leaguepedia_parser.parsers.game_parser import (
get_regions,
get_tournaments,
get_games,
get_game_details,
)
from leaguepedia_parser.parsers.team_parser import (
get_team_logo,
get_long_team_name_from_trigram,
get_team_thumbnail,
get_all_team_assets
)
|
438188
|
from bitcoin.pyspecials import *
from bitcoin.main import *
from bitcoin.deterministic import *
from bitcoin.bci import *
from bitcoin.transaction import *
from bitcoin.composite import *
import re, hmac, hashlib
try:
from strxor import strxor as sxor
except ImportError:
sxor = lambda a,b: ''.join([chr(ord(a) ^ ord(b)) for a,b in zip(s1, s2)])
RE_HEXCODE = re.compile(r'^0100(02|03)[0-9a-fA-F]{128}0{26}$')
RE_PAYCODE = re.compile(r"^P[1-9a-km-zA-HJ-NP-Z]{0,115}$")
def is_bip47_code(s):
assert isinstance(s, string_types)
if not RE_HEX_CHARS.match(s) and len(s)==80:
return is_bip47_code(safe_hexlify(s))
elif RE_HEX_CHARS.match(s) and len(s)==160:
return bool(RE_HEXCODE.match(s))
elif s[0] == 'P':
return bool(RE_PAYCODE.match(s))
return False
def bip47_ckd(seed):
"""Derive derived xpub from entropy or mnemonic"""
assert isinstance(seed, string_types) and \
(RE_MNEMONIC.match(seed) or RE_BIP32_PRIV.match(seed)), \
""
return bip32_ckd(bip32_master_key(seed), "M/47'/0'/0'")
def mk_paycode(xkey):
"""Derive paycode from initial entropy/mnemonic/bip32 root key """
if xkey.startswith("xprv") or RE_MNEMONIC.match(xkey) or \
(RE_HEX_CHARS.match(xkey) and len(xkey) % 32 == 0):
pcode = serialize_paycode(bip47_ckd(xkey))
elif xkey[:4] == "xpub":
pcode = serialize_paycode(xkey)
return pcode
def b58_paycode_decode(pcode):
"""Decode b58check to hex paycode"""
assert is_bip47_code(pcode)
return b58check_to_hex(pcode)
def b58_paycode_encode(hexstr):
"""Encode hex paycode to b58check hexcode"""
assert is_bip47_code(hexstr)
return hex_to_b58check(hexstr, 0x47)
# args = (pubkey, chaincode) or derived xpub(key)
def serialize_paycode(*args):
"""Serialize xpub or (pubkey, chaincode) into hex"""
# Convenience function, derived xpub
if RE_BIP32_PUB.match(str(args[0])):
xpub = args[0]
depth = bip32_deserialize(xpub)[1]
assert depth == 3, "xpub depth is {0} and must be 3".format(depth)
cc = bip32_extract_chaincode(xpub)
pub = bip32_extract_key(xpub)
elif isinstance(args[0], tuple):
pub, cc = sorted(args, key=lambda x: -len(x))
pub, cc = decode(pub, 16), decode(cc, 16)
return '0100{0:066x}{1:064x}{2:026x}'.format(pub, cc, 0)
def deserialize_paycode(pcode):
"""Deserialize hex or b58check paycode to (pubkey, chaincode) """
assert is_bip47_code(pcode)
hex = b58_paycode_decode(pcode) if pcode.startswith('P') else pcode
pubkey = hex[4:70]
chaincode = hex[70:134]
assert (hex[:4], hex[-26:]) == ('0100', '00'*13), \
"Deserialize Error! Ensure hex paycode is hexlified"
return pubkey, chaincode
def find_S(a, B):
"""Find secret point, S, from notification Tx's 1st privkey (a) and receiver's pubkey (B)"""
assert is_privkey(a) and is_pubkey(B)
a, B = decode_privkey(a), decode_pubkey(B)
S = encode_pubkey(fast_multiply(B, a), 'hex_compressed')
return S[2:]
def find_blinding_factor(a, B, outpoint):
"""Outpoint is in "TXID:VOUT", a is Alice's privkey, B is Bob's pubkey"""
txid, vout = outpoint.split(":")
x = changebase(find_S(a, B), 16, 256, 32)
o = changebase(txid, 16, 256, 32)[::-1] + changebase(vout, 16, 256, 4)[::-1]
s = hmac.new(x, o, hashlib.sha512).hexdigest()
return s
# TODO: not working, matches A0
# deserialize_paycode() broken??
# def bip47_check_derivation(privkey, paycode):
# assert RE_PRIVKEY.match(privkey), "{0} is not a privkey".format(privkey)
# assert RE_PAYCODE.match(paycode), "{0} is not a paycode".format(paycode)
# pubkey, _ = deserialize_paycode(paycode)
# return compress(privtopub(privkey)) == pubkey
def get_xor_paycode(a, B, outpoint, paycode_in):
#assert bip47_check_derivation(a, paycode_in), "Privkey, {0}, not derived from {1}".format(a, paycode_in)
bf = unhexlify(find_blinding_factor(a, B, outpoint))
x, c = deserialize_paycode(paycode_in)
parity = x[:2]
x = x[2:]
assert parity in ('02', '03')
xdash = sxor(bf[:32], changebase(x, 16, 256, 32))
cdash = sxor(bf[-32:], changebase(c, 16, 256, 32))
return serialize_paycode(parity+changebase(xdash, 256, 16, 64), changebase(cdash, 256, 16, 64))
#def check_blinded_paycode(a, B, outpoint, paycode_in):
# bf = unhexlify(find_blinding_factor(a, B, outpoint))
# a = private key which signs outpoint, "txid:1", and sends to B's notification address
def bip47_mk_notification_tx(a, outpoint, paycodeB):
# a is a privkey which should be difficult to associate with Alice
from_addr = privtoaddr(a)
from_pubkey = compress(privtopub(a))
pubB, chaincodeB = deserialize_paycode(paycodeB)
notification_address = pubtoaddr(pubB)
# TODO: need to figure out how the value is decided
txh = blockcypher_mktx(from_addr, notification_address, 50000)
txo = deserialize(txh)
outpoint = ""
# for inp in txo["ins"]:
# spk_items = deserialize_script(inp.get("script"))
# if RE_DER.match(spk_items[0]) and RE_PUBKEY.match(spk_items[-1]):
#
# if spk[-1] in (from_pubkey, decompress(from_pubkey)):
# outpoint = "{hash}:{index}".format(hash=inp["outpoint"]["hash"], index=inp["outpoint"]["index"])
# txo['outs'].append({'script': get_xor_paycode(a, B, outpoint, ), 'value': 0})
def bip47_check_address(addr, index=0):
"""Checks notification address at decreasing indexes for payments,
returns [{"txid:vout": "6a4c5001..."}]"""
#from bitcoin.transaction import get_script
un = unspent(addr)[int(index) : 1+int(index)]
outpoints = access(un, "output")[int(index)]
txids = map(lambda s: str(s[:64]), outpoints)
#scripts = []
scriptpks = list(multiaccess(txo.get('outs'), 'script'))
opret = filter(lambda s: s.startswith("6a4c5001"), scriptpks)
assert is_bip47_code(deserialize_script(opret)[-1])
return scripts
# if scriptpk startswith 01 then select first exposed pubkey
Amn = "response seminar brave tip suit recall often sound stick owner lottery motion"
Apc = "<KEY>"
Bmn = "reward upper indicate eight swift arch injury crystal super wrestle already dentist"
Bpc = "<KEY>"
a0 = "8d6a8ecd8ee5e0042ad0cb56e3a971c760b5145c3917a8e7beaf0ed92d7a520c"
A0 = "0353883a146a23f988e0f381a9507cbdb3e3130cd81b3ce26daf2af088724ce683"
b0 = "04448fd1be0c9c13a5ca0b530e464b619dc091b299b98c5cab9978b32b4a1b8b"
B0 = "024ce8e3b04ea205ff49f529950616c3db615b1e37753858cc60c1ce64d17e2ad8"
S0 = multiply(B0, a0) # "03f5bb84706ee366052471e6139e6a9a969d586e5fe6471a9b96c3d8caefe86fef"
addrs = ['<KEY>', '<KEY>', '<KEY>', '<KEY>', '<KEY>', '<KEY>', '<KEY>', '<KEY>', '<KEY>', '<KEY>']
Ss = ['f5bb84706ee366052471e6139e6a9a969d586e5fe6471a9b96c3d8caefe86fef', 'adfb9b18ee1c4460852806a8780802096d67a8c1766222598dc801076beb0b4d', '79e860c3eb885723bb5a1d54e5cecb7df5dc33b1d56802906762622fa3c18ee5', 'd8339a01189872988ed4bd5954518485edebf52762bf698b75800ac38e32816d', '14c687bc1a01eb31e867e529fee73dd7540c51b9ff98f763adf1fc2f43f98e83', '<KEY>', '<KEY>', '5f5ecc738095a6fb1ea47acda4996f1206d3b30448f233ef6ed27baf77e81e46', '<KEY>', 'fe36c27c62c99605d6cd7b63bf8d9fe85d753592b14744efca8be20a4d767c37']
bs = ['04448fd1be0c9c13a5ca0b530e464b619dc091b299b98c5cab9978b32b4a1b8b', '<KEY>', '46d32fbee043d8ee176fe85a18da92557ee00b189b533fce2340e4745c4b7b8c', '<KEY>', '<KEY>', 'ce67e97abf4772d88385e66d9bf530ee66e07172d40219c62ee721ff1a0dca01', 'ef049794ed2eef833d5466b3be6fe7676512aa302afcde0f88d6fcfe8c32cc09', 'd3ea8f780bed7ef2cd0e38c5d943639663236247c0a77c2c16d374e5a202455b', 'efb86ca2a3bad69558c2f7c2a1e2d7008bf7511acad5c2cbf909b851eb77e8f3', '<KEY>']
Bs = ['024ce8e3b04ea205ff49f529950616c3db615b1e37753858cc60c1ce64d17e2ad8', '03e092e58581cf950ff9c8fc64395471733e13f97dedac0044ebd7d60ccc1eea4d', '<KEY>', '<KEY>', '<KEY>', '03dac6d8f74cacc7630106a1cfd68026c095d3d572f3ea088d9a078958f8593572', '02396351f38e5e46d9a270ad8ee221f250eb35a575e98805e94d11f45d763c4651', '<KEY>', '<KEY>', '03d51a06c6b48f067ff144d5acdfbe046efa2e83515012cf4990a89341c1440289']
bip47_txid = "bad5802e2183be44007b6b94395113d7cb513dbeb68d40245a83f5fadfcc76f3"
bip47_txid2 = "9414f1681fb1255bd168a806254321a837008dd4480c02226063183deb100204"
pchex = "010002063e4eb95e62791b06c50e1a3a942e1ecaaa9afbbeb324d16ae6821e091611fa96c0cf048f607fe51a0327f5e2528979311c78cb2de0d682c61e1180fc3d543b00000000000000000000000000"
txh = "010000000186f411ab1c8e70ae8a0795ab7a6757aea6e4d5ae1826fc7b8f00c597d500609c010000006b483045022100ac8c6dbc482c79e86c18928a8b364923c774bfdbd852059f6b3778f2319b59a7022029d7cc5724e2f41ab1fcfc0ba5a0d4f57ca76f72f19530ba97c860c70a6bf0a801210272d83d8a1fa323feab1c085157a0791b46eba34afb8bfbfaeb3a3fcc3f2c9ad8ffffffff0210270000000000001976a9148066a8e7ee82e5c5b9b7dc1765038340dc5420a988ac1027000000000000536a4c50010002063e4eb95e62791b06c50e1a3a942e1ecaaa9afbbeb324d16ae6821e091611fa96c0cf048f607fe51a0327f5e2528979311c78cb2de0d682c61e1180fc3d543b0000000000000000000000000000000000"
txo = {
'ins': [{'outpoint': {'hash': '9c6000d597c5008f7bfc2618aed5e4a6ae57677aab95078aae708e1cab11f486',
'index': 1},
'script': '483045022100ac8c6dbc482c79e86c18928a8b364923c774bfdbd852059f6b3778f2319b59a7022029d7cc5724e2f41ab1fcfc0ba5a0d4f57ca76f72f19530ba97c860c70a6bf0a801210272d83d8a1fa323feab1c085157a0791b46eba34afb8bfbfaeb3a3fcc3f2c9ad8',
'sequence': 4294967295}],
'locktime': 0,
'outs': [{'script': '76a9148066a8e7ee82e5c5b9b7dc1765038340dc5420a988ac',
'value': 10000},
{'script': '6a4c50010002063e4eb95e62791b06c50e1a3a942e1ecaaa9afbbeb324d16ae6821e091611fa96c0cf048f607fe51a0327f5e2528979311c78cb2de0d682c61e1180fc3d543b00000000000000000000000000',
'value': 10000}],
'version': 1}
ins = ['9414f1681fb1255bd168a806254321a837008dd4480c02226063183deb100204:1']
outs = ['1ChvUUvht2hUQufHBXF8NgLhW8SwE2ecGV:50000']
outpoint = ins[0]
raw = "0100000001040210eb3d18636022020c48d48d0037a821432506a868d15b25b11f68f114940100000000ffffffff0150c30000000000001976a9148066a8e7ee82e5c5b9b7dc1765038340dc5420a988ac00000000"
rawo = {'locktime': 0, 'outs': [{'value': 50000, 'script': '76a9148066a8e7ee82e5c5b9b7dc1765038340dc5420a988ac'}], 'version': 1, 'ins': [{'script': '', 'outpoint': {'index': 1, 'hash': '9414f1681fb1255bd168a806254321a837008dd4480c02226063183deb100204'}, 'sequence': 4294967295}]}
#rawo['outs'].append({'script': get_xor_paycode(a0, B0, outpoint, Bpc), 'value': 0})
Apubkey = "<KEY>"
Bpubkey = "<KEY>"
|
438248
|
from typing import Any, Optional
from django.db.models import QuerySet
from rest_framework.exceptions import NotFound
from rest_framework.request import Request
from rest_framework.response import Response
from app.views import AuthenticatedAPIView
from notion.api.serializers import NotionPageSerializer
from notion.api.throttling import NotionThrottle
from notion.cache import get_cached_page
from notion.helpers import uuid_to_id
from notion.models import Material
from notion.page import NotionPage
from studying.models import Study
class NotionMaterialView(AuthenticatedAPIView):
throttle_classes = [NotionThrottle]
def get(self, request: Request, *args, **kwargs) -> Response:
material = self.get_material()
if material is None:
raise NotFound()
page = get_cached_page(material.page_id)
return Response(
data=NotionPageSerializer(page).data,
status=200,
headers=self.get_headers(page),
)
def get_material(self) -> Optional[Material]:
queryset = self.get_queryset()
return queryset.filter(page_id=self.page_id).first()
def get_queryset(self) -> QuerySet[Material]:
if self.request.user.is_superuser or self.request.user.has_perm('notion.see_all_materials'):
return Material.objects.all()
available_courses = Study.objects.filter(student=self.request.user).values('course')
return Material.objects.filter(active=True, course__in=available_courses)
@staticmethod
def get_headers(page: NotionPage) -> dict:
headers: dict[str, Any] = dict()
if page.last_modified is not None:
headers['last-modified'] = page.last_modified.strftime('%a, %d %b %Y %H:%M:%S %Z')
return headers
@property
def page_id(self) -> str:
return uuid_to_id(self.kwargs['page_id'])
|
438251
|
import unittest
from ocr_numbers import (
convert,
)
# Tests adapted from `problem-specifications//canonical-data.json`
class OcrNumbersTest(unittest.TestCase):
def test_recognizes_0(self):
self.assertEqual(convert([" _ ", "| |", "|_|", " "]), "0")
def test_recognizes_1(self):
self.assertEqual(convert([" ", " |", " |", " "]), "1")
def test_unreadable_but_correctly_sized_inputs_return(self):
self.assertEqual(convert([" ", " _", " |", " "]), "?")
def test_input_with_a_number_of_lines_that_is_not_a_multiple_of_four_raises_an_error(
self,
):
with self.assertRaises(ValueError) as err:
convert([" _ ", "| |", " "])
self.assertEqual(type(err.exception), ValueError)
self.assertEqual(
err.exception.args[0], "Number of input lines is not a multiple of four"
)
def test_input_with_a_number_of_columns_that_is_not_a_multiple_of_three_raises_an_error(
self,
):
with self.assertRaises(ValueError) as err:
convert([" ", " |", " |", " "])
self.assertEqual(type(err.exception), ValueError)
self.assertEqual(
err.exception.args[0], "Number of input columns is not a multiple of three"
)
def test_recognizes_110101100(self):
self.assertEqual(
convert(
[
" _ _ _ _ ",
" | || | || | | || || |",
" | ||_| ||_| | ||_||_|",
" ",
]
),
"110101100",
)
def test_garbled_numbers_in_a_string_are_replaced_with(self):
self.assertEqual(
convert(
[
" _ _ _ ",
" | || | || | || || |",
" | | _| ||_| | ||_||_|",
" ",
]
),
"11?10?1?0",
)
def test_recognizes_2(self):
self.assertEqual(convert([" _ ", " _|", "|_ ", " "]), "2")
def test_recognizes_3(self):
self.assertEqual(convert([" _ ", " _|", " _|", " "]), "3")
def test_recognizes_4(self):
self.assertEqual(convert([" ", "|_|", " |", " "]), "4")
def test_recognizes_5(self):
self.assertEqual(convert([" _ ", "|_ ", " _|", " "]), "5")
def test_recognizes_6(self):
self.assertEqual(convert([" _ ", "|_ ", "|_|", " "]), "6")
def test_recognizes_7(self):
self.assertEqual(convert([" _ ", " |", " |", " "]), "7")
def test_recognizes_8(self):
self.assertEqual(convert([" _ ", "|_|", "|_|", " "]), "8")
def test_recognizes_9(self):
self.assertEqual(convert([" _ ", "|_|", " _|", " "]), "9")
def test_recognizes_string_of_decimal_numbers(self):
self.assertEqual(
convert(
[
" _ _ _ _ _ _ _ _ ",
" | _| _||_||_ |_ ||_||_|| |",
" ||_ _| | _||_| ||_| _||_|",
" ",
]
),
"1234567890",
)
def test_numbers_separated_by_empty_lines_are_recognized_lines_are_joined_by_commas(
self,
):
self.assertEqual(
convert(
[
" _ _ ",
" | _| _|",
" ||_ _|",
" ",
" _ _ ",
"|_||_ |_ ",
" | _||_|",
" ",
" _ _ _ ",
" ||_||_|",
" ||_| _|",
" ",
]
),
"123,456,789",
)
|
438260
|
from django.core.cache import cache
from airmozilla.starred.models import StarredEvent
def stars(request):
context = {}
if request.user.is_active:
context['star_ids'] = _get_star_ids(request.user)
return context
def _get_star_ids(user):
cache_key = 'star_ids%s' % user.id
as_string = cache.get(cache_key)
if as_string is None:
ids = list(
StarredEvent.objects
.filter(user=user)
.values_list('event_id', flat=True)
.order_by('created')
)
as_string = ','.join(str(x) for x in ids)
cache.set(cache_key, as_string, 60 * 60)
return as_string
|
438322
|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from pathos.pools import ProcessPool
from scipy import interpolate
from scipy.integrate import solve_ivp
from scipy.special import legendre
import config
from ADR_solver import solve_ADR
from ADVD_solver import solve_ADVD
from CVC_solver import solve_CVC
from utils import timing
class LTSystem(object):
def __init__(self, npoints_output):
"""Legendre transform J_n{f(x)}.
Args:
npoints_output: For a input function, choose n=0,1,2,...,`npoints_output`-1 as data.
"""
self.npoints_output = npoints_output
@timing
def gen_operator_data(self, space, m, num):
"""For each input function, generate `npoints_output` data, so the total number N = num x npoints_output.
"""
print("Generating operator data...", flush=True)
features = space.random(num)
sensors = np.linspace(0, 2, num=m)[:, None]
sensor_values = space.eval_u(features, sensors)
sensor_values_tile = np.tile(sensor_values, (1, self.npoints_output)).reshape(
[-1, m]
)
ns = np.tile(np.arange(self.npoints_output)[:, None], (num, 1))
s_values = np.vstack(list(map(self.eval_s, sensor_values)))
return [sensor_values_tile, ns], s_values
def eval_s(self, sensor_value):
"""Compute J_n{f(x)} for a `sensor_value` of `f` with n=0,1,...,'npoints_output'-1.
"""
x = np.linspace(-1, 1, num=10000)
samplings = interpolate.interp1d(
np.linspace(-1, 1, len(sensor_value)), sensor_value, kind="cubic"
)(x)
ns = np.arange(self.npoints_output)
ys = np.vstack(list(map(lambda n: legendre(n)(x), ns)))
return np.sum((samplings * ys)[:, 1:], axis=1, keepdims=True) * (x[1] - x[0])
class ODESystem(object):
def __init__(self, g, s0, T):
self.g = g
self.s0 = s0
self.T = T
@timing
def gen_operator_data(self, space, m, num):
print("Generating operator data...", flush=True)
features = space.random(num)
sensors = np.linspace(0, self.T, num=m)[:, None]
sensor_values = space.eval_u(features, sensors)
x = self.T * np.random.rand(num)[:, None]
y = self.eval_s_space(space, features, x)
return [sensor_values, x], y
def eval_s_space(self, space, features, x):
"""For a list of functions in `space` represented by `features`
and a list `x`, compute the corresponding list of outputs.
"""
def f(feature, xi):
return self.eval_s(lambda t: space.eval_u_one(feature, t), xi[0])
p = ProcessPool(nodes=config.processes)
res = p.map(f, features, x)
return np.array(list(res))
def eval_s_func(self, u, x):
"""For an input function `u` and a list `x`, compute the corresponding list of outputs.
"""
res = map(lambda xi: self.eval_s(u, xi[0]), x)
return np.array(list(res))
def eval_s(self, u, tf):
"""Compute `s`(`tf`) for an input function `u`.
"""
def f(t, y):
return self.g(y, u(t), t)
sol = solve_ivp(f, [0, tf], self.s0, method="RK45")
return sol.y[0, -1:]
class DRSystem(object):
def __init__(self, D, k, T, Nt, npoints_output):
"""Diffusion-reaction on the domain [0, 1] x [0, T].
Args:
T: Time [0, T].
Nt: Nt in FDM
npoints_output: For a input function, randomly choose these many points from the solver output as data
"""
self.D = D
self.k = k
self.T = T
self.Nt = Nt
self.npoints_output = npoints_output
@timing
def gen_operator_data(self, space, m, num):
"""For each input function, generate `npoints_output` data, so the total number N = num x npoints_output.
"""
print("Generating operator data...", flush=True)
features = space.random(num)
sensors = np.linspace(0, 1, num=m)[:, None]
sensor_values = space.eval_u(features, sensors)
# p = ProcessPool(nodes=config.processes)
# s_values = p.map(self.eval_s, sensor_values)
s_values = map(self.eval_s, sensor_values)
res = np.vstack(list(map(self.eval_s_sampling, sensor_values, s_values)))
return [res[:, :m], res[:, m:-1]], res[:, -1:]
def eval_s_sampling(self, sensor_value, s):
"""Given a `sensor_value` of `u` and the corresponding solution `s`, generate the
sampling outputs.
"""
m = sensor_value.shape[0]
x = np.random.randint(m, size=self.npoints_output)
t = np.random.randint(self.Nt, size=self.npoints_output)
xt = np.hstack([x[:, None], t[:, None]]) * [1 / (m - 1), self.T / (self.Nt - 1)]
y = s[x][range(self.npoints_output), t][:, None]
return np.hstack([np.tile(sensor_value, (self.npoints_output, 1)), xt, y])
def eval_s(self, sensor_value):
"""Compute s(x, t) over m * Nt points for a `sensor_value` of `u`.
"""
return solve_ADR(
0,
1,
0,
self.T,
lambda x: self.D * np.ones_like(x),
lambda x: np.zeros_like(x),
lambda u: self.k * u ** 2,
lambda u: 2 * self.k * u,
lambda x, t: np.tile(sensor_value[:, None], (1, len(t))),
lambda x: np.zeros_like(x),
len(sensor_value),
self.Nt,
)[2]
class CVCSystem(object):
def __init__(self, f, g, T, Nt, npoints_output):
"""Advection on the domain [0, 1] x [0, T].
Args:
T: Time [0, T].
Nt: Nt in FDM
npoints_output: For a input function, randomly choose these many points from the solver output as data
"""
self.f = f
self.g = g
self.T = T
self.Nt = Nt
self.npoints_output = npoints_output
@timing
def gen_operator_data(self, space, m, num):
"""For each input function, generate `npoints_output` data, so the total number N = num x npoints_output.
"""
print("Generating operator data...", flush=True)
features = space.random(num)
sensors = np.linspace(0, 1, num=m)[:, None]
# Case I Input: V(sin^2(pi*x))
sensor_values = space.eval_u(features, np.sin(np.pi * sensors) ** 2)
# Case II Input: x*V(x)
# sensor_values = sensors.T * space.eval_u(features, sensors)
# Case III/IV Input: V(x)
# sensor_values = space.eval_u(features, sensors)
# p = ProcessPool(nodes=config.processes)
# s_values = np.array(p.map(self.eval_s, sensor_values))
s_values = np.array(list(map(self.eval_s, sensor_values)))
res = np.vstack(list(map(self.eval_s_sampling, sensor_values, s_values)))
return [res[:, :m], res[:, m:-1]], res[:, -1:]
def eval_s_sampling(self, sensor_value, s):
"""Given a `sensor_value` of `u` and the corresponding solution `s`, generate the
sampling outputs.
"""
m = sensor_value.shape[0]
x = np.random.randint(m, size=self.npoints_output)
t = np.random.randint(self.Nt, size=self.npoints_output)
xt = np.hstack([x[:, None], t[:, None]]) * [1 / (m - 1), self.T / (self.Nt - 1)]
y = s[x][range(self.npoints_output), t][:, None]
return np.hstack([np.tile(sensor_value, (self.npoints_output, 1)), xt, y])
def eval_s(self, sensor_value):
"""Compute s(x, t) over m * Nt points for a `sensor_value` of `u`.
"""
# Case I: Analytical solution for a(x)=1, u(x,0)=V(x) (V,V' periodic)
return solve_CVC(
0,
1,
0,
self.T,
self.f,
self.g,
interpolate.interp1d(
np.linspace(0, 1, len(sensor_value)), sensor_value, kind="cubic"
),
len(sensor_value),
self.Nt,
)[2]
# Case II: Wendroff for a(x)=1, u(x,0)=f(x), u(0,t)=g(t) (f(0)=g(0))
"""
return solve_CVC(
0,
1,
0,
self.T,
lambda x: sensor_value,
lambda t: np.zeros_like(t),
None,
len(sensor_value),
self.Nt,
)[2]
"""
# Case III: Wendroff for a(x)=1+0.1*V(x), u(x,0)=f(x), u(0,t)=g(t) (f(0)=g(0))
"""
return solve_CVC(
0,
1,
0,
self.T,
lambda x: x ** 2,
lambda t: np.sin(np.pi * t),
lambda x: sensor_value,
len(sensor_value),
self.Nt,
)[2]
"""
# Case IV: Wendroff for a(x)=1+0.1*(V(x)+V(1-x))/2, u(x,0)=f(x) (f,f' periodic)
"""
return solve_CVC(
0,
1,
0,
self.T,
lambda x: np.sin(2 * np.pi * x),
None,
lambda x: sensor_value,
len(sensor_value),
self.Nt,
)[2]
"""
class ADVDSystem(object):
def __init__(self, f, g, T, Nt, npoints_output):
"""Advection-diffusion on the domain [0, 1] x [0, T].
Args:
T: Time [0, T].
Nt: Nt in FDM
npoints_output: For a input function, randomly choose these many points from the solver output as data
"""
self.f = f
self.g = g
self.T = T
self.Nt = Nt
self.npoints_output = npoints_output
@timing
def gen_operator_data(self, space, m, num):
"""For each input function, generate `npoints_output` data, so the total number N = num x npoints_output.
"""
print("Generating operator data...", flush=True)
features = space.random(num)
sensors = np.linspace(0, 1, num=m)[:, None]
# Input: V(sin^2(pi*x))
sensor_values = space.eval_u(features, np.sin(np.pi * sensors) ** 2)
# p = ProcessPool(nodes=config.processes)
# s_values = np.array(p.map(self.eval_s, sensor_values))
s_values = np.array(list(map(self.eval_s, sensor_values)))
res = np.vstack(list(map(self.eval_s_sampling, sensor_values, s_values)))
return [res[:, :m], res[:, m:-1]], res[:, -1:]
def eval_s_sampling(self, sensor_value, s):
"""Given a `sensor_value` of `u` and the corresponding solution `s`, generate the
sampling outputs.
"""
m = sensor_value.shape[0]
x = np.random.randint(m, size=self.npoints_output)
t = np.random.randint(self.Nt, size=self.npoints_output)
xt = np.hstack([x[:, None], t[:, None]]) * [1 / (m - 1), self.T / (self.Nt - 1)]
y = s[x][range(self.npoints_output), t][:, None]
return np.hstack([np.tile(sensor_value, (self.npoints_output, 1)), xt, y])
def eval_s(self, sensor_value):
"""Compute s(x, t) over m * Nt points for a `sensor_value` of `u`.
"""
Nt_pc = (self.Nt - 1) * 10 + 1
return solve_ADVD(
0,
1,
0,
self.T,
self.f,
self.g,
lambda x: sensor_value,
len(sensor_value),
Nt_pc,
)[2][:, 0:Nt_pc:10]
|
438376
|
from tests.base_unittest import BaseUnitTest
from mock import Mock
from mock import patch
from pypokerengine.engine.player import Player
from pypokerengine.engine.seats import Seats
from pypokerengine.engine.table import Table
from pypokerengine.engine.card import Card
from pypokerengine.engine.message_builder import MessageBuilder
from pypokerengine.engine.dealer import MessageHandler
from pypokerengine.players import BasePokerPlayer
from nose.tools import *
class MessageIntegrationTest(BaseUnitTest):
def setUp(self):
self.player = BasePokerPlayer()
self.MH = MessageHandler()
self.MH.register_algorithm("U", self.player)
def test_game_start_message(self):
with patch.object(self.player, 'receive_game_start_message') as monkey:
msg = self.__game_start_message()
self.MH.process_message(-1, msg)
monkey.assert_called_with(msg["message"]["game_information"])
def test_round_start_message(self):
with patch.object(self.player, 'receive_round_start_message') as monkey:
msg = self.__round_start_message()
self.MH.process_message("U", msg)
round_count = msg["message"]["round_count"]
hole = msg["message"]["hole_card"]
seats = msg["message"]["seats"]
monkey.assert_called_with(round_count, hole, seats)
def test_street_start_message(self):
with patch.object(self.player, 'receive_street_start_message') as monkey:
msg = self.__street_start_message()
self.MH.process_message(-1, msg)
street = "flop"
round_state = msg["message"]["round_state"]
monkey.assert_called_with(street, round_state)
def test_ask_message(self):
with patch.object(self.player, 'declare_action') as monkey:
msg = self.__ask_message()
self.MH.process_message("U", msg)
hole = msg["message"]["hole_card"]
valid_actions = msg["message"]["valid_actions"]
round_state = msg["message"]["round_state"]
monkey.assert_called_with(valid_actions, hole, round_state)
def test_game_update_message(self):
with patch.object(self.player, 'receive_game_update_message') as monkey:
msg = self.__game_update_message()
self.MH.process_message(-1, msg)
action = msg["message"]["action"]
round_state = msg["message"]["round_state"]
monkey.assert_called_with(action, round_state)
def test_round_result_message(self):
with patch.object(self.player, 'receive_round_result_message') as monkey:
msg = self.__round_result_message()
self.MH.process_message(-1, msg)
winners = msg["message"]["winners"]
hand_info = msg["message"]["hand_info"]
round_state = msg["message"]["round_state"]
monkey.assert_called_with(winners, hand_info, round_state)
def __game_start_message(self):
config = self.__setup_config()
seats = self.__setup_seats()
return MessageBuilder.build_game_start_message(config, seats)
def __round_start_message(self):
seats = self.__setup_seats()
return MessageBuilder.build_round_start_message(7, 1, seats)
def __street_start_message(self):
state = self.__setup_state()
return MessageBuilder.build_street_start_message(state)
def __ask_message(self):
state = self.__setup_state()
return MessageBuilder.build_ask_message(1, state)
def __game_update_message(self):
state = self.__setup_state()
return MessageBuilder.build_game_update_message(1, "call", 10, state)
def __round_result_message(self):
hand_info = ["dummy", "info"]
state = self.__setup_state()
winners = state["table"].seats.players[1:2]
return MessageBuilder.build_round_result_message(7, winners, hand_info, state)
def __game_result_message(self):
config = self.__setup_config()
seats = self.__setup_seats()
return MessageBuilder.build_game_result_message(config, seats)
def __setup_state(self):
return {
"street": 1,
"next_player": 2,
"round_count": 3,
"small_blind_amount": 4,
"table": self.__setup_table()
}
def __setup_table(self):
table = Table()
table.set_blind_pos(0, 1)
table.seats = self.__setup_seats()
table.add_community_card(Card.from_id(1))
return table
def __setup_config(self):
return { "initial_stack":100, "max_round": 10, "small_blind_amount": 5,\
"ante": 3, "blind_structure": {}}
def __setup_seats(self):
seats = Seats()
for player in self.__setup_players():
seats.sitdown(player)
return seats
def __setup_players(self):
hole = [Card.from_id(1), Card.from_id(2)]
players = [self.__setup_player() for _ in range(3)]
players[1].add_holecard(hole)
return players
def __setup_player(self):
return Player("uuid", 100, "hoge")
|
438377
|
import random
from pprint import pformat
import disnake
from disnake import Localized
from disnake.enums import Locale
from disnake.ext import commands
class Localizations(commands.Cog):
def __init__(self, bot):
self.bot: commands.Bot = bot
@commands.slash_command()
async def localized_command(
self,
inter: disnake.AppCmdInter,
auto: str,
choice: str = commands.Param(
choices=[
# lookup keys for choices
Localized("a", key="CHOICE_A"),
Localized("o", key="CHOICE_O"),
Localized("u", key="CHOICE_U"),
]
),
other: str = commands.Param(
# by lookup key
name=Localized(key="OTHER_NAME"),
# specify localizations directly
description=Localized(data={Locale.en_GB: "insert bri'ish description here"}),
),
) -> None:
"""
{{ MY_LOC_CMD }} Does absolutely nothing
Parameters
----------
auto: Autocompletes with numbers from 1-5
choice: Shows umlauts for german users {{CHOICE_PARAM}}
other: Another value
"""
await inter.response.send_message(f"```py\n{pformat(locals())}\n```")
@localized_command.autocomplete("auto")
async def autocomp(
self, inter: disnake.AppCmdInter, value: str
) -> "disnake.app_commands.Choices":
# not really autocomplete, only used for showing autocomplete localization
x = list(map(str, range(1, 6)))
random.shuffle(x)
return [Localized(v, key=f"AUTOCOMP_{v}") for v in x]
@commands.slash_command()
async def localized_top_level(self, inter: disnake.AppCmdInter) -> None:
pass
@localized_top_level.sub_command_group()
async def second(self, inter: disnake.AppCmdInter) -> None:
pass
@second.sub_command(
name=Localized(data={Locale.en_GB: "british_subcommand"}),
description=Localized(key="MY_SUBCMD_DESC"),
)
async def third(
self,
inter: disnake.AppCmdInter,
value: str = commands.Param(name=Localized("a_string", key="A_VERY_COOL_PARAM_NAME")),
) -> None:
await inter.response.send_message(f"```py\n{pformat(locals())}\n```")
# works for message/user commands as well
@commands.message_command(
name=Localized("Localized Reverse", key="MSG_REVERSE"),
)
async def cmd_msg(self, inter: disnake.AppCmdInter, msg: disnake.Message) -> None:
await inter.response.send_message(msg.content[::-1])
def setup(bot):
bot.add_cog(Localizations(bot))
print(f"> Extension {__name__} is ready\n")
|
438380
|
from config_base import ConfigurationBase
class ExtractKeywordsConfig(ConfigurationBase):
def __init__(self, config_file):
ConfigurationBase.__init__(self, config_file)
self.processed_documents_folder = self.__getfilepath__("DEFAULT", "processed_documents_folder")
self.file_mask = self.__getstring__("DEFAULT", "file_mask")
self.min_document_frequency = self.__getint__("DEFAULT", "min_document_frequency")
self.max_phrase_length = self.__getint__("DEFAULT", "max_phrase_length")
self.max_proportion_documents = self.__getfloat__("DEFAULT", "max_proportion_documents")
self.stop_words_file = self.__getstring__("DEFAULT", "stop_words_file")
self.keywords_file = self.__getstring__("DEFAULT", "keywords_file")
|
438383
|
from django.test import TestCase
from django.template import Context, Template
from django.template.loader import get_template
from taggit_templatetags.tests.models import AlphaModel, BetaModel
from taggit.tests.tests import BaseTaggingTest
from taggit_templatetags.templatetags.taggit_extras import get_weight_fun
class SetUpTestCase():
a_model = AlphaModel
b_model = BetaModel
def setUp(self):
a1 = self.a_model.objects.create(name="apple")
a2 = self.a_model.objects.create(name="pear")
b1 = self.b_model.objects.create(name="dog")
b2 = self.b_model.objects.create(name="kitty")
a1.tags.add("green")
a1.tags.add("sweet")
a1.tags.add("fresh")
a2.tags.add("yellow")
a2.tags.add("sour")
b1.tags.add("sweet")
b1.tags.add("yellow")
b2.tags.add("sweet")
b2.tags.add("green")
class TestWeightFun(TestCase):
def test_one(self):
t_min = 1
t_max = 6
f_min = 10
f_max = 20
weight_fun = get_weight_fun(t_min, t_max, f_min, f_max)
self.assertEqual(weight_fun(20), 6)
self.assertEqual(weight_fun(10), 1)
self.assertEqual(weight_fun(15), 3.5)
def test_two(self):
t_min = 10
t_max = 100
f_min = 5
f_max = 7
weight_fun = get_weight_fun(t_min, t_max, f_min, f_max)
self.assertEqual(weight_fun(5), 10)
self.assertEqual(weight_fun(7), 100)
self.assertEqual(weight_fun(6), 55)
class TemplateTagListTestCase(SetUpTestCase, BaseTaggingTest, TestCase):
def get_template(self, argument):
return """ {%% load taggit_extras %%}
{%% get_taglist %s %%}
""" % argument
def test_project(self):
t = Template(self.get_template("as taglist"))
c = Context({})
t.render(c)
self.assert_tags_equal(c.get("taglist"), ["sweet", "green", "yellow", "fresh", "sour"], False)
def test_app(self):
t = Template(self.get_template("as taglist for 'tests'"))
c = Context({})
t.render(c)
self.assert_tags_equal(c.get("taglist"), ["sweet", "green", "yellow", "fresh", "sour"], False)
def test_model(self):
t = Template(self.get_template("as taglist for 'tests.BetaModel'"))
c = Context({})
t.render(c)
self.assert_tags_equal(c.get("taglist"), ["sweet", "green", "yellow"], False)
class TemplateTagCloudTestCase(SetUpTestCase, BaseTaggingTest, TestCase):
def get_template(self, argument):
return """ {%% load taggit_extras %%}
{%% get_tagcloud %s %%}
""" % argument
def test_project(self):
t = Template(self.get_template("as taglist"))
c = Context({})
t.render(c)
self.assert_tags_equal(c.get("taglist"), ["fresh", "green", "sour", "sweet", "yellow"], False)
self.assertEqual(c.get("taglist")[3].name, "sweet")
self.assertEqual(c.get("taglist")[3].weight, 6.0)
self.assertEqual(c.get("taglist")[1].name, "green")
self.assertEqual(c.get("taglist")[1].weight, 3.5)
self.assertEqual(c.get("taglist")[2].name, "sour")
self.assertEqual(c.get("taglist")[2].weight, 1.0)
def test_app(self):
t = Template(self.get_template("as taglist for 'tests'"))
c = Context({})
t.render(c)
self.assert_tags_equal(c.get("taglist"), ["fresh", "green", "sour", "sweet", "yellow"], False)
self.assertEqual(c.get("taglist")[3].name, "sweet")
self.assertEqual(c.get("taglist")[3].weight, 6.0)
self.assertEqual(c.get("taglist")[1].name, "green")
self.assertEqual(c.get("taglist")[1].weight, 3.5)
self.assertEqual(c.get("taglist")[2].name, "sour")
self.assertEqual(c.get("taglist")[2].weight, 1.0)
def test_model(self):
t = Template(self.get_template("as taglist for 'tests.BetaModel'"))
c = Context({})
t.render(c)
self.assert_tags_equal(c.get("taglist"), ["green", "sweet", "yellow"], False)
self.assertEqual(c.get("taglist")[0].name, "green")
self.assertEqual(c.get("taglist")[0].weight, 1.0)
self.assertEqual(c.get("taglist")[1].name, "sweet")
self.assertEqual(c.get("taglist")[1].weight, 6.0)
self.assertEqual(c.get("taglist")[2].name, "yellow")
self.assertEqual(c.get("taglist")[2].weight, 1.0)
class TemplateInclusionTagTest(SetUpTestCase, TestCase, BaseTaggingTest):
def test_taglist_project(self):
t = get_template('taggit_templatetags/taglist_include.html')
c = Context({'forvar': None})
t.render(c)
self.assert_tags_equal(c.get("tags"), ["sweet", "green", "yellow", "fresh", "sour"], False)
def test_taglist_app(self):
t = get_template('taggit_templatetags/taglist_include.html')
c = Context({'forvar': 'tests'})
t.render(c)
self.assert_tags_equal(c.get("tags"), ["sweet", "green", "yellow", "fresh", "sour"], False)
def test_taglist_model(self):
t = get_template('taggit_templatetags/taglist_include.html')
c = Context({'forvar': 'tests.BetaModel'})
t.render(c)
self.assert_tags_equal(c.get("tags"), ["sweet", "green", "yellow"], False)
def test_tagcloud_project(self):
t = get_template('taggit_templatetags/tagcloud_include.html')
c = Context({'forvar': None})
t.render(c)
self.assert_tags_equal(c.get("tags"), ["fresh", "green", "sour", "sweet", "yellow"], False)
def test_tagcloud_app(self):
t = get_template('taggit_templatetags/tagcloud_include.html')
c = Context({'forvar': 'tests'})
t.render(c)
self.assert_tags_equal(c.get("tags"), ["fresh", "green", "sour", "sweet", "yellow"], False)
def test_tagcloud_model(self):
t = get_template('taggit_templatetags/tagcloud_include.html')
c = Context({'forvar': 'tests.BetaModel'})
t.render(c)
self.assert_tags_equal(c.get("tags"), ["green", "sweet", "yellow"], False)
class AlphaPathologicalCaseTestCase(TestCase, BaseTaggingTest):
"""
This is a testcase for one tag once.
"""
a_model = AlphaModel
def setUp(self):
a1 = self.a_model.objects.create(name="apple")
a1.tags.add("green")
def test_tagcloud(self):
t = get_template('taggit_templatetags/tagcloud_include.html')
c = Context({'forvar': None})
t.render(c)
self.assert_tags_equal(c.get("tags"), ["green"], False)
self.assertEqual(c.get("tags")[0].name, "green")
self.assertEqual(c.get("tags")[0].weight, 6.0)
class BetaPathologicalCaseTestCase(TestCase, BaseTaggingTest):
"""
This is a testcase for one tag thrice.
"""
a_model = AlphaModel
b_model = BetaModel
def setUp(self):
a1 = self.a_model.objects.create(name="apple")
a2 = self.a_model.objects.create(name="pear")
b1 = self.b_model.objects.create(name="dog")
a1.tags.add("green")
a2.tags.add("green")
b1.tags.add("green")
def test_tagcloud(self):
t = get_template('taggit_templatetags/tagcloud_include.html')
c = Context({'forvar': None})
t.render(c)
self.assert_tags_equal(c.get("tags"), ["green"], False)
self.assertEqual(c.get("tags")[0].name, "green")
self.assertEqual(c.get("tags")[0].weight, 6.0)
class GammaPathologicalCaseTestCase(TestCase, BaseTaggingTest):
"""
This is a pathological testcase for no tag at all.
"""
a_model = AlphaModel
b_model = BetaModel
def setUp(self):
a1 = self.a_model.objects.create(name="apple")
b1 = self.b_model.objects.create(name="dog")
def test_tagcloud(self):
t = get_template('taggit_templatetags/tagcloud_include.html')
c = Context({'forvar': None})
t.render(c)
self.assert_tags_equal(c.get("tags"), [], False)
|
438384
|
import magma as m
from mantle import *
from loam.boards.papilioone import PapilioOne
from loam.shields.megawing import MegaWing
megawing = MegaWing(PapilioOne)
megawing.Clock.on()
megawing.Switch.on(4)
megawing.LED.on(8)
main = megawing.main()
mux16test = Mux(16, 8)
A8 = Out(Bits(8))
muxinputs = [
A8(0,0,0,0,0,1,0,0),
A8(1,0,0,0,0,0,1,0),
A8(0,1,0,0,0,1,0,0),
A8(1,1,0,0,0,0,1,0),
A8(0,0,1,0,0,1,0,0),
A8(1,0,1,0,0,0,1,0),
A8(0,1,1,0,0,1,0,0),
A8(1,1,1,0,0,0,1,0),
A8(0,0,0,1,0,1,0,0),
A8(1,0,0,1,0,0,1,0),
A8(0,1,0,1,0,1,0,0),
A8(1,1,0,1,0,0,1,0),
A8(0,0,1,1,0,1,0,0),
A8(1,0,1,1,0,0,1,0),
A8(0,1,1,1,0,1,0,0),
A8(1,1,1,1,0,0,1,0)]
muxS = main.SWITCH[0:4]
mux16testO = mux16test(*(muxinputs + [muxS]))
wire(mux16testO, main.LED)
|
438441
|
from unittest import TestCase
from mock import Mock, MagicMock
from alarmdecoder import AlarmDecoder
from alarmdecoder.panels import ADEMCO
from alarmdecoder.messages import Message, ExpanderMessage
from alarmdecoder.zonetracking import Zonetracker, Zone
class TestZonetracking(TestCase):
def setUp(self):
self._alarmdecoder = Mock(spec=AlarmDecoder)
self._alarmdecoder.mode = ADEMCO
self._zonetracker = Zonetracker(self._alarmdecoder)
self._zonetracker.on_fault += self.fault_event
self._zonetracker.on_restore += self.restore_event
self._faulted = False
self._restored = False
def tearDown(self):
pass
### Library events
def fault_event(self, sender, *args, **kwargs):
self._faulted = True
def restore_event(self, sender, *args, **kwargs):
self._restored = True
### Util
def _build_expander_message(self, msg):
msg = ExpanderMessage(msg)
zone = self._zonetracker.expander_to_zone(msg.address, msg.channel)
return zone, msg
### Tests
def test_zone_fault(self):
zone, msg = self._build_expander_message('!EXP:07,01,01')
self._zonetracker.update(msg)
self.assertEqual(self._zonetracker._zones[zone].status, Zone.FAULT)
self.assertTrue(self._faulted)
def test_zone_restore(self):
zone, msg = self._build_expander_message('!EXP:07,01,01')
self._zonetracker.update(msg)
zone, msg = self._build_expander_message('!EXP:07,01,00')
self._zonetracker.update(msg)
self.assertEqual(self._zonetracker._zones[zone].status, Zone.CLEAR)
self.assertTrue(self._restored)
def test_message_ready(self):
msg = Message('[00000000000000100A--],001,[f707000600e5800c0c020000]," "')
self._zonetracker.update(msg)
self.assertEqual(len(self._zonetracker._zones_faulted), 1)
msg = Message('[10000000000000000A--],000,[f707000600e5800c0c020000]," "')
self._zonetracker.update(msg)
self.assertEqual(len(self._zonetracker._zones_faulted), 0)
def test_message_fault_text(self):
msg = Message('[00000000000000000A--],001,[f707000600e5800c0c020000],"FAULT 1 "')
self._zonetracker.update(msg)
self.assertEqual(len(self._zonetracker._zones_faulted), 1)
def test_ECP_failure(self):
msg = Message('[00000000000000100A--],0bf,[f707000600e5800c0c020000],"CHECK 1 "')
self._zonetracker.update(msg)
self.assertEqual(self._zonetracker._zones[1].status, Zone.CHECK)
def test_zone_restore_skip(self):
panel_messages = [
'[00000000000000000A--],001,[f707000600e5800c0c020000],"FAULT 1 "',
'[00000000000000000A--],002,[f707000600e5800c0c020000],"FAULT 2 "',
'[00000000000000000A--],001,[f707000600e5800c0c020000],"FAULT 1 "',
'[00000000000000000A--],001,[f707000600e5800c0c020000],"FAULT 1 "'
]
for m in panel_messages:
msg = Message(m)
self._zonetracker.update(msg)
self.assertIn(1, self._zonetracker._zones_faulted)
self.assertNotIn(2, self._zonetracker._zones_faulted)
def test_zone_out_of_order_fault(self):
panel_messages = [
'[00000000000000100A--],001,[f707000600e5800c0c020000],"FAULT 1 "',
'[00000000000000100A--],004,[f707000600e5800c0c020000],"FAULT 4 "',
'[00000000000000100A--],003,[f707000600e5800c0c020000],"FAULT 3 "',
'[00000000000000100A--],004,[f707000600e5800c0c020000],"FAULT 4 "',
]
for m in panel_messages:
msg = Message(m)
self._zonetracker.update(msg)
self.assertIn(1, self._zonetracker._zones_faulted)
self.assertIn(3, self._zonetracker._zones_faulted)
self.assertIn(4, self._zonetracker._zones_faulted)
def test_zone_multi_zone_skip_restore(self):
panel_messages = [
'[00000000000000100A--],001,[f707000600e5800c0c020000],"FAULT 1 "',
'[00000000000000100A--],004,[f707000600e5800c0c020000],"FAULT 4 "',
'[00000000000000100A--],002,[f707000600e5800c0c020000],"FAULT 2 "',
'[00000000000000100A--],004,[f707000600e5800c0c020000],"FAULT 4 "',
'[00000000000000100A--],004,[f707000600e5800c0c020000],"FAULT 4 "',
]
for m in panel_messages:
msg = Message(m)
self._zonetracker.update(msg)
self.assertNotIn(1, self._zonetracker._zones_faulted)
self.assertNotIn(2, self._zonetracker._zones_faulted)
self.assertIn(4, self._zonetracker._zones_faulted)
def test_zone_timeout_restore(self):
panel_messages = [
'[00000000000000100A--],001,[f707000600e5800c0c020000],"FAULT 1 "',
'[00000000000000100A--],004,[f707000600e5800c0c020000],"FAULT 4 "',
'[00000000000000100A--],002,[f707000600e5800c0c020000],"FAULT 2 "',
'[00000000000000100A--],004,[f707000600e5800c0c020000],"FAULT 4 "',
'[00000000000000100A--],004,[f707000600e5800c0c020000],"FAULT 4 "',
]
for m in panel_messages:
msg = Message(m)
self._zonetracker.update(msg)
self.assertIn(4, self._zonetracker._zones_faulted)
self._zonetracker._zones[4].timestamp -= 35 # forcefully expire the zone
# generic message to force an update.
msg = Message('[00000000000000000A--],000,[f707000600e5800c0c020000]," "')
self._zonetracker.update(msg)
self.assertNotIn(4, self._zonetracker._zones_faulted)
|
438470
|
from re import match
from consolemenu.validators.base import BaseValidator
class RegexValidator(BaseValidator):
def __init__(self, pattern):
super(RegexValidator, self).__init__()
self.__pattern = pattern
@property
def pattern(self):
return self.__pattern
def validate(self, input_string):
"""
Validate input_string against a regex pattern
:return: True if match / False otherwise
"""
validation_result = False
try:
validation_result = bool(match(pattern=self.pattern, string=input_string))
except TypeError as e:
self.log.error(
'Exception while validating Regex, pattern={}, input_string={} - exception: {}'.format(self.pattern,
input_string,
e))
return validation_result
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.